From d6be71567e7688531361f49d64f5cd85ec18585b Mon Sep 17 00:00:00 2001
From: Marco <marco.piraccini@gmail.com>
Date: Sun, 17 May 2026 23:34:51 +0200
Subject: [PATCH 01/83] test: relax min assertion in
 test-performance-eventloopdelay

Signed-off-by: marcopiraccini <marco.piraccini@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63100
Reviewed-By: Paolo Insogna <paolo@cowtech.it>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 test/sequential/test-performance-eventloopdelay.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/sequential/test-performance-eventloopdelay.js b/test/sequential/test-performance-eventloopdelay.js
index 72e6f7abfef3c2..66493318f5651d 100644
--- a/test/sequential/test-performance-eventloopdelay.js
+++ b/test/sequential/test-performance-eventloopdelay.js
@@ -71,7 +71,11 @@ const { sleep } = require('internal/util');
         // The values are non-deterministic, so we just check that a value is
         // present, as opposed to a specific value.
         assert(histogram.count > 0, `Expected samples to be recorded, got count=${histogram.count}`);
-        assert(histogram.min > 0);
+        // Min can legitimately be 0: the underlying HDR histogram has a
+        // lowest discernible value of 1us, so samples whose delta falls in
+        // the [0, 1us) bucket are reported as 0. A negative value would
+        // indicate a bug.
+        assert(histogram.min >= 0);
         assert(histogram.max > 0);
         assert(histogram.stddev > 0);
         assert(histogram.mean > 0);

From bc906671a8afce57a41ee981b198ebbc95b25087 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Sun, 17 May 2026 15:42:17 -0700
Subject: [PATCH 02/83] stream: fix merge handling for object-like sources
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

merge() treated any final non-iterable object as an options object.
That dropped valid from() inputs such as ArrayBuffer, ArrayBufferView,
and streamable protocol objects.

Fixes: https://github.com/nodejs/node/issues/63355

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63356
Fixes: https://github.com/nodejs/node/issues/63355
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: René <contact.9a5d6388@renegade334.me.uk>
---
 lib/internal/streams/iter/consumers.js        | 10 +++++++-
 .../test-stream-iter-consumers-merge.js       | 24 +++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/lib/internal/streams/iter/consumers.js b/lib/internal/streams/iter/consumers.js
index 442fe95b8e1b85..bcfe5d5ab29749 100644
--- a/lib/internal/streams/iter/consumers.js
+++ b/lib/internal/streams/iter/consumers.js
@@ -8,6 +8,7 @@
 // ondrain() - backpressure drain utility
 
 const {
+  ArrayBufferIsView,
   ArrayBufferPrototypeGetByteLength,
   ArrayBufferPrototypeSlice,
   ArrayPrototypeMap,
@@ -51,9 +52,12 @@ const {
 
 const {
   drainableProtocol,
+  toAsyncStreamable,
+  toStreamable,
 } = require('internal/streams/iter/types');
 
 const {
+  isAnyArrayBuffer,
   isSharedArrayBuffer,
 } = require('internal/util/types');
 
@@ -65,8 +69,12 @@ function isMergeOptions(value) {
   return (
     value !== null &&
     typeof value === 'object' &&
+    !ArrayBufferIsView(value) &&
+    typeof value[toStreamable] !== 'function' &&
+    typeof value[toAsyncStreamable] !== 'function' &&
     !isAsyncIterable(value) &&
-    !isSyncIterable(value)
+    !isSyncIterable(value) &&
+    !isAnyArrayBuffer(value)
   );
 }
 
diff --git a/test/parallel/test-stream-iter-consumers-merge.js b/test/parallel/test-stream-iter-consumers-merge.js
index ad047c0ffd7ed4..c5b18be042d874 100644
--- a/test/parallel/test-stream-iter-consumers-merge.js
+++ b/test/parallel/test-stream-iter-consumers-merge.js
@@ -9,6 +9,8 @@ const {
   push,
   merge,
   text,
+  toAsyncStreamable,
+  toStreamable,
 } = require('stream/iter');
 
 // =============================================================================
@@ -162,6 +164,27 @@ async function testMergeStringSources() {
   assert.ok(combined.includes('world'));
 }
 
+// merge() accepts object-like sources that are normalized via from()
+async function testMergeObjectLikeSources() {
+  const arrayBuffer = new TextEncoder().encode('abc').buffer;
+  const dataView = new DataView(new TextEncoder().encode('def').buffer);
+  const streamable = {
+    [toStreamable]() {
+      return 'ghi';
+    },
+  };
+  const asyncStreamable = {
+    [toAsyncStreamable]() {
+      return Promise.resolve('jkl');
+    },
+  };
+
+  assert.strictEqual(await text(merge(arrayBuffer)), 'abc');
+  assert.strictEqual(await text(merge(dataView)), 'def');
+  assert.strictEqual(await text(merge(streamable)), 'ghi');
+  assert.strictEqual(await text(merge(asyncStreamable)), 'jkl');
+}
+
 Promise.all([
   testMergeTwoSources(),
   testMergeSingleSource(),
@@ -172,4 +195,5 @@ Promise.all([
   testMergeConsumerBreak(),
   testMergeSignalMidIteration(),
   testMergeStringSources(),
+  testMergeObjectLikeSources(),
 ]).then(common.mustCall());

From 1f371fcffbd6424187ee478f20810255c4a9efea Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Sun, 17 May 2026 16:06:55 -0700
Subject: [PATCH 03/83] stream: add sync iterable fast path to pipeTo

Avoid normalizing sync iterable sources through from() when pipeTo()
has no transforms or signal and the writer can accept sync writes.
This keeps writes incremental while preserving async fallback for
values that still need it.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63318
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
---
 benchmark/streams/iter-throughput-pipeto.js | 27 +++++++-
 lib/internal/streams/iter/pull.js           | 58 ++++++++++++++--
 test/parallel/test-stream-iter-pipeto.js    | 76 +++++++++++++++++++++
 3 files changed, 155 insertions(+), 6 deletions(-)

diff --git a/benchmark/streams/iter-throughput-pipeto.js b/benchmark/streams/iter-throughput-pipeto.js
index 117a78aead1088..819d5e22a8a272 100644
--- a/benchmark/streams/iter-throughput-pipeto.js
+++ b/benchmark/streams/iter-throughput-pipeto.js
@@ -6,7 +6,7 @@ const common = require('../common.js');
 const { Readable, Writable, pipeline } = require('stream');
 
 const bench = common.createBenchmark(main, {
-  api: ['classic', 'webstream', 'iter', 'iter-sync'],
+  api: ['classic', 'webstream', 'iter', 'iter-sync-source', 'iter-sync'],
   datasize: [1024 * 1024, 16 * 1024 * 1024, 64 * 1024 * 1024],
   n: [5],
 }, {
@@ -26,6 +26,8 @@ function main({ api, datasize, n }) {
       return benchWebStream(chunk, datasize, n, totalOps);
     case 'iter':
       return benchIter(chunk, datasize, n, totalOps);
+    case 'iter-sync-source':
+      return benchIterSyncSource(chunk, datasize, n, totalOps);
     case 'iter-sync':
       return benchIterSync(chunk, datasize, n, totalOps);
   }
@@ -101,6 +103,29 @@ function benchIter(chunk, datasize, n, totalOps) {
   })();
 }
 
+function benchIterSyncSource(chunk, datasize, n, totalOps) {
+  const { pipeTo } = require('stream/iter');
+
+  async function run() {
+    let remaining = datasize;
+    function* source() {
+      while (remaining > 0) {
+        const size = Math.min(remaining, chunk.length);
+        remaining -= size;
+        yield size === chunk.length ? chunk : chunk.subarray(0, size);
+      }
+    }
+    const writer = { write() {}, writeSync() { return true; } };
+    await pipeTo(source(), writer);
+  }
+
+  (async () => {
+    bench.start();
+    for (let i = 0; i < n; i++) await run();
+    bench.end(totalOps);
+  })();
+}
+
 function benchIterSync(chunk, datasize, n, totalOps) {
   const { pipeToSync } = require('stream/iter');
 
diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js
index 5b004c58a5e995..3ff88b251d182a 100644
--- a/lib/internal/streams/iter/pull.js
+++ b/lib/internal/streams/iter/pull.js
@@ -8,6 +8,8 @@
 
 const {
   ArrayBufferIsView,
+  ArrayFromAsync,
+  ArrayIsArray,
   ArrayPrototypePush,
   ArrayPrototypeSlice,
   PromisePrototypeThen,
@@ -38,7 +40,9 @@ const {
   fromSync,
   isSyncIterable,
   isAsyncIterable,
+  isPrimitiveChunk,
   isUint8ArrayBatch,
+  normalizeAsyncValue,
 } = require('internal/streams/iter/from');
 
 const {
@@ -53,7 +57,10 @@ const {
 const {
   drainableProtocol,
   kSyncWriteAcceptedOnFalse,
+  kValidatedSource,
   kValidatedTransform,
+  toAsyncStreamable,
+  toStreamable,
 } = require('internal/streams/iter/types');
 
 // =============================================================================
@@ -116,6 +123,22 @@ function parsePipeToArgs(args, requiredMethod) {
   };
 }
 
+function canUseSyncIterablePipeToFastPath(source, transforms, signal) {
+  if (signal !== undefined ||
+      transforms.length !== 0 ||
+      isPrimitiveChunk(source) ||
+      ArrayIsArray(source) ||
+      source?.[kValidatedSource] ||
+      !isSyncIterable(source) ||
+      isAsyncIterable(source)) {
+    return false;
+  }
+
+  // Preserve from()'s top-level protocol precedence for custom iterables.
+  return typeof source[toAsyncStreamable] !== 'function' &&
+    typeof source[toStreamable] !== 'function';
+}
+
 // =============================================================================
 // Transform Output Flattening
 // =============================================================================
@@ -822,12 +845,13 @@ async function pipeTo(source, ...args) {
   // Check for abort
   signal?.throwIfAborted();
 
-  // Normalize source via from()
-  const normalized = from(source);
+  const hasWriteSync = typeof writer.writeSync === 'function';
+  const useSyncIterableFastPath =
+    hasWriteSync && canUseSyncIterablePipeToFastPath(source, transforms, signal);
+  const normalized = useSyncIterableFastPath ? undefined : from(source);
 
   let totalBytes = 0;
   const hasWritev = typeof writer.writev === 'function';
-  const hasWriteSync = typeof writer.writeSync === 'function';
   const hasWritevSync = typeof writer.writevSync === 'function';
   const hasEndSync = typeof writer.endSync === 'function';
   const syncFalseCanBeAccepted = writer[kSyncWriteAcceptedOnFalse] === true;
@@ -908,8 +932,32 @@ async function pipeTo(source, ...args) {
   }
 
   try {
-    // Fast path: no transforms - iterate normalized source directly
-    if (transforms.length === 0) {
+    if (useSyncIterableFastPath) {
+      // Avoid from()'s async sync-iterable batching path. This keeps writes
+      // incremental for synchronous sources while preserving async
+      // normalization for non-primitive yielded values.
+      for (const value of source) {
+        if (isUint8ArrayBatch(value)) {
+          if (value.length > 0) {
+            const p = writeBatch(value);
+            if (p) await p;
+          }
+          continue;
+        }
+        if (isUint8Array(value)) {
+          const p = writeBatch([value]);
+          if (p) await p;
+          continue;
+        }
+
+        const batch = await ArrayFromAsync(normalizeAsyncValue(value));
+        if (batch.length > 0) {
+          const p = writeBatch(batch);
+          if (p) await p;
+        }
+      }
+    } else if (transforms.length === 0) {
+      // Fast path: no transforms - iterate normalized source directly
       if (signal) {
         for await (const batch of normalized) {
           signal.throwIfAborted();
diff --git a/test/parallel/test-stream-iter-pipeto.js b/test/parallel/test-stream-iter-pipeto.js
index 9845a5ba254efb..bc6fa9d4984233 100644
--- a/test/parallel/test-stream-iter-pipeto.js
+++ b/test/parallel/test-stream-iter-pipeto.js
@@ -219,6 +219,79 @@ async function testPipeToSyncMinimalWriter() {
   assert.strictEqual(chunks.length > 0, true);
 }
 
+async function testPipeToSyncIterableFastPathWritesIncrementally() {
+  let pulled = 0;
+  let firstWritePulled = 0;
+  const chunks = [];
+  function* source() {
+    for (let i = 0; i < 3; i++) {
+      pulled++;
+      yield new Uint8Array([0x61 + i]);
+    }
+  }
+  const writer = {
+    write: common.mustNotCall(),
+    writeSync(chunk) {
+      if (firstWritePulled === 0) {
+        firstWritePulled = pulled;
+      }
+      chunks.push(chunk);
+      return true;
+    },
+  };
+
+  const totalBytes = await pipeTo(source(), writer);
+  assert.strictEqual(totalBytes, 3);
+  assert.strictEqual(firstWritePulled, 1);
+  assert.deepStrictEqual(chunks, [
+    new Uint8Array([0x61]),
+    new Uint8Array([0x62]),
+    new Uint8Array([0x63]),
+  ]);
+}
+
+async function testPipeToSyncIterableFastPathWriteFallback() {
+  const asyncWrites = [];
+  const writer = {
+    writeSync(chunk) {
+      return chunk[0] !== 0x62;
+    },
+    async write(chunk) {
+      asyncWrites.push(chunk);
+    },
+  };
+  function* source() {
+    yield new Uint8Array([0x61]);
+    yield new Uint8Array([0x62]);
+    yield new Uint8Array([0x63]);
+  }
+
+  const totalBytes = await pipeTo(source(), writer);
+  assert.strictEqual(totalBytes, 3);
+  assert.deepStrictEqual(asyncWrites, [new Uint8Array([0x62])]);
+}
+
+async function testPipeToSyncIterableFastPathAsyncValue() {
+  const chunks = [];
+  const writer = {
+    write: common.mustNotCall(),
+    writeSync(chunk) {
+      chunks.push(chunk);
+      return true;
+    },
+  };
+  function* source() {
+    yield Promise.resolve('a');
+    yield new Uint8Array([0x62]);
+  }
+
+  const totalBytes = await pipeTo(source(), writer);
+  assert.strictEqual(totalBytes, 2);
+  const result = new TextDecoder().decode(
+    new Uint8Array(chunks.reduce((acc, c) => [...acc, ...c], [])));
+  assert.strictEqual(result, 'ab');
+}
+
 Promise.all([
   testPipeToSync(),
   testPipeTo(),
@@ -234,4 +307,7 @@ Promise.all([
   testPipeToSyncPreventClose(),
   testPipeToMinimalWriter(),
   testPipeToSyncMinimalWriter(),
+  testPipeToSyncIterableFastPathWritesIncrementally(),
+  testPipeToSyncIterableFastPathWriteFallback(),
+  testPipeToSyncIterableFastPathAsyncValue(),
 ]).then(common.mustCall());

From debe2ed2efd377d301282e4c64489ca2a9d7b028 Mon Sep 17 00:00:00 2001
From: Ali Hassan <24819103+thisalihassan@users.noreply.github.com>
Date: Mon, 18 May 2026 12:54:35 +0500
Subject: [PATCH 04/83] test_runner: avoid hanging on incomplete v8 frames

Signed-off-by: Ali Hassan <ali-hassan27@outlook.com>
PR-URL: https://github.com/nodejs/node/pull/62704
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
---
 lib/internal/test_runner/runner.js            | 54 ++++++++++--
 test/parallel/test-runner-v8-deserializer.mjs | 88 ++++++++++++++++---
 2 files changed, 124 insertions(+), 18 deletions(-)

diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js
index 1b0dfb51b21fbe..d6cb6438d2b52a 100644
--- a/lib/internal/test_runner/runner.js
+++ b/lib/internal/test_runner/runner.js
@@ -25,6 +25,7 @@ const {
   SafePromiseAllSettledReturnVoid,
   SafeSet,
   String,
+  StringFromCharCode,
   StringPrototypeIndexOf,
   StringPrototypeSlice,
   StringPrototypeStartsWith,
@@ -261,6 +262,7 @@ class FileTest extends Test {
   #rawBuffer = []; // Raw data waiting to be parsed
   #rawBufferSize = 0;
   #reportedChildren = 0;
+  #pendingPartialV8Header = false;
   failedSubtests = false;
 
   constructor(options) {
@@ -352,6 +354,12 @@ class FileTest extends Test {
   }
   parseMessage(readData) {
     let dataLength = TypedArrayPrototypeGetLength(readData);
+    if (this.#pendingPartialV8Header) {
+      readData = Buffer.concat([TypedArrayPrototypeSubarray(v8Header, 0, 1), readData]);
+      dataLength = TypedArrayPrototypeGetLength(readData);
+      this.#pendingPartialV8Header = false;
+    }
+
     if (dataLength === 0) return;
     const partialV8Header = readData[dataLength - 1] === v8Header[0];
 
@@ -362,22 +370,52 @@ class FileTest extends Test {
       dataLength--;
     }
 
-    if (this.#rawBuffer[0] && TypedArrayPrototypeGetLength(this.#rawBuffer[0]) < kSerializedSizeHeader) {
-      this.#rawBuffer[0] = Buffer.concat([this.#rawBuffer[0], readData]);
-    } else {
-      ArrayPrototypePush(this.#rawBuffer, readData);
+    if (dataLength > 0) {
+      if (this.#rawBuffer[0] && TypedArrayPrototypeGetLength(this.#rawBuffer[0]) < kSerializedSizeHeader) {
+        this.#rawBuffer[0] = Buffer.concat([this.#rawBuffer[0], readData]);
+      } else {
+        ArrayPrototypePush(this.#rawBuffer, readData);
+      }
+      this.#rawBufferSize += dataLength;
+      this.#processRawBuffer();
     }
-    this.#rawBufferSize += dataLength;
-    this.#processRawBuffer();
 
     if (partialV8Header) {
-      ArrayPrototypePush(this.#rawBuffer, TypedArrayPrototypeSubarray(v8Header, 0, 1));
-      this.#rawBufferSize++;
+      this.#pendingPartialV8Header = true;
     }
   }
   #drainRawBuffer() {
+    if (this.#pendingPartialV8Header) {
+      ArrayPrototypePush(this.#rawBuffer, TypedArrayPrototypeSubarray(v8Header, 0, 1));
+      this.#rawBufferSize++;
+      this.#pendingPartialV8Header = false;
+    }
+
     while (this.#rawBuffer.length > 0) {
+      const prevBufferLength = this.#rawBuffer.length;
+      const prevBufferSize = this.#rawBufferSize;
       this.#processRawBuffer();
+
+      if (this.#rawBuffer.length === prevBufferLength &&
+          this.#rawBufferSize === prevBufferSize) {
+        const bufferHead = this.#rawBuffer[0];
+        this.addToReport({
+          __proto__: null,
+          type: 'test:stdout',
+          data: {
+            __proto__: null,
+            file: this.name,
+            message: StringFromCharCode(bufferHead[0]),
+          },
+        });
+
+        if (TypedArrayPrototypeGetLength(bufferHead) === 1) {
+          ArrayPrototypeShift(this.#rawBuffer);
+        } else {
+          this.#rawBuffer[0] = TypedArrayPrototypeSubarray(bufferHead, 1);
+        }
+        this.#rawBufferSize--;
+      }
     }
   }
   #processRawBuffer() {
diff --git a/test/parallel/test-runner-v8-deserializer.mjs b/test/parallel/test-runner-v8-deserializer.mjs
index 0f6fea1e64b58d..5e50df441da59e 100644
--- a/test/parallel/test-runner-v8-deserializer.mjs
+++ b/test/parallel/test-runner-v8-deserializer.mjs
@@ -14,12 +14,29 @@ async function toArray(chunks) {
   return arr;
 }
 
-const chunks = await toArray(serializer([
-  { type: 'test:diagnostic', data: { nesting: 0, details: {}, message: 'diagnostic' } },
-]));
+const diagnosticEvent = {
+  type: 'test:diagnostic',
+  data: { nesting: 0, details: {}, message: 'diagnostic' },
+};
+const chunks = await toArray(serializer([diagnosticEvent]));
 const defaultSerializer = new DefaultSerializer();
 defaultSerializer.writeHeader();
 const headerLength = defaultSerializer.releaseBuffer().length;
+const headerOnly = Buffer.from([0xff, 0x0f]);
+const oversizedLengthHeader = Buffer.from([0xff, 0x0f, 0x7f, 0xff, 0xff, 0xff]);
+const truncatedLengthHeader = Buffer.from([0xff, 0x0f, 0x00, 0x01, 0x00, 0x00]);
+// Expected stdout for oversizedLengthHeader: first byte is emitted via
+// String.fromCharCode (byte-by-byte fallback in #drainRawBuffer), remaining
+// bytes go through the nonSerialized UTF-8 decode path in #processRawBuffer.
+const oversizedLengthStdout = String.fromCharCode(oversizedLengthHeader[0]) +
+  Buffer.from(oversizedLengthHeader.subarray(1)).toString('utf-8');
+
+function collectStdout(reported) {
+  return reported
+    .filter((event) => event.type === 'test:stdout')
+    .map((event) => event.data.message)
+    .join('');
+}
 
 describe('v8 deserializer', common.mustCall(() => {
   let fileTest;
@@ -56,27 +73,78 @@ describe('v8 deserializer', common.mustCall(() => {
 
   it('should deserialize a serialized chunk', async () => {
     const reported = await collectReported(chunks);
-    assert.deepStrictEqual(reported, [
-      { data: { nesting: 0, details: {}, message: 'diagnostic' }, type: 'test:diagnostic' },
-    ]);
+    assert.deepStrictEqual(reported, [diagnosticEvent]);
   });
 
   it('should deserialize a serialized chunk after non-serialized chunk', async () => {
     const reported = await collectReported([Buffer.concat([Buffer.from('unknown'), ...chunks])]);
     assert.deepStrictEqual(reported, [
       { data: { __proto__: null, file: 'filetest', message: 'unknown' }, type: 'test:stdout' },
-      { data: { nesting: 0, details: {}, message: 'diagnostic' }, type: 'test:diagnostic' },
+      diagnosticEvent,
     ]);
   });
 
   it('should deserialize a serialized chunk before non-serialized output', async () => {
     const reported = await collectReported([Buffer.concat([ ...chunks, Buffer.from('unknown')])]);
     assert.deepStrictEqual(reported, [
-      { data: { nesting: 0, details: {}, message: 'diagnostic' }, type: 'test:diagnostic' },
+      diagnosticEvent,
       { data: { __proto__: null, file: 'filetest', message: 'unknown' }, type: 'test:stdout' },
     ]);
   });
 
+  it('should not hang when buffer starts with v8Header followed by oversized length', async () => {
+    // Regression test for https://github.com/nodejs/node/issues/62693
+    // FF 0F is the v8 serializer header; the next 4 bytes are read as a
+    // big-endian message size.  0x7FFFFFFF far exceeds any actual buffer
+    // size, causing #processRawBuffer to make no progress and
+    // #drainRawBuffer to loop forever without the no-progress guard.
+    const reported = await collectReported([oversizedLengthHeader]);
+    assert.partialDeepStrictEqual(
+      reported,
+      Array.from({ length: reported.length }, () => ({ type: 'test:stdout' })),
+    );
+    assert.strictEqual(collectStdout(reported), oversizedLengthStdout);
+  });
+
+  it('should flush incomplete v8 frame as stdout and keep prior valid data', async () => {
+    // A valid non-serialized message followed by bytes that look like
+    // a v8 header with a truncated/oversized length.
+    const reported = await collectReported([
+      Buffer.from('hello'),
+      truncatedLengthHeader,
+    ]);
+    assert.strictEqual(collectStdout(reported), `hello${truncatedLengthHeader.toString('latin1')}`);
+  });
+
+  it('should flush v8Header-only bytes as stdout when stream ends', async () => {
+    // Just the two-byte v8 header with no size field at all.
+    const reported = await collectReported([headerOnly]);
+    assert(reported.every((event) => event.type === 'test:stdout'));
+    assert.strictEqual(collectStdout(reported), headerOnly.toString('latin1'));
+  });
+
+  it('should resync and parse valid messages after false v8 header', async () => {
+    // A false v8 header (FF 0F + oversized length) followed by a
+    // legitimate serialized message. The parser must skip the corrupt
+    // bytes and still deserialize the real message.
+    const reported = await collectReported([
+      oversizedLengthHeader,
+      ...chunks,
+    ]);
+    assert.deepStrictEqual(reported.at(-1), diagnosticEvent);
+    assert.strictEqual(reported.filter((event) => event.type === 'test:diagnostic').length, 1);
+    assert.strictEqual(collectStdout(reported), oversizedLengthStdout);
+  });
+
+  it('should preserve a false v8 header split across chunks', async () => {
+    const reported = await collectReported([
+      oversizedLengthHeader.subarray(0, 1),
+      oversizedLengthHeader.subarray(1),
+    ]);
+    assert(reported.every((event) => event.type === 'test:stdout'));
+    assert.strictEqual(collectStdout(reported), oversizedLengthStdout);
+  });
+
   const headerPosition = headerLength * 2 + 4;
   for (let i = 0; i < headerPosition + 5; i++) {
     const message = `should deserialize a serialized message split into two chunks {...${i},${i + 1}...}`;
@@ -84,7 +152,7 @@ describe('v8 deserializer', common.mustCall(() => {
       const data = chunks[0];
       const reported = await collectReported([data.subarray(0, i), data.subarray(i)]);
       assert.deepStrictEqual(reported, [
-        { data: { nesting: 0, details: {}, message: 'diagnostic' }, type: 'test:diagnostic' },
+        diagnosticEvent,
       ]);
     });
 
@@ -96,7 +164,7 @@ describe('v8 deserializer', common.mustCall(() => {
       ]);
       assert.deepStrictEqual(reported, [
         { data: { __proto__: null, file: 'filetest', message: 'unknown' }, type: 'test:stdout' },
-        { data: { nesting: 0, details: {}, message: 'diagnostic' }, type: 'test:diagnostic' },
+        diagnosticEvent,
         { data: { __proto__: null, file: 'filetest', message: 'unknown' }, type: 'test:stdout' },
       ]);
     }

From 3b19867caaef6b85c65e44dc60274dce2b240d22 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Mon, 18 May 2026 03:42:45 -0700
Subject: [PATCH 05/83] benchmark: respect stream/iter broadcast backpressure

Only decrement the remaining byte count after a stream/iter broadcast
write is accepted. If writeSync() is blocked by strict backpressure,
fall back to the async write() path for the same chunk.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63314
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 benchmark/streams/iter-throughput-broadcast.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/benchmark/streams/iter-throughput-broadcast.js b/benchmark/streams/iter-throughput-broadcast.js
index 459d78e7c75f25..c5bbac9306777e 100644
--- a/benchmark/streams/iter-throughput-broadcast.js
+++ b/benchmark/streams/iter-throughput-broadcast.js
@@ -128,9 +128,11 @@ function benchIter(chunk, numConsumers, datasize, n, totalOps) {
     let remaining = datasize;
     while (remaining > 0) {
       const size = Math.min(remaining, chunk.length);
-      remaining -= size;
       const buf = size === chunk.length ? chunk : chunk.subarray(0, size);
-      writer.writeSync(buf);
+      if (!writer.writeSync(buf)) {
+        await writer.write(buf);
+      }
+      remaining -= size;
     }
     writer.endSync();
 

From f2aaf638465db9a545f33a6bfb416ffd952ffba3 Mon Sep 17 00:00:00 2001
From: Matteo Collina <hello@matteocollina.com>
Date: Mon, 18 May 2026 19:45:55 +0200
Subject: [PATCH 06/83] test: fix flaky test-watch-mode-inspect timeout

This test randomly times out (~120s) on CI due to a race condition
between child-process restart (triggered by touching the watched file)
and the second inspector-session connection.

The old code used an interval-based restart (write every 500ms) and
a 'gettingDebuggedPid' flag to pause writes during a session. This
still left a race window where getDebuggedPid() would attempt to
connect the inspector via HTTP GET /json/list + WebSocket upgrade
either before the new child was ready (empty target list) or after
the old session was being destroyed, causing the promise to hang.

Fix: Replace the interval with a single write that triggers exactly
one restart, then wait for the restarted child's 'safe to debug now'
stdout line before connecting the second inspector session. This
eliminates the race by ensuring the new child process and its
inspector session are fully ready before any connection attempt.

Removes the now-unused gettingDebuggedPid flag and the pending
setTimeout delay that was needed as a backstop for the interval.

Fixes: https://github.com/nodejs/node/issues/44898
Signed-off-by: Matteo Collina <hello@matteocollina.com>
PR-URL: https://github.com/nodejs/node/pull/63361
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Paolo Insogna <paolo@cowtech.it>
---
 test/sequential/test-watch-mode-inspect.mjs | 27 +++++++++------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/test/sequential/test-watch-mode-inspect.mjs b/test/sequential/test-watch-mode-inspect.mjs
index f2886f11b56da4..d00036d3b859da 100644
--- a/test/sequential/test-watch-mode-inspect.mjs
+++ b/test/sequential/test-watch-mode-inspect.mjs
@@ -3,7 +3,6 @@ import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { writeFileSync, readFileSync } from 'node:fs';
-import { setTimeout } from 'node:timers/promises';
 import { NodeInstance } from '../common/inspector-helper.js';
 
 
@@ -12,10 +11,7 @@ if (common.isIBMi)
 
 common.skipIfInspectorDisabled();
 
-let gettingDebuggedPid = false;
-
 async function getDebuggedPid(instance, waitForLog = true) {
-  gettingDebuggedPid = true;
   const session = await instance.connectInspectorSession();
   await session.send({ method: 'Runtime.enable' });
   if (waitForLog) {
@@ -25,20 +21,23 @@ async function getDebuggedPid(instance, waitForLog = true) {
     'method': 'Runtime.evaluate', 'params': { 'expression': 'process.pid' },
   })).result;
   session.disconnect();
-  gettingDebuggedPid = false;
   return innerPid;
 }
 
-function restart(file) {
+// Triggers a single restart and resolves when the restarted child prints "safe to debug now".
+function restartAndWaitForReady(file, instance) {
+  const ready = new Promise((resolve) => {
+    instance.on('stdout', (data) => {
+      if (data?.includes('safe to debug now')) {
+        resolve();
+      }
+    });
+  });
   writeFileSync(file, readFileSync(file));
-  const interval = setInterval(() => {
-    if (!gettingDebuggedPid) {
-      writeFileSync(file, readFileSync(file));
-    }
-  }, common.platformTimeout(500));
-  return () => clearInterval(interval);
+  return ready;
 }
 
+
 describe('watch mode - inspect', () => {
   it('should start debugger on inner process', async () => {
     const file = fixtures.path('watch-mode/inspect.js');
@@ -51,11 +50,9 @@ describe('watch mode - inspect', () => {
     const pids = [instance.pid];
     pids.push(await getDebuggedPid(instance));
     instance.resetPort();
-    const stopRestarting = restart(file);
+    await restartAndWaitForReady(file, instance);
     pids.push(await getDebuggedPid(instance));
-    stopRestarting();
 
-    await setTimeout(common.platformTimeout(500));
     await instance.kill();
 
     // There should be a process per restart and one per parent process.

From 155268f786e58164bff31797b6442e8f50d3c269 Mon Sep 17 00:00:00 2001
From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
Date: Mon, 18 May 2026 19:46:09 +0200
Subject: [PATCH 07/83] doc: add Rust toolchain manual installation
 instructions Windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
PR-URL: https://github.com/nodejs/node/pull/63367
Refs: https://github.com/nodejs/node/issues/63225
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Stefan Stojanovic <stefan.stojanovic@janeasystems.com>
---
 BUILDING.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/BUILDING.md b/BUILDING.md
index 7597f0114e7f76..5cf5e9f57d6753 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -755,6 +755,10 @@ Refs:
 * As an alternative to Visual Studio 2026, download Visual Studio 2022 Current channel Version 17.14 from the
   [Evergreen bootstrappers](https://learn.microsoft.com/en-us/visualstudio/releases/2022/release-history#evergreen-bootstrappers)
   table and install using the same workload and optional component selection as described above.
+* To install the Rust toolchain, required for Temporal support introduced in Node.js 26,
+  ensure Visual Studio is already installed, then run `rustup-init.exe` downloaded from
+  [Install Rust](https://rust-lang.org/tools/install/),
+  choosing the default: "Proceed with standard installation".
 * Basic Unix tools required for some tests,
   [Git for Windows](https://git-scm.com/download/win) includes Git Bash
   and tools which can be included in the global `PATH`.

From 4ee756741b41592ad80bfb7d95d0011d756ed744 Mon Sep 17 00:00:00 2001
From: Livia Medeiros <livia@cirno.name>
Date: Tue, 19 May 2026 06:18:00 +0800
Subject: [PATCH 08/83] fs: add `Temporal.Instant` support to `Stats` and
 `BigIntStats`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: LiviaMedeiros <livia@cirno.name>
PR-URL: https://github.com/nodejs/node/pull/60789
Refs: https://github.com/nodejs/node/issues/57891
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: René <contact.9a5d6388@renegade334.me.uk>
---
 doc/api/errors.md                       |  13 ++
 doc/api/fs.md                           |  37 +++++-
 lib/internal/errors.js                  |   2 +
 lib/internal/fs/utils.js                | 154 ++++++++++++++++++++++--
 test/parallel/test-fs-stat-temporal.mjs | 105 ++++++++++++++++
 test/parallel/test-fs-watchfile.js      |  12 +-
 6 files changed, 304 insertions(+), 19 deletions(-)
 create mode 100644 test/parallel/test-fs-stat-temporal.mjs

diff --git a/doc/api/errors.md b/doc/api/errors.md
index f2aafb1b165ca7..8e0956c29f3843 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -2465,6 +2465,18 @@ OpenSSL crypto support.
 An attempt was made to use features that require [ICU][], but Node.js was not
 compiled with ICU support.
 
+<a id="ERR_NO_TEMPORAL"></a>
+
+### `ERR_NO_TEMPORAL`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+An attempt was made to use features that require [`Temporal`][], but Node.js was not
+compiled with `Temporal` support or it has been disabled in the current environment
+(for example, when running with `--no-harmony-temporal`).
+
 <a id="ERR_NO_TYPESCRIPT"></a>
 
 ### `ERR_NO_TYPESCRIPT`
@@ -4472,6 +4484,7 @@ An error occurred trying to allocate memory. This should never happen.
 [`QuicError`]: quic.md#class-quicerror
 [`REPL`]: repl.md
 [`ServerResponse`]: http.md#class-httpserverresponse
+[`Temporal`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal
 [`Writable`]: stream.md#class-streamwritable
 [`child_process`]: child_process.md
 [`cipher.getAuthTag()`]: crypto.md#ciphergetauthtag
diff --git a/doc/api/fs.md b/doc/api/fs.md
index c5e908aaa39f6c..884e5935219b67 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -4799,7 +4799,11 @@ Stats {
   atime: 2019-06-22T03:37:33.072Z,
   mtime: 2019-06-22T03:36:54.583Z,
   ctime: 2019-06-22T03:37:06.624Z,
-  birthtime: 2019-06-22T03:28:46.937Z
+  birthtime: 2019-06-22T03:28:46.937Z,
+  atimeInstant: 2019-06-22T03:37:33.071963Z,
+  mtimeInstant: 2019-06-22T03:36:54.5833518Z,
+  ctimeInstant: 2019-06-22T03:37:06.6235366Z,
+  birthtimeInstant: 2019-06-22T03:28:46.9372893Z
 }
 false
 Stats {
@@ -4820,7 +4824,11 @@ Stats {
   atime: 2019-06-22T03:36:56.619Z,
   mtime: 2019-06-22T03:36:54.584Z,
   ctime: 2019-06-22T03:36:54.584Z,
-  birthtime: 2019-06-22T03:26:47.711Z
+  birthtime: 2019-06-22T03:26:47.711Z,
+  atimeInstant: 2019-06-22T03:36:56.6188555Z,
+  mtimeInstant: 2019-06-22T03:36:54.584Z,
+  ctimeInstant: 2019-06-22T03:36:54.5838145Z,
+  birthtimeInstant: 2019-06-22T03:26:47.7107478Z
 }
 ```
 
@@ -7525,6 +7533,9 @@ i.e. before the `'ready'` event is emitted.
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/60789
+    description: Added `Temporal.Instant` support.
   - version:
     - v22.0.0
     - v20.13.0
@@ -7560,10 +7571,19 @@ Stats {
   mtimeMs: 1318289051000.1,
   ctimeMs: 1318289051000.1,
   birthtimeMs: 1318289051000.1,
+
+  // Instances of Date
   atime: Mon, 10 Oct 2011 23:24:11 GMT,
   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT,
+
+  // Instances of Temporal.Instant
+  atimeInstant: 2011-10-10T23:24:11.0001Z,
+  mtimeInstant: 2011-10-10T23:24:11.0001Z,
+  ctimeInstant: 2011-10-10T23:24:11.0001Z,
+  birthtimeInstant: 2011-10-10T23:24:11.0001Z
+}
 ```
 
 `bigint` version:
@@ -7588,10 +7608,19 @@ BigIntStats {
   mtimeNs: 1318289051000000000n,
   ctimeNs: 1318289051000000000n,
   birthtimeNs: 1318289051000000000n,
+
+  // Instances of Date
   atime: Mon, 10 Oct 2011 23:24:11 GMT,
   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
-  birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+  birthtime: Mon, 10 Oct 2011 23:24:11 GMT,
+
+  // Instances of Temporal.Instant
+  atimeInstant: 2011-10-10T23:24:11Z,
+  mtimeInstant: 2011-10-10T23:24:11Z,
+  ctimeInstant: 2011-10-10T23:24:11Z,
+  birthtimeInstant: 2011-10-10T23:24:11Z
+}
 ```
 
 #### `stats.isBlockDevice()`
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index a93bb57e6cf0ad..f989bc8fe60a6e 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -1639,6 +1639,8 @@ E('ERR_NO_CRYPTO',
   'Node.js is not compiled with OpenSSL crypto support', Error);
 E('ERR_NO_ICU',
   '%s is not supported on Node.js compiled without ICU', TypeError);
+E('ERR_NO_TEMPORAL',
+  'Temporal is not supported in this environment', Error);
 E('ERR_NO_TYPESCRIPT',
   'Node.js is not compiled with TypeScript support', Error);
 E('ERR_OPERATION_FAILED', 'Operation failed: %s', Error, TypeError);
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index eaa9bd145b14cd..811c52aeffb8b9 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -8,6 +8,7 @@ const {
   DatePrototypeGetTime,
   ErrorCaptureStackTrace,
   FunctionPrototypeCall,
+  MathFloor,
   MathMin,
   MathRound,
   Number,
@@ -22,6 +23,7 @@ const {
   Symbol,
   TypedArrayPrototypeAt,
   TypedArrayPrototypeIncludes,
+  globalThis,
 } = primordials;
 
 const { Buffer } = require('buffer');
@@ -32,6 +34,7 @@ const {
     ERR_INCOMPATIBLE_OPTION_PAIR,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
+    ERR_NO_TEMPORAL,
     ERR_OUT_OF_RANGE,
   },
   hideStackFrames,
@@ -43,10 +46,10 @@ const {
   isUint8Array,
 } = require('internal/util/types');
 const {
-  kEmptyObject,
-  once,
   deprecate,
   isWindows,
+  kEmptyObject,
+  once,
   setOwnProperty,
 } = require('internal/util');
 const { toPathIfFileURL } = require('internal/url');
@@ -62,6 +65,10 @@ const {
 const pathModule = require('path');
 const kType = Symbol('type');
 const kStats = Symbol('stats');
+const kPartialAtimeNs = Symbol('partialAtimeNs');
+const kPartialMtimeNs = Symbol('partialMtimeNs');
+const kPartialCtimeNs = Symbol('partialCtimeNs');
+const kPartialBirthtimeNs = Symbol('kPartialBirthtimeNs');
 const assert = require('internal/assert');
 
 const {
@@ -430,6 +437,25 @@ function nsFromTimeSpecBigInt(sec, nsec) {
   return sec * kNsPerSecBigInt + nsec;
 }
 
+// TODO(LiviaMedeiros): TemporalInstant primordial
+let TemporalInstant;
+
+function instantFromNs(nsec) {
+  TemporalInstant ??= globalThis.Temporal?.Instant;
+  if (TemporalInstant === undefined) {
+    throw new ERR_NO_TEMPORAL();
+  }
+  return new TemporalInstant(nsec);
+}
+
+function instantFromTimeSpecMs(msec, nsec) {
+  TemporalInstant ??= globalThis.Temporal?.Instant;
+  if (TemporalInstant === undefined) {
+    throw new ERR_NO_TEMPORAL();
+  }
+  return new TemporalInstant(BigInt(MathFloor(msec / kMsPerSec)) * kNsPerSecBigInt + BigInt(nsec));
+}
+
 // The Date constructor performs Math.floor() on the absolute value
 // of the timestamp: https://tc39.es/ecma262/#sec-timeclip
 // Since there may be a precision loss when the timestamp is
@@ -490,6 +516,106 @@ const lazyDateFields = {
   },
 };
 
+const lazyTemporalFields = {
+  __proto__: null,
+  atimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'atimeInstant',
+                            instantFromTimeSpecMs(this.atimeMs, this[kPartialAtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'atimeInstant', value);
+    },
+  },
+  mtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'mtimeInstant',
+                            instantFromTimeSpecMs(this.mtimeMs, this[kPartialMtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'mtimeInstant', value);
+    },
+  },
+  ctimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'ctimeInstant',
+                            instantFromTimeSpecMs(this.ctimeMs, this[kPartialCtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'ctimeInstant', value);
+    },
+  },
+  birthtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'birthtimeInstant',
+                            instantFromTimeSpecMs(this.birthtimeMs, this[kPartialBirthtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'birthtimeInstant', value);
+    },
+  },
+};
+
+const lazyTemporalBigIntFields = {
+  __proto__: null,
+  atimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'atimeInstant', instantFromNs(this.atimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'atimeInstant', value);
+    },
+  },
+  mtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'mtimeInstant', instantFromNs(this.mtimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'mtimeInstant', value);
+    },
+  },
+  ctimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'ctimeInstant', instantFromNs(this.ctimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'ctimeInstant', value);
+    },
+  },
+  birthtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'birthtimeInstant', instantFromNs(this.birthtimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'birthtimeInstant', value);
+    },
+  },
+};
+
 function BigIntStats(dev, mode, nlink, uid, gid, rdev, blksize,
                      ino, size, blocks,
                      atimeNs, mtimeNs, ctimeNs, birthtimeNs) {
@@ -508,6 +634,7 @@ function BigIntStats(dev, mode, nlink, uid, gid, rdev, blksize,
 ObjectSetPrototypeOf(BigIntStats.prototype, StatsBase.prototype);
 ObjectSetPrototypeOf(BigIntStats, StatsBase);
 ObjectDefineProperties(BigIntStats.prototype, lazyDateFields);
+ObjectDefineProperties(BigIntStats.prototype, lazyTemporalBigIntFields);
 
 BigIntStats.prototype._checkModeProperty = function(property) {
   if (isWindows && (property === S_IFIFO || property === S_IFBLK ||
@@ -519,18 +646,23 @@ BigIntStats.prototype._checkModeProperty = function(property) {
 
 function Stats(dev, mode, nlink, uid, gid, rdev, blksize,
                ino, size, blocks,
-               atimeMs, mtimeMs, ctimeMs, birthtimeMs) {
+               atimeS, atimeNs, mtimeS, mtimeNs, ctimeS, ctimeNs, birthtimeS, birthtimeNs) {
   FunctionPrototypeCall(StatsBase, this, dev, mode, nlink, uid, gid, rdev,
                         blksize, ino, size, blocks);
-  this.atimeMs = atimeMs;
-  this.mtimeMs = mtimeMs;
-  this.ctimeMs = ctimeMs;
-  this.birthtimeMs = birthtimeMs;
+  this.atimeMs = msFromTimeSpec(atimeS, atimeNs);
+  this.mtimeMs = msFromTimeSpec(mtimeS, mtimeNs);
+  this.ctimeMs = msFromTimeSpec(ctimeS, ctimeNs);
+  this.birthtimeMs = msFromTimeSpec(birthtimeS, birthtimeNs);
+  this[kPartialAtimeNs] = atimeNs;
+  this[kPartialMtimeNs] = mtimeNs;
+  this[kPartialCtimeNs] = ctimeNs;
+  this[kPartialBirthtimeNs] = birthtimeNs;
 }
 
 ObjectSetPrototypeOf(Stats.prototype, StatsBase.prototype);
 ObjectSetPrototypeOf(Stats, StatsBase);
 ObjectDefineProperties(Stats.prototype, lazyDateFields);
+ObjectDefineProperties(Stats.prototype, lazyTemporalFields);
 
 Stats.prototype._checkModeProperty = function(property) {
   if (isWindows && (property === S_IFIFO || property === S_IFBLK ||
@@ -563,10 +695,10 @@ function getStatsFromBinding(stats, offset = 0) {
     stats[3 + offset], stats[4 + offset], stats[5 + offset],
     stats[6 + offset], stats[7 + offset], stats[8 + offset],
     stats[9 + offset],
-    msFromTimeSpec(stats[10 + offset], stats[11 + offset]),
-    msFromTimeSpec(stats[12 + offset], stats[13 + offset]),
-    msFromTimeSpec(stats[14 + offset], stats[15 + offset]),
-    msFromTimeSpec(stats[16 + offset], stats[17 + offset]),
+    stats[10 + offset], stats[11 + offset], // atime
+    stats[12 + offset], stats[13 + offset], // mtime
+    stats[14 + offset], stats[15 + offset], // ctime
+    stats[16 + offset], stats[17 + offset], // birthtime
   );
 }
 
diff --git a/test/parallel/test-fs-stat-temporal.mjs b/test/parallel/test-fs-stat-temporal.mjs
new file mode 100644
index 00000000000000..67443fc36c94ea
--- /dev/null
+++ b/test/parallel/test-fs-stat-temporal.mjs
@@ -0,0 +1,105 @@
+import * as common from '../common/index.mjs';
+
+// Test `Temporal.Instant`s returned by fsPromises.stat and fs.statSync
+
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import assert from 'node:assert';
+import tmpdir from '../common/tmpdir.js';
+
+if (!common.hasTemporal) {
+  common.skip('Temporal support unavailable');
+}
+
+// On some platforms (for example, ppc64) boundaries are tighter
+// than usual. If we catch these errors, skip corresponding test.
+const ignoredErrors = new Set(['EINVAL', 'EOVERFLOW']);
+
+tmpdir.refresh();
+const filepath = tmpdir.resolve('timestamp');
+
+await (await fsPromises.open(filepath, 'w')).close();
+
+// Perform a trivial check to determine if filesystem supports setting
+// and retrieving atime and mtime. If it doesn't, skip the test.
+await fsPromises.utimes(filepath, 2, 2);
+const { atimeMs, mtimeMs } = await fsPromises.stat(filepath);
+if (atimeMs !== 2000 || mtimeMs !== 2000) {
+  common.skip(`Unsupported filesystem (atimeMs=${atimeMs}, mtimeMs=${mtimeMs})`);
+}
+
+// Allow delta due to precision loss or platform-specific nuances
+function closeEnough(actual, expected, margin) {
+  // On ppc64, value is rounded to seconds
+  if (process.arch === 'ppc64') {
+    margin += 1000;
+  }
+
+  // Filesystems without support for timestamps before 1970-01-01, such as NFSv3,
+  // should return 0 for negative numbers. Do not treat it as error.
+  if (actual === 0 && expected < 0) {
+    console.log(`ignored 0 while expecting ${expected}`);
+    return;
+  }
+
+  assert.ok(Math.abs(Number(actual - expected)) < margin,
+            `expected ${expected} ± ${margin}, got ${actual}`);
+}
+
+// Ensure that accessed atime and mtime are enumerable
+function validateEnumerability(stats) {
+  const keys = Object.keys(stats);
+  assert.ok(keys.includes('atimeInstant'));
+  assert.ok(keys.includes('mtimeInstant'));
+}
+
+async function runTest(atimeMs, mtimeMs, margin = 0) {
+  margin += Number.EPSILON;
+
+  // TODO(LiviaMedeiros): use bigint nanoseconds once `utimes()` supports Temporal
+  const atime = atimeMs / 1000;
+  const mtime = mtimeMs / 1000;
+  try {
+    await fsPromises.utimes(filepath, atime, mtime);
+  } catch (e) {
+    if (ignoredErrors.has(e.code)) return;
+    throw e;
+  }
+
+  const stats = await fsPromises.stat(filepath);
+  closeEnough(stats.atimeMs, atimeMs, margin);
+  closeEnough(stats.mtimeMs, mtimeMs, margin);
+  closeEnough(stats.atimeInstant.epochMilliseconds, atimeMs, margin);
+  closeEnough(stats.mtimeInstant.epochMilliseconds, mtimeMs, margin);
+  validateEnumerability(stats);
+
+  const statsBigint = await fsPromises.stat(filepath, { bigint: true });
+  closeEnough(statsBigint.atimeMs, BigInt(atimeMs), margin);
+  closeEnough(statsBigint.mtimeMs, BigInt(mtimeMs), margin);
+  closeEnough(statsBigint.atimeInstant.epochMilliseconds, atimeMs, margin);
+  closeEnough(statsBigint.mtimeInstant.epochMilliseconds, mtimeMs, margin);
+  validateEnumerability(statsBigint);
+
+  const statsSync = fs.statSync(filepath);
+  closeEnough(statsSync.atimeMs, atimeMs, margin);
+  closeEnough(statsSync.mtimeMs, mtimeMs, margin);
+  closeEnough(statsSync.atimeInstant.epochMilliseconds, atimeMs, margin);
+  closeEnough(statsSync.mtimeInstant.epochMilliseconds, mtimeMs, margin);
+  validateEnumerability(statsSync);
+
+  const statsSyncBigint = fs.statSync(filepath, { bigint: true });
+  closeEnough(statsSyncBigint.atimeMs, BigInt(atimeMs), margin);
+  closeEnough(statsSyncBigint.mtimeMs, BigInt(mtimeMs), margin);
+  closeEnough(statsSyncBigint.atimeInstant.epochMilliseconds, atimeMs, margin);
+  closeEnough(statsSyncBigint.mtimeInstant.epochMilliseconds, mtimeMs, margin);
+  validateEnumerability(statsSyncBigint);
+}
+
+// Too high/low numbers produce too different results on different platforms
+{
+  await runTest(0, 0);
+  await runTest(1, 1);
+  await runTest(355, 40691, 1); // Precision loss on 32bit
+  await runTest(40691, 355, 1); // Precision loss on 32bit
+  await runTest(1713037251360, 1713037251360, 1); // Precision loss
+}
diff --git a/test/parallel/test-fs-watchfile.js b/test/parallel/test-fs-watchfile.js
index bd86835d9ff758..e1fd3f4c3433d3 100644
--- a/test/parallel/test-fs-watchfile.js
+++ b/test/parallel/test-fs-watchfile.js
@@ -42,10 +42,14 @@ const expectedStatObject = new fs.Stats(
   0,                                        // ino
   0,                                        // size
   0,                                        // blocks
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // atime
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // mtime
-  Date.UTC(1970, 0, 1, 0, 0, 0),            // ctime
-  Date.UTC(1970, 0, 1, 0, 0, 0)             // birthtime
+  0,                                        // atimeS
+  0,                                        // atimeNs
+  0,                                        // mtimeS
+  0,                                        // mtimeNs
+  0,                                        // ctime
+  0,                                        // ctimeNs
+  0,                                        // birthtime
+  0,                                        // birthtimeNs
 );
 
 tmpdir.refresh();

From 55920df97595db73664d3c50736fdb02c45e4feb Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Mon, 18 May 2026 21:16:32 -0400
Subject: [PATCH 09/83] deps: update corepack to 0.35.0

PR-URL: https://github.com/nodejs/node/pull/63375
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 deps/corepack/CHANGELOG.md          |    24 +
 deps/corepack/README.md             |     4 +-
 deps/corepack/dist/lib/corepack.cjs | 30162 +++++++++-----------------
 deps/corepack/package.json          |    25 +-
 4 files changed, 10514 insertions(+), 19701 deletions(-)

diff --git a/deps/corepack/CHANGELOG.md b/deps/corepack/CHANGELOG.md
index 16553bd776ffa4..be8dfa5c8cb8df 100644
--- a/deps/corepack/CHANGELOG.md
+++ b/deps/corepack/CHANGELOG.md
@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.35.0](https://github.com/nodejs/corepack/compare/v0.34.7...v0.35.0) (2026-05-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* Drop support for Node.js 20 and Node.js 25.
+* Switching to Node.js built-in proxy support, meaning that proxy support is now
+  gated by having `NODE_USE_ENV_PROXY` set as an environment variable.
+
+### Features
+
+* update package manager versions ([#820](https://github.com/nodejs/corepack/issues/820)) ([fdbd751](https://github.com/nodejs/corepack/commit/fdbd751d9851a50730925de053e9722963c2e135))
+
+
+### Bug Fixes
+
+* target node 22.22.2 in esbuild ([#845](https://github.com/nodejs/corepack/issues/845)) ([0f01502](https://github.com/nodejs/corepack/commit/0f01502fd8832649a573bc68e1851128f547646d))
+
+
+### Miscellaneous Chores
+
+* **deps:** bump engine support matrix ([88c602a](https://github.com/nodejs/corepack/commit/88c602a6ea3f75bf30dc1d071bdb488fae2c8276))
+* **deps:** drop Undici and `proxy-from-env` ([8167b0d](https://github.com/nodejs/corepack/commit/8167b0d65acc091af464ead019f7485cb512082f))
+
 ## [0.34.7](https://github.com/nodejs/corepack/compare/v0.34.6...v0.34.7) (2026-04-17)
 
 
diff --git a/deps/corepack/README.md b/deps/corepack/README.md
index 1920174797a5dc..dd32b4ad09f139 100644
--- a/deps/corepack/README.md
+++ b/deps/corepack/README.md
@@ -328,8 +328,6 @@ same major line. Should you need to upgrade to a new major, use an explicit
   Only keys that start with `COREPACK_` and are not in the exception list
   (`COREPACK_ENABLE_DOWNLOAD_PROMPT` and `COREPACK_ENV_FILE` are ignored)
   will be taken into account.
-  For Node.js 18.x users, this setting has no effect as that version doesn't
-  support parsing of `.env` files.
 
 - `COREPACK_HOME` can be set in order to define where Corepack should install
   the package managers. By default it is set to `%LOCALAPPDATA%\node\corepack`
@@ -352,7 +350,7 @@ same major line. Should you need to upgrade to a new major, use an explicit
   empty password, explicitly set `COREPACK_NPM_PASSWORD` to an empty string.
 
 - `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` are supported through
-  [`proxy-from-env`](https://github.com/Rob--W/proxy-from-env).
+  [`NODE_USE_ENV_PROXY=1`](https://nodejs.org/api/cli.html#node_use_env_proxy1).
 
 - `COREPACK_INTEGRITY_KEYS` can be set to an empty string or `0` to
   instruct Corepack to skip integrity checks, or to a JSON string containing
diff --git a/deps/corepack/dist/lib/corepack.cjs b/deps/corepack/dist/lib/corepack.cjs
index 232645cab47b0c..478389c3e2d04e 100644
--- a/deps/corepack/dist/lib/corepack.cjs
+++ b/deps/corepack/dist/lib/corepack.cjs
@@ -33,7 +33,248 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// .yarn/cache/typanion-npm-3.14.0-8af344c436-8b03b19844.zip/node_modules/typanion/lib/index.mjs
+// node_modules/clipanion/lib/constants.js
+var require_constants = __commonJS({
+  "node_modules/clipanion/lib/constants.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var NODE_INITIAL = 0;
+    var NODE_SUCCESS = 1;
+    var NODE_ERRORED = 2;
+    var START_OF_INPUT = `
`;
+    var END_OF_INPUT = `\0`;
+    var HELP_COMMAND_INDEX = -1;
+    var HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
+    var OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
+    var BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
+    var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
+    var DEBUG = process.env.DEBUG_CLI === `1`;
+    exports2.BATCH_REGEX = BATCH_REGEX;
+    exports2.BINDING_REGEX = BINDING_REGEX;
+    exports2.DEBUG = DEBUG;
+    exports2.END_OF_INPUT = END_OF_INPUT;
+    exports2.HELP_COMMAND_INDEX = HELP_COMMAND_INDEX;
+    exports2.HELP_REGEX = HELP_REGEX;
+    exports2.NODE_ERRORED = NODE_ERRORED;
+    exports2.NODE_INITIAL = NODE_INITIAL;
+    exports2.NODE_SUCCESS = NODE_SUCCESS;
+    exports2.OPTION_REGEX = OPTION_REGEX;
+    exports2.START_OF_INPUT = START_OF_INPUT;
+  }
+});
+
+// node_modules/clipanion/lib/errors.js
+var require_errors = __commonJS({
+  "node_modules/clipanion/lib/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var constants2 = require_constants();
+    var UsageError16 = class extends Error {
+      constructor(message) {
+        super(message);
+        this.clipanion = { type: `usage` };
+        this.name = `UsageError`;
+      }
+    };
+    var UnknownSyntaxError = class extends Error {
+      constructor(input, candidates) {
+        super();
+        this.input = input;
+        this.candidates = candidates;
+        this.clipanion = { type: `none` };
+        this.name = `UnknownSyntaxError`;
+        if (this.candidates.length === 0) {
+          this.message = `Command not found, but we're not sure what's the alternative.`;
+        } else if (this.candidates.every((candidate) => candidate.reason !== null && candidate.reason === candidates[0].reason)) {
+          const [{ reason }] = this.candidates;
+          this.message = `${reason}
+
+${this.candidates.map(({ usage }) => `$ ${usage}`).join(`
+`)}`;
+        } else if (this.candidates.length === 1) {
+          const [{ usage }] = this.candidates;
+          this.message = `Command not found; did you mean:
+
+$ ${usage}
+${whileRunning(input)}`;
+        } else {
+          this.message = `Command not found; did you mean one of:
+
+${this.candidates.map(({ usage }, index) => {
+            return `${`${index}.`.padStart(4)} ${usage}`;
+          }).join(`
+`)}
+
+${whileRunning(input)}`;
+        }
+      }
+    };
+    var AmbiguousSyntaxError = class extends Error {
+      constructor(input, usages) {
+        super();
+        this.input = input;
+        this.usages = usages;
+        this.clipanion = { type: `none` };
+        this.name = `AmbiguousSyntaxError`;
+        this.message = `Cannot find which to pick amongst the following alternatives:
+
+${this.usages.map((usage, index) => {
+          return `${`${index}.`.padStart(4)} ${usage}`;
+        }).join(`
+`)}
+
+${whileRunning(input)}`;
+      }
+    };
+    var whileRunning = (input) => `While running ${input.filter((token) => {
+      return token !== constants2.END_OF_INPUT;
+    }).map((token) => {
+      const json = JSON.stringify(token);
+      if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
+        return json;
+      } else {
+        return token;
+      }
+    }).join(` `)}`;
+    exports2.AmbiguousSyntaxError = AmbiguousSyntaxError;
+    exports2.UnknownSyntaxError = UnknownSyntaxError;
+    exports2.UsageError = UsageError16;
+  }
+});
+
+// node_modules/clipanion/lib/format.js
+var require_format = __commonJS({
+  "node_modules/clipanion/lib/format.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var MAX_LINE_LENGTH = 80;
+    var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`);
+    for (let t = 0; t <= 24; ++t)
+      richLine[richLine.length - t] = `\x1B[38;5;${232 + t}m\u2501`;
+    var richFormat = {
+      header: (str) => `\x1B[1m\u2501\u2501\u2501 ${str}${str.length < MAX_LINE_LENGTH - 5 ? ` ${richLine.slice(str.length + 5).join(``)}` : `:`}\x1B[0m`,
+      bold: (str) => `\x1B[1m${str}\x1B[22m`,
+      error: (str) => `\x1B[31m\x1B[1m${str}\x1B[22m\x1B[39m`,
+      code: (str) => `\x1B[36m${str}\x1B[39m`
+    };
+    var textFormat = {
+      header: (str) => str,
+      bold: (str) => str,
+      error: (str) => str,
+      code: (str) => str
+    };
+    function dedent(text) {
+      const lines = text.split(`
+`);
+      const nonEmptyLines = lines.filter((line) => line.match(/\S/));
+      const indent = nonEmptyLines.length > 0 ? nonEmptyLines.reduce((minLength, line) => Math.min(minLength, line.length - line.trimStart().length), Number.MAX_VALUE) : 0;
+      return lines.map((line) => line.slice(indent).trimRight()).join(`
+`);
+    }
+    function formatMarkdownish(text, { format, paragraphs }) {
+      text = text.replace(/\r\n?/g, `
+`);
+      text = dedent(text);
+      text = text.replace(/^\n+|\n+$/g, ``);
+      text = text.replace(/^(\s*)-([^\n]*?)\n+/gm, `$1-$2
+
+`);
+      text = text.replace(/\n(\n)?\n*/g, ($0, $1) => $1 ? $1 : ` `);
+      if (paragraphs) {
+        text = text.split(/\n/).map((paragraph) => {
+          const bulletMatch = paragraph.match(/^\s*[*-][\t ]+(.*)/);
+          if (!bulletMatch)
+            return paragraph.match(/(.{1,80})(?: |$)/g).join(`
+`);
+          const indent = paragraph.length - paragraph.trimStart().length;
+          return bulletMatch[1].match(new RegExp(`(.{1,${78 - indent}})(?: |$)`, `g`)).map((line, index) => {
+            return ` `.repeat(indent) + (index === 0 ? `- ` : `  `) + line;
+          }).join(`
+`);
+        }).join(`
+
+`);
+      }
+      text = text.replace(/(`+)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
+        return format.code($1 + $2 + $1);
+      });
+      text = text.replace(/(\*\*)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
+        return format.bold($1 + $2 + $1);
+      });
+      return text ? `${text}
+` : ``;
+    }
+    exports2.formatMarkdownish = formatMarkdownish;
+    exports2.richFormat = richFormat;
+    exports2.textFormat = textFormat;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/utils.js
+var require_utils = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var errors = require_errors();
+    var isOptionSymbol = /* @__PURE__ */ Symbol(`clipanion/isOption`);
+    function makeCommandOption(spec) {
+      return { ...spec, [isOptionSymbol]: true };
+    }
+    function rerouteArguments(a, b) {
+      if (typeof a === `undefined`)
+        return [a, b];
+      if (typeof a === `object` && a !== null && !Array.isArray(a)) {
+        return [void 0, a];
+      } else {
+        return [a, b];
+      }
+    }
+    function cleanValidationError(message, { mergeName = false } = {}) {
+      const match = message.match(/^([^:]+): (.*)$/m);
+      if (!match)
+        return `validation failed`;
+      let [, path16, line] = match;
+      if (mergeName)
+        line = line[0].toLowerCase() + line.slice(1);
+      line = path16 !== `.` || !mergeName ? `${path16.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`;
+      return line;
+    }
+    function formatError(message, errors$1) {
+      if (errors$1.length === 1) {
+        return new errors.UsageError(`${message}${cleanValidationError(errors$1[0], { mergeName: true })}`);
+      } else {
+        return new errors.UsageError(`${message}:
+${errors$1.map((error) => `
+- ${cleanValidationError(error)}`).join(``)}`);
+      }
+    }
+    function applyValidator(name2, value, validator) {
+      if (typeof validator === `undefined`)
+        return value;
+      const errors2 = [];
+      const coercions = [];
+      const coercion = (v) => {
+        const orig = value;
+        value = v;
+        return coercion.bind(null, orig);
+      };
+      const check = validator(value, { errors: errors2, coercions, coercion });
+      if (!check)
+        throw formatError(`Invalid value for ${name2}`, errors2);
+      for (const [, op] of coercions)
+        op();
+      return value;
+    }
+    exports2.applyValidator = applyValidator;
+    exports2.cleanValidationError = cleanValidationError;
+    exports2.formatError = formatError;
+    exports2.isOptionSymbol = isOptionSymbol;
+    exports2.makeCommandOption = makeCommandOption;
+    exports2.rerouteArguments = rerouteArguments;
+  }
+});
+
+// node_modules/typanion/lib/index.mjs
 var lib_exports = {};
 __export(lib_exports, {
   KeyRelationship: () => KeyRelationship,
@@ -946,7 +1187,7 @@ function hasKeyRelationship(subject, relationship, others, options) {
 }
 var simpleKeyRegExp, colorStringRegExp, colorStringAlphaRegExp, base64RegExp, uuid4RegExp, iso8601RegExp, BOOLEAN_COERCIONS, isInstanceOf, isOneOf, TypeAssertionError, checks, KeyRelationship, keyRelationships;
 var init_lib = __esm({
-  ".yarn/cache/typanion-npm-3.14.0-8af344c436-8b03b19844.zip/node_modules/typanion/lib/index.mjs"() {
+  "node_modules/typanion/lib/index.mjs"() {
     simpleKeyRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
     colorStringRegExp = /^#[0-9a-f]{6}$/i;
     colorStringAlphaRegExp = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
@@ -1037,18060 +1278,9840 @@ var init_lib = __esm({
   }
 });
 
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/platform/node.js
-var require_node = __commonJS({
-  ".yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/platform/node.js"(exports2) {
+// node_modules/clipanion/lib/advanced/Command.js
+var require_Command = __commonJS({
+  "node_modules/clipanion/lib/advanced/Command.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var tty2 = require("tty");
-    function _interopDefaultLegacy(e) {
-      return e && typeof e === "object" && "default" in e ? e : { "default": e };
-    }
-    var tty__default = /* @__PURE__ */ _interopDefaultLegacy(tty2);
-    function getDefaultColorDepth2() {
-      if (tty__default["default"] && `getColorDepth` in tty__default["default"].WriteStream.prototype)
-        return tty__default["default"].WriteStream.prototype.getColorDepth();
-      if (process.env.FORCE_COLOR === `0`)
-        return 1;
-      if (process.env.FORCE_COLOR === `1`)
-        return 8;
-      if (typeof process.stdout !== `undefined` && process.stdout.isTTY)
-        return 8;
-      return 1;
-    }
-    var gContextStorage;
-    function getCaptureActivator2(context) {
-      let contextStorage = gContextStorage;
-      if (typeof contextStorage === `undefined`) {
-        if (context.stdout === process.stdout && context.stderr === process.stderr)
-          return null;
-        const { AsyncLocalStorage: LazyAsyncLocalStorage } = require("async_hooks");
-        contextStorage = gContextStorage = new LazyAsyncLocalStorage();
-        const origStdoutWrite = process.stdout._write;
-        process.stdout._write = function(chunk, encoding, cb) {
-          const context2 = contextStorage.getStore();
-          if (typeof context2 === `undefined`)
-            return origStdoutWrite.call(this, chunk, encoding, cb);
-          return context2.stdout.write(chunk, encoding, cb);
-        };
-        const origStderrWrite = process.stderr._write;
-        process.stderr._write = function(chunk, encoding, cb) {
-          const context2 = contextStorage.getStore();
-          if (typeof context2 === `undefined`)
-            return origStderrWrite.call(this, chunk, encoding, cb);
-          return context2.stderr.write(chunk, encoding, cb);
-        };
+    var advanced_options_utils = require_utils();
+    function _interopNamespace(e) {
+      if (e && e.__esModule) return e;
+      var n = /* @__PURE__ */ Object.create(null);
+      if (e) {
+        Object.keys(e).forEach(function(k) {
+          if (k !== "default") {
+            var d = Object.getOwnPropertyDescriptor(e, k);
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: function() {
+                return e[k];
+              }
+            });
+          }
+        });
       }
-      return (fn2) => {
-        return contextStorage.run(context, fn2);
-      };
+      n["default"] = e;
+      return Object.freeze(n);
     }
-    exports2.getCaptureActivator = getCaptureActivator2;
-    exports2.getDefaultColorDepth = getDefaultColorDepth2;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/debug.js
-var require_debug = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/debug.js"(exports2, module2) {
-    "use strict";
-    var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
-    };
-    module2.exports = debug2;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/constants.js
-var require_constants = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/constants.js"(exports2, module2) {
-    "use strict";
-    var SEMVER_SPEC_VERSION = "2.0.0";
-    var MAX_LENGTH = 256;
-    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
-    9007199254740991;
-    var MAX_SAFE_COMPONENT_LENGTH = 16;
-    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
-    var RELEASE_TYPES = [
-      "major",
-      "premajor",
-      "minor",
-      "preminor",
-      "patch",
-      "prepatch",
-      "prerelease"
-    ];
-    module2.exports = {
-      MAX_LENGTH,
-      MAX_SAFE_COMPONENT_LENGTH,
-      MAX_SAFE_BUILD_LENGTH,
-      MAX_SAFE_INTEGER,
-      RELEASE_TYPES,
-      SEMVER_SPEC_VERSION,
-      FLAG_INCLUDE_PRERELEASE: 1,
-      FLAG_LOOSE: 2
-    };
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/re.js
-var require_re = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/re.js"(exports2, module2) {
-    "use strict";
-    var {
-      MAX_SAFE_COMPONENT_LENGTH,
-      MAX_SAFE_BUILD_LENGTH,
-      MAX_LENGTH
-    } = require_constants();
-    var debug2 = require_debug();
-    exports2 = module2.exports = {};
-    var re = exports2.re = [];
-    var safeRe = exports2.safeRe = [];
-    var src = exports2.src = [];
-    var safeSrc = exports2.safeSrc = [];
-    var t = exports2.t = {};
-    var R = 0;
-    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
-    var safeRegexReplacements = [
-      ["\\s", 1],
-      ["\\d", MAX_LENGTH],
-      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
-    ];
-    var makeSafeRegex = (value) => {
-      for (const [token, max] of safeRegexReplacements) {
-        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
-      }
-      return value;
-    };
-    var createToken = (name2, value, isGlobal) => {
-      const safe = makeSafeRegex(value);
-      const index = R++;
-      debug2(name2, index, value);
-      t[name2] = index;
-      src[index] = value;
-      safeSrc[index] = safe;
-      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
-      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
-    };
-    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
-    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
-    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
-    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
-    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
-    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
-    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
-    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
-    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
-    createToken("GTLT", "((?:<|>)?=?)");
-    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
-    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
-    createToken("COERCERTL", src[t.COERCE], true);
-    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
-    createToken("LONETILDE", "(?:~>?)");
-    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-    exports2.tildeTrimReplace = "$1~";
-    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("LONECARET", "(?:\\^)");
-    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
-    exports2.caretTrimReplace = "$1^";
-    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-    exports2.comparatorTrimReplace = "$1$2$3";
-    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
-    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
-    createToken("STAR", "(<|>)?=?\\s*\\*");
-    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
-    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/parse-options.js
-var require_parse_options = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/parse-options.js"(exports2, module2) {
-    "use strict";
-    var looseOption = Object.freeze({ loose: true });
-    var emptyOpts = Object.freeze({});
-    var parseOptions = (options) => {
-      if (!options) {
-        return emptyOpts;
+    var Command12 = class {
+      constructor() {
+        this.help = false;
       }
-      if (typeof options !== "object") {
-        return looseOption;
+      /**
+       * Defines the usage information for the given command.
+       */
+      static Usage(usage) {
+        return usage;
       }
-      return options;
-    };
-    module2.exports = parseOptions;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/identifiers.js
-var require_identifiers = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/identifiers.js"(exports2, module2) {
-    "use strict";
-    var numeric = /^[0-9]+$/;
-    var compareIdentifiers = (a, b) => {
-      if (typeof a === "number" && typeof b === "number") {
-        return a === b ? 0 : a < b ? -1 : 1;
+      /**
+       * Standard error handler which will simply rethrow the error. Can be used
+       * to add custom logic to handle errors from the command or simply return
+       * the parent class error handling.
+       */
+      async catch(error) {
+        throw error;
       }
-      const anum = numeric.test(a);
-      const bnum = numeric.test(b);
-      if (anum && bnum) {
-        a = +a;
-        b = +b;
+      async validateAndExecute() {
+        const commandClass = this.constructor;
+        const cascade2 = commandClass.schema;
+        if (Array.isArray(cascade2)) {
+          const { isDict: isDict2, isUnknown: isUnknown2, applyCascade: applyCascade2 } = await Promise.resolve().then(function() {
+            return /* @__PURE__ */ _interopNamespace((init_lib(), __toCommonJS(lib_exports)));
+          });
+          const schema = applyCascade2(isDict2(isUnknown2()), cascade2);
+          const errors = [];
+          const coercions = [];
+          const check = schema(this, { errors, coercions });
+          if (!check)
+            throw advanced_options_utils.formatError(`Invalid option schema`, errors);
+          for (const [, op] of coercions) {
+            op();
+          }
+        } else if (cascade2 != null) {
+          throw new Error(`Invalid command schema`);
+        }
+        const exitCode = await this.execute();
+        if (typeof exitCode !== `undefined`) {
+          return exitCode;
+        } else {
+          return 0;
+        }
       }
-      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
-    };
-    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
-    module2.exports = {
-      compareIdentifiers,
-      rcompareIdentifiers
     };
+    Command12.isOption = advanced_options_utils.isOptionSymbol;
+    Command12.Default = [];
+    exports2.Command = Command12;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/semver.js
-var require_semver = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/semver.js"(exports2, module2) {
+// node_modules/clipanion/lib/core.js
+var require_core = __commonJS({
+  "node_modules/clipanion/lib/core.js"(exports2) {
     "use strict";
-    var debug2 = require_debug();
-    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
-    var { safeRe: re, t } = require_re();
-    var parseOptions = require_parse_options();
-    var { compareIdentifiers } = require_identifiers();
-    var SemVer3 = class _SemVer {
-      constructor(version2, options) {
-        options = parseOptions(options);
-        if (version2 instanceof _SemVer) {
-          if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
-            return version2;
-          } else {
-            version2 = version2.version;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var constants2 = require_constants();
+    var errors = require_errors();
+    function debug(str) {
+      if (constants2.DEBUG) {
+        console.log(str);
+      }
+    }
+    var basicHelpState = {
+      candidateUsage: null,
+      requiredOptions: [],
+      errorMessage: null,
+      ignoreOptions: false,
+      path: [],
+      positionals: [],
+      options: [],
+      remainder: null,
+      selectedIndex: constants2.HELP_COMMAND_INDEX
+    };
+    function makeStateMachine() {
+      return {
+        nodes: [makeNode(), makeNode(), makeNode()]
+      };
+    }
+    function makeAnyOfMachine(inputs) {
+      const output = makeStateMachine();
+      const heads = [];
+      let offset = output.nodes.length;
+      for (const input of inputs) {
+        heads.push(offset);
+        for (let t = 0; t < input.nodes.length; ++t)
+          if (!isTerminalNode(t))
+            output.nodes.push(cloneNode(input.nodes[t], offset));
+        offset += input.nodes.length - 2;
+      }
+      for (const head of heads)
+        registerShortcut(output, constants2.NODE_INITIAL, head);
+      return output;
+    }
+    function injectNode(machine, node) {
+      machine.nodes.push(node);
+      return machine.nodes.length - 1;
+    }
+    function simplifyMachine(input) {
+      const visited = /* @__PURE__ */ new Set();
+      const process5 = (node) => {
+        if (visited.has(node))
+          return;
+        visited.add(node);
+        const nodeDef = input.nodes[node];
+        for (const transitions of Object.values(nodeDef.statics))
+          for (const { to } of transitions)
+            process5(to);
+        for (const [, { to }] of nodeDef.dynamics)
+          process5(to);
+        for (const { to } of nodeDef.shortcuts)
+          process5(to);
+        const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
+        while (nodeDef.shortcuts.length > 0) {
+          const { to } = nodeDef.shortcuts.shift();
+          const toDef = input.nodes[to];
+          for (const [segment, transitions] of Object.entries(toDef.statics)) {
+            const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment) ? nodeDef.statics[segment] = [] : nodeDef.statics[segment];
+            for (const transition of transitions) {
+              if (!store.some(({ to: to2 }) => transition.to === to2)) {
+                store.push(transition);
+              }
+            }
+          }
+          for (const [test, transition] of toDef.dynamics)
+            if (!nodeDef.dynamics.some(([otherTest, { to: to2 }]) => test === otherTest && transition.to === to2))
+              nodeDef.dynamics.push([test, transition]);
+          for (const transition of toDef.shortcuts) {
+            if (!shortcuts.has(transition.to)) {
+              nodeDef.shortcuts.push(transition);
+              shortcuts.add(transition.to);
+            }
           }
-        } else if (typeof version2 !== "string") {
-          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
-        }
-        if (version2.length > MAX_LENGTH) {
-          throw new TypeError(
-            `version is longer than ${MAX_LENGTH} characters`
-          );
-        }
-        debug2("SemVer", version2, options);
-        this.options = options;
-        this.loose = !!options.loose;
-        this.includePrerelease = !!options.includePrerelease;
-        const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
-        if (!m) {
-          throw new TypeError(`Invalid Version: ${version2}`);
         }
-        this.raw = version2;
-        this.major = +m[1];
-        this.minor = +m[2];
-        this.patch = +m[3];
-        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-          throw new TypeError("Invalid major version");
+      };
+      process5(constants2.NODE_INITIAL);
+    }
+    function debugMachine(machine, { prefix = `` } = {}) {
+      if (constants2.DEBUG) {
+        debug(`${prefix}Nodes are:`);
+        for (let t = 0; t < machine.nodes.length; ++t) {
+          debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
+        }
+      }
+    }
+    function runMachineInternal(machine, input, partial = false) {
+      debug(`Running a vm on ${JSON.stringify(input)}`);
+      let branches = [{ node: constants2.NODE_INITIAL, state: {
+        candidateUsage: null,
+        requiredOptions: [],
+        errorMessage: null,
+        ignoreOptions: false,
+        options: [],
+        path: [],
+        positionals: [],
+        remainder: null,
+        selectedIndex: null
+      } }];
+      debugMachine(machine, { prefix: `  ` });
+      const tokens = [constants2.START_OF_INPUT, ...input];
+      for (let t = 0; t < tokens.length; ++t) {
+        const segment = tokens[t];
+        debug(`  Processing ${JSON.stringify(segment)}`);
+        const nextBranches = [];
+        for (const { node, state } of branches) {
+          debug(`    Current node is ${node}`);
+          const nodeDef = machine.nodes[node];
+          if (node === constants2.NODE_ERRORED) {
+            nextBranches.push({ node, state });
+            continue;
+          }
+          console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
+          const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
+          if (!partial || t < tokens.length - 1 || hasExactMatch) {
+            if (hasExactMatch) {
+              const transitions = nodeDef.statics[segment];
+              for (const { to, reducer } of transitions) {
+                nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                debug(`      Static transition to ${to} found`);
+              }
+            } else {
+              debug(`      No static transition found`);
+            }
+          } else {
+            let hasMatches = false;
+            for (const candidate of Object.keys(nodeDef.statics)) {
+              if (!candidate.startsWith(segment))
+                continue;
+              if (segment === candidate) {
+                for (const { to, reducer } of nodeDef.statics[candidate]) {
+                  nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                  debug(`      Static transition to ${to} found`);
+                }
+              } else {
+                for (const { to } of nodeDef.statics[candidate]) {
+                  nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
+                  debug(`      Static transition to ${to} found (partial match)`);
+                }
+              }
+              hasMatches = true;
+            }
+            if (!hasMatches) {
+              debug(`      No partial static transition found`);
+            }
+          }
+          if (segment !== constants2.END_OF_INPUT) {
+            for (const [test, { to, reducer }] of nodeDef.dynamics) {
+              if (execute(tests, test, state, segment)) {
+                nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
+                debug(`      Dynamic transition to ${to} found (via ${test})`);
+              }
+            }
+          }
         }
-        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-          throw new TypeError("Invalid minor version");
+        if (nextBranches.length === 0 && segment === constants2.END_OF_INPUT && input.length === 1) {
+          return [{
+            node: constants2.NODE_INITIAL,
+            state: basicHelpState
+          }];
         }
-        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-          throw new TypeError("Invalid patch version");
+        if (nextBranches.length === 0) {
+          throw new errors.UnknownSyntaxError(input, branches.filter(({ node }) => {
+            return node !== constants2.NODE_ERRORED;
+          }).map(({ state }) => {
+            return { usage: state.candidateUsage, reason: null };
+          }));
         }
-        if (!m[4]) {
-          this.prerelease = [];
-        } else {
-          this.prerelease = m[4].split(".").map((id) => {
-            if (/^[0-9]+$/.test(id)) {
-              const num = +id;
-              if (num >= 0 && num < MAX_SAFE_INTEGER) {
-                return num;
-              }
-            }
-            return id;
-          });
+        if (nextBranches.every(({ node }) => node === constants2.NODE_ERRORED)) {
+          throw new errors.UnknownSyntaxError(input, nextBranches.map(({ state }) => {
+            return { usage: state.candidateUsage, reason: state.errorMessage };
+          }));
         }
-        this.build = m[5] ? m[5].split(".") : [];
-        this.format();
+        branches = trimSmallerBranches(nextBranches);
       }
-      format() {
-        this.version = `${this.major}.${this.minor}.${this.patch}`;
-        if (this.prerelease.length) {
-          this.version += `-${this.prerelease.join(".")}`;
+      if (branches.length > 0) {
+        debug(`  Results:`);
+        for (const branch of branches) {
+          debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
         }
-        return this.version;
+      } else {
+        debug(`  No results`);
       }
-      toString() {
-        return this.version;
+      return branches;
+    }
+    function checkIfNodeIsFinished(node, state) {
+      if (state.selectedIndex !== null)
+        return true;
+      if (Object.prototype.hasOwnProperty.call(node.statics, constants2.END_OF_INPUT)) {
+        for (const { to } of node.statics[constants2.END_OF_INPUT])
+          if (to === constants2.NODE_SUCCESS)
+            return true;
       }
-      compare(other) {
-        debug2("SemVer.compare", this.version, this.options, other);
-        if (!(other instanceof _SemVer)) {
-          if (typeof other === "string" && other === this.version) {
-            return 0;
+      return false;
+    }
+    function suggestMachine(machine, input, partial) {
+      const prefix = partial && input.length > 0 ? [``] : [];
+      const branches = runMachineInternal(machine, input, partial);
+      const suggestions = [];
+      const suggestionsJson = /* @__PURE__ */ new Set();
+      const traverseSuggestion = (suggestion, node, skipFirst = true) => {
+        let nextNodes = [node];
+        while (nextNodes.length > 0) {
+          const currentNodes = nextNodes;
+          nextNodes = [];
+          for (const node2 of currentNodes) {
+            const nodeDef = machine.nodes[node2];
+            const keys = Object.keys(nodeDef.statics);
+            for (const key of Object.keys(nodeDef.statics)) {
+              const segment = keys[0];
+              for (const { to, reducer } of nodeDef.statics[segment]) {
+                if (reducer !== `pushPath`)
+                  continue;
+                if (!skipFirst)
+                  suggestion.push(segment);
+                nextNodes.push(to);
+              }
+            }
           }
-          other = new _SemVer(other, this.options);
-        }
-        if (other.version === this.version) {
-          return 0;
-        }
-        return this.compareMain(other) || this.comparePre(other);
-      }
-      compareMain(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
-        }
-        if (this.major < other.major) {
-          return -1;
-        }
-        if (this.major > other.major) {
-          return 1;
-        }
-        if (this.minor < other.minor) {
-          return -1;
+          skipFirst = false;
         }
-        if (this.minor > other.minor) {
-          return 1;
+        const json = JSON.stringify(suggestion);
+        if (suggestionsJson.has(json))
+          return;
+        suggestions.push(suggestion);
+        suggestionsJson.add(json);
+      };
+      for (const { node, state } of branches) {
+        if (state.remainder !== null) {
+          traverseSuggestion([state.remainder], node);
+          continue;
         }
-        if (this.patch < other.patch) {
-          return -1;
+        const nodeDef = machine.nodes[node];
+        const isFinished = checkIfNodeIsFinished(nodeDef, state);
+        for (const [candidate, transitions] of Object.entries(nodeDef.statics))
+          if (isFinished && candidate !== constants2.END_OF_INPUT || !candidate.startsWith(`-`) && transitions.some(({ reducer }) => reducer === `pushPath`))
+            traverseSuggestion([...prefix, candidate], node);
+        if (!isFinished)
+          continue;
+        for (const [test, { to }] of nodeDef.dynamics) {
+          if (to === constants2.NODE_ERRORED)
+            continue;
+          const tokens = suggest(test, state);
+          if (tokens === null)
+            continue;
+          for (const token of tokens) {
+            traverseSuggestion([...prefix, token], node);
+          }
         }
-        if (this.patch > other.patch) {
-          return 1;
+      }
+      return [...suggestions].sort();
+    }
+    function runMachine(machine, input) {
+      const branches = runMachineInternal(machine, [...input, constants2.END_OF_INPUT]);
+      return selectBestState(input, branches.map(({ state }) => {
+        return state;
+      }));
+    }
+    function trimSmallerBranches(branches) {
+      let maxPathSize = 0;
+      for (const { state } of branches)
+        if (state.path.length > maxPathSize)
+          maxPathSize = state.path.length;
+      return branches.filter(({ state }) => {
+        return state.path.length === maxPathSize;
+      });
+    }
+    function selectBestState(input, states) {
+      const terminalStates = states.filter((state) => {
+        return state.selectedIndex !== null;
+      });
+      if (terminalStates.length === 0)
+        throw new Error();
+      const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === constants2.HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name2) => state.options.find((opt) => opt.name === name2))));
+      if (requiredOptionsSetStates.length === 0) {
+        throw new errors.UnknownSyntaxError(input, terminalStates.map((state) => ({
+          usage: state.candidateUsage,
+          reason: null
+        })));
+      }
+      let maxPathSize = 0;
+      for (const state of requiredOptionsSetStates)
+        if (state.path.length > maxPathSize)
+          maxPathSize = state.path.length;
+      const bestPathBranches = requiredOptionsSetStates.filter((state) => {
+        return state.path.length === maxPathSize;
+      });
+      const getPositionalCount = (state) => state.positionals.filter(({ extra }) => {
+        return !extra;
+      }).length + state.options.length;
+      const statesWithPositionalCount = bestPathBranches.map((state) => {
+        return { state, positionalCount: getPositionalCount(state) };
+      });
+      let maxPositionalCount = 0;
+      for (const { positionalCount } of statesWithPositionalCount)
+        if (positionalCount > maxPositionalCount)
+          maxPositionalCount = positionalCount;
+      const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) => {
+        return positionalCount === maxPositionalCount;
+      }).map(({ state }) => {
+        return state;
+      });
+      const fixedStates = aggregateHelpStates(bestPositionalStates);
+      if (fixedStates.length > 1)
+        throw new errors.AmbiguousSyntaxError(input, fixedStates.map((state) => state.candidateUsage));
+      return fixedStates[0];
+    }
+    function aggregateHelpStates(states) {
+      const notHelps = [];
+      const helps = [];
+      for (const state of states) {
+        if (state.selectedIndex === constants2.HELP_COMMAND_INDEX) {
+          helps.push(state);
+        } else {
+          notHelps.push(state);
         }
-        return 0;
       }
-      comparePre(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
+      if (helps.length > 0) {
+        notHelps.push({
+          ...basicHelpState,
+          path: findCommonPrefix(...helps.map((state) => state.path)),
+          options: helps.reduce((options, state) => options.concat(state.options), [])
+        });
+      }
+      return notHelps;
+    }
+    function findCommonPrefix(firstPath, secondPath, ...rest) {
+      if (secondPath === void 0)
+        return Array.from(firstPath);
+      return findCommonPrefix(firstPath.filter((segment, i) => segment === secondPath[i]), ...rest);
+    }
+    function makeNode() {
+      return {
+        dynamics: [],
+        shortcuts: [],
+        statics: {}
+      };
+    }
+    function isTerminalNode(node) {
+      return node === constants2.NODE_SUCCESS || node === constants2.NODE_ERRORED;
+    }
+    function cloneTransition(input, offset = 0) {
+      return {
+        to: !isTerminalNode(input.to) ? input.to > 2 ? input.to + offset - 2 : input.to + offset : input.to,
+        reducer: input.reducer
+      };
+    }
+    function cloneNode(input, offset = 0) {
+      const output = makeNode();
+      for (const [test, transition] of input.dynamics)
+        output.dynamics.push([test, cloneTransition(transition, offset)]);
+      for (const transition of input.shortcuts)
+        output.shortcuts.push(cloneTransition(transition, offset));
+      for (const [segment, transitions] of Object.entries(input.statics))
+        output.statics[segment] = transitions.map((transition) => cloneTransition(transition, offset));
+      return output;
+    }
+    function registerDynamic(machine, from, test, to, reducer) {
+      machine.nodes[from].dynamics.push([
+        test,
+        { to, reducer }
+      ]);
+    }
+    function registerShortcut(machine, from, to, reducer) {
+      machine.nodes[from].shortcuts.push({ to, reducer });
+    }
+    function registerStatic(machine, from, test, to, reducer) {
+      const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test) ? machine.nodes[from].statics[test] = [] : machine.nodes[from].statics[test];
+      store.push({ to, reducer });
+    }
+    function execute(store, callback, state, segment) {
+      if (Array.isArray(callback)) {
+        const [name2, ...args] = callback;
+        return store[name2](state, segment, ...args);
+      } else {
+        return store[callback](state, segment);
+      }
+    }
+    function suggest(callback, state) {
+      const fn2 = Array.isArray(callback) ? tests[callback[0]] : tests[callback];
+      if (typeof fn2.suggest === `undefined`)
+        return null;
+      const args = Array.isArray(callback) ? callback.slice(1) : [];
+      return fn2.suggest(state, ...args);
+    }
+    var tests = {
+      always: () => {
+        return true;
+      },
+      isOptionLike: (state, segment) => {
+        return !state.ignoreOptions && (segment !== `-` && segment.startsWith(`-`));
+      },
+      isNotOptionLike: (state, segment) => {
+        return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
+      },
+      isOption: (state, segment, name2, hidden) => {
+        return !state.ignoreOptions && segment === name2;
+      },
+      isBatchOption: (state, segment, names) => {
+        return !state.ignoreOptions && constants2.BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name2) => names.includes(`-${name2}`));
+      },
+      isBoundOption: (state, segment, names, options) => {
+        const optionParsing = segment.match(constants2.BINDING_REGEX);
+        return !state.ignoreOptions && !!optionParsing && constants2.OPTION_REGEX.test(optionParsing[1]) && names.includes(optionParsing[1]) && options.filter((opt) => opt.names.includes(optionParsing[1])).every((opt) => opt.allowBinding);
+      },
+      isNegatedOption: (state, segment, name2) => {
+        return !state.ignoreOptions && segment === `--no-${name2.slice(2)}`;
+      },
+      isHelp: (state, segment) => {
+        return !state.ignoreOptions && constants2.HELP_REGEX.test(segment);
+      },
+      isUnsupportedOption: (state, segment, names) => {
+        return !state.ignoreOptions && segment.startsWith(`-`) && constants2.OPTION_REGEX.test(segment) && !names.includes(segment);
+      },
+      isInvalidOption: (state, segment) => {
+        return !state.ignoreOptions && segment.startsWith(`-`) && !constants2.OPTION_REGEX.test(segment);
+      }
+    };
+    tests.isOption.suggest = (state, name2, hidden = true) => {
+      return !hidden ? [name2] : null;
+    };
+    var reducers = {
+      setCandidateState: (state, segment, candidateState) => {
+        return { ...state, ...candidateState };
+      },
+      setSelectedIndex: (state, segment, index) => {
+        return { ...state, selectedIndex: index };
+      },
+      pushBatch: (state, segment) => {
+        return { ...state, options: state.options.concat([...segment.slice(1)].map((name2) => ({ name: `-${name2}`, value: true }))) };
+      },
+      pushBound: (state, segment) => {
+        const [, name2, value] = segment.match(constants2.BINDING_REGEX);
+        return { ...state, options: state.options.concat({ name: name2, value }) };
+      },
+      pushPath: (state, segment) => {
+        return { ...state, path: state.path.concat(segment) };
+      },
+      pushPositional: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: false }) };
+      },
+      pushExtra: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: true }) };
+      },
+      pushExtraNoLimits: (state, segment) => {
+        return { ...state, positionals: state.positionals.concat({ value: segment, extra: NoLimits }) };
+      },
+      pushTrue: (state, segment, name2 = segment) => {
+        return { ...state, options: state.options.concat({ name: segment, value: true }) };
+      },
+      pushFalse: (state, segment, name2 = segment) => {
+        return { ...state, options: state.options.concat({ name: name2, value: false }) };
+      },
+      pushUndefined: (state, segment) => {
+        return { ...state, options: state.options.concat({ name: segment, value: void 0 }) };
+      },
+      pushStringValue: (state, segment) => {
+        var _a;
+        const copy = { ...state, options: [...state.options] };
+        const lastOption = state.options[state.options.length - 1];
+        lastOption.value = ((_a = lastOption.value) !== null && _a !== void 0 ? _a : []).concat([segment]);
+        return copy;
+      },
+      setStringValue: (state, segment) => {
+        const copy = { ...state, options: [...state.options] };
+        const lastOption = state.options[state.options.length - 1];
+        lastOption.value = segment;
+        return copy;
+      },
+      inhibateOptions: (state) => {
+        return { ...state, ignoreOptions: true };
+      },
+      useHelp: (state, segment, command) => {
+        const [
+          ,
+          /* name */
+          ,
+          index
+        ] = segment.match(constants2.HELP_REGEX);
+        if (typeof index !== `undefined`) {
+          return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
+        } else {
+          return { ...state, options: [{ name: `-c`, value: String(command) }] };
         }
-        if (this.prerelease.length && !other.prerelease.length) {
-          return -1;
-        } else if (!this.prerelease.length && other.prerelease.length) {
-          return 1;
-        } else if (!this.prerelease.length && !other.prerelease.length) {
-          return 0;
+      },
+      setError: (state, segment, errorMessage) => {
+        if (segment === constants2.END_OF_INPUT) {
+          return { ...state, errorMessage: `${errorMessage}.` };
+        } else {
+          return { ...state, errorMessage: `${errorMessage} ("${segment}").` };
         }
-        let i = 0;
-        do {
-          const a = this.prerelease[i];
-          const b = other.prerelease[i];
-          debug2("prerelease compare", i, a, b);
-          if (a === void 0 && b === void 0) {
-            return 0;
-          } else if (b === void 0) {
-            return 1;
-          } else if (a === void 0) {
-            return -1;
-          } else if (a === b) {
-            continue;
-          } else {
-            return compareIdentifiers(a, b);
-          }
-        } while (++i);
+      },
+      setOptionArityError: (state, segment) => {
+        const lastOption = state.options[state.options.length - 1];
+        return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
+      }
+    };
+    var NoLimits = /* @__PURE__ */ Symbol();
+    var CommandBuilder = class {
+      constructor(cliIndex, cliOpts) {
+        this.allOptionNames = [];
+        this.arity = { leading: [], trailing: [], extra: [], proxy: false };
+        this.options = [];
+        this.paths = [];
+        this.cliIndex = cliIndex;
+        this.cliOpts = cliOpts;
+      }
+      addPath(path16) {
+        this.paths.push(path16);
+      }
+      setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
+        Object.assign(this.arity, { leading, trailing, extra, proxy });
+      }
+      addPositional({ name: name2 = `arg`, required = true } = {}) {
+        if (!required && this.arity.extra === NoLimits)
+          throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
+        if (!required && this.arity.trailing.length > 0)
+          throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
+        if (!required && this.arity.extra !== NoLimits) {
+          this.arity.extra.push(name2);
+        } else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) {
+          this.arity.leading.push(name2);
+        } else {
+          this.arity.trailing.push(name2);
+        }
+      }
+      addRest({ name: name2 = `arg`, required = 0 } = {}) {
+        if (this.arity.extra === NoLimits)
+          throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
+        if (this.arity.trailing.length > 0)
+          throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
+        for (let t = 0; t < required; ++t)
+          this.addPositional({ name: name2 });
+        this.arity.extra = NoLimits;
+      }
+      addProxy({ required = 0 } = {}) {
+        this.addRest({ required });
+        this.arity.proxy = true;
+      }
+      addOption({ names, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
+        if (!allowBinding && arity > 1)
+          throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
+        if (!Number.isInteger(arity))
+          throw new Error(`The arity must be an integer, got ${arity}`);
+        if (arity < 0)
+          throw new Error(`The arity must be positive, got ${arity}`);
+        this.allOptionNames.push(...names);
+        this.options.push({ names, description, arity, hidden, required, allowBinding });
+      }
+      setContext(context) {
+        this.context = context;
       }
-      compareBuild(other) {
-        if (!(other instanceof _SemVer)) {
-          other = new _SemVer(other, this.options);
+      usage({ detailed = true, inlineOptions = true } = {}) {
+        const segments = [this.cliOpts.binaryName];
+        const detailedOptionList = [];
+        if (this.paths.length > 0)
+          segments.push(...this.paths[0]);
+        if (detailed) {
+          for (const { names, arity, hidden, description, required } of this.options) {
+            if (hidden)
+              continue;
+            const args = [];
+            for (let t = 0; t < arity; ++t)
+              args.push(` #${t}`);
+            const definition = `${names.join(`,`)}${args.join(``)}`;
+            if (!inlineOptions && description) {
+              detailedOptionList.push({ definition, description, required });
+            } else {
+              segments.push(required ? `<${definition}>` : `[${definition}]`);
+            }
+          }
+          segments.push(...this.arity.leading.map((name2) => `<${name2}>`));
+          if (this.arity.extra === NoLimits)
+            segments.push(`...`);
+          else
+            segments.push(...this.arity.extra.map((name2) => `[${name2}]`));
+          segments.push(...this.arity.trailing.map((name2) => `<${name2}>`));
+        }
+        const usage = segments.join(` `);
+        return { usage, options: detailedOptionList };
+      }
+      compile() {
+        if (typeof this.context === `undefined`)
+          throw new Error(`Assertion failed: No context attached`);
+        const machine = makeStateMachine();
+        let firstNode = constants2.NODE_INITIAL;
+        const candidateUsage = this.usage().usage;
+        const requiredOptions = this.options.filter((opt) => opt.required).map((opt) => opt.names);
+        firstNode = injectNode(machine, makeNode());
+        registerStatic(machine, constants2.NODE_INITIAL, constants2.START_OF_INPUT, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
+        const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`;
+        const paths = this.paths.length > 0 ? this.paths : [[]];
+        for (const path16 of paths) {
+          let lastPathNode = firstNode;
+          if (path16.length > 0) {
+            const optionPathNode = injectNode(machine, makeNode());
+            registerShortcut(machine, lastPathNode, optionPathNode);
+            this.registerOptions(machine, optionPathNode);
+            lastPathNode = optionPathNode;
+          }
+          for (let t = 0; t < path16.length; ++t) {
+            const nextPathNode = injectNode(machine, makeNode());
+            registerStatic(machine, lastPathNode, path16[t], nextPathNode, `pushPath`);
+            lastPathNode = nextPathNode;
+          }
+          if (this.arity.leading.length > 0 || !this.arity.proxy) {
+            const helpNode = injectNode(machine, makeNode());
+            registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
+            registerDynamic(machine, helpNode, `always`, helpNode, `pushExtra`);
+            registerStatic(machine, helpNode, constants2.END_OF_INPUT, constants2.NODE_SUCCESS, [`setSelectedIndex`, constants2.HELP_COMMAND_INDEX]);
+            this.registerOptions(machine, lastPathNode);
+          }
+          if (this.arity.leading.length > 0)
+            registerStatic(machine, lastPathNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+          let lastLeadingNode = lastPathNode;
+          for (let t = 0; t < this.arity.leading.length; ++t) {
+            const nextLeadingNode = injectNode(machine, makeNode());
+            if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
+              this.registerOptions(machine, nextLeadingNode);
+            if (this.arity.trailing.length > 0 || t + 1 !== this.arity.leading.length)
+              registerStatic(machine, nextLeadingNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+            registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
+            lastLeadingNode = nextLeadingNode;
+          }
+          let lastExtraNode = lastLeadingNode;
+          if (this.arity.extra === NoLimits || this.arity.extra.length > 0) {
+            const extraShortcutNode = injectNode(machine, makeNode());
+            registerShortcut(machine, lastLeadingNode, extraShortcutNode);
+            if (this.arity.extra === NoLimits) {
+              const extraNode = injectNode(machine, makeNode());
+              if (!this.arity.proxy)
+                this.registerOptions(machine, extraNode);
+              registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+              registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+              registerShortcut(machine, extraNode, extraShortcutNode);
+            } else {
+              for (let t = 0; t < this.arity.extra.length; ++t) {
+                const nextExtraNode = injectNode(machine, makeNode());
+                if (!this.arity.proxy || t > 0)
+                  this.registerOptions(machine, nextExtraNode);
+                registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
+                registerShortcut(machine, nextExtraNode, extraShortcutNode);
+                lastExtraNode = nextExtraNode;
+              }
+            }
+            lastExtraNode = extraShortcutNode;
+          }
+          if (this.arity.trailing.length > 0)
+            registerStatic(machine, lastExtraNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+          let lastTrailingNode = lastExtraNode;
+          for (let t = 0; t < this.arity.trailing.length; ++t) {
+            const nextTrailingNode = injectNode(machine, makeNode());
+            if (!this.arity.proxy)
+              this.registerOptions(machine, nextTrailingNode);
+            if (t + 1 < this.arity.trailing.length)
+              registerStatic(machine, nextTrailingNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
+            registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
+            lastTrailingNode = nextTrailingNode;
+          }
+          registerDynamic(machine, lastTrailingNode, positionalArgument, constants2.NODE_ERRORED, [`setError`, `Extraneous positional argument`]);
+          registerStatic(machine, lastTrailingNode, constants2.END_OF_INPUT, constants2.NODE_SUCCESS, [`setSelectedIndex`, this.cliIndex]);
         }
-        let i = 0;
-        do {
-          const a = this.build[i];
-          const b = other.build[i];
-          debug2("build compare", i, a, b);
-          if (a === void 0 && b === void 0) {
-            return 0;
-          } else if (b === void 0) {
-            return 1;
-          } else if (a === void 0) {
-            return -1;
-          } else if (a === b) {
-            continue;
+        return {
+          machine,
+          context: this.context
+        };
+      }
+      registerOptions(machine, node) {
+        registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
+        registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, `pushBatch`);
+        registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
+        registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], constants2.NODE_ERRORED, [`setError`, `Unsupported option name`]);
+        registerDynamic(machine, node, [`isInvalidOption`], constants2.NODE_ERRORED, [`setError`, `Invalid option name`]);
+        for (const option of this.options) {
+          const longestName = option.names.reduce((longestName2, name2) => {
+            return name2.length > longestName2.length ? name2 : longestName2;
+          }, ``);
+          if (option.arity === 0) {
+            for (const name2 of option.names) {
+              registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], node, `pushTrue`);
+              if (name2.startsWith(`--`) && !name2.startsWith(`--no-`)) {
+                registerDynamic(machine, node, [`isNegatedOption`, name2], node, [`pushFalse`, name2]);
+              }
+            }
           } else {
-            return compareIdentifiers(a, b);
+            let lastNode = injectNode(machine, makeNode());
+            for (const name2 of option.names)
+              registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], lastNode, `pushUndefined`);
+            for (let t = 0; t < option.arity; ++t) {
+              const nextNode = injectNode(machine, makeNode());
+              registerStatic(machine, lastNode, constants2.END_OF_INPUT, constants2.NODE_ERRORED, `setOptionArityError`);
+              registerDynamic(machine, lastNode, `isOptionLike`, constants2.NODE_ERRORED, `setOptionArityError`);
+              const action = option.arity === 1 ? `setStringValue` : `pushStringValue`;
+              registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
+              lastNode = nextNode;
+            }
+            registerShortcut(machine, lastNode, node);
           }
-        } while (++i);
-      }
-      // preminor will bump the version up to the next minor release, and immediately
-      // down to pre-release. premajor and prepatch work the same way.
-      inc(release, identifier, identifierBase) {
-        if (release.startsWith("pre")) {
-          if (!identifier && identifierBase === false) {
-            throw new Error("invalid increment argument: identifier is empty");
-          }
-          if (identifier) {
-            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
-            if (!match || match[1] !== identifier) {
-              throw new Error(`invalid identifier: ${identifier}`);
-            }
-          }
-        }
-        switch (release) {
-          case "premajor":
-            this.prerelease.length = 0;
-            this.patch = 0;
-            this.minor = 0;
-            this.major++;
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "preminor":
-            this.prerelease.length = 0;
-            this.patch = 0;
-            this.minor++;
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "prepatch":
-            this.prerelease.length = 0;
-            this.inc("patch", identifier, identifierBase);
-            this.inc("pre", identifier, identifierBase);
-            break;
-          // If the input is a non-prerelease version, this acts the same as
-          // prepatch.
-          case "prerelease":
-            if (this.prerelease.length === 0) {
-              this.inc("patch", identifier, identifierBase);
-            }
-            this.inc("pre", identifier, identifierBase);
-            break;
-          case "release":
-            if (this.prerelease.length === 0) {
-              throw new Error(`version ${this.raw} is not a prerelease`);
-            }
-            this.prerelease.length = 0;
-            break;
-          case "major":
-            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
-              this.major++;
-            }
-            this.minor = 0;
-            this.patch = 0;
-            this.prerelease = [];
-            break;
-          case "minor":
-            if (this.patch !== 0 || this.prerelease.length === 0) {
-              this.minor++;
-            }
-            this.patch = 0;
-            this.prerelease = [];
-            break;
-          case "patch":
-            if (this.prerelease.length === 0) {
-              this.patch++;
-            }
-            this.prerelease = [];
-            break;
-          // This probably shouldn't be used publicly.
-          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-          case "pre": {
-            const base = Number(identifierBase) ? 1 : 0;
-            if (this.prerelease.length === 0) {
-              this.prerelease = [base];
-            } else {
-              let i = this.prerelease.length;
-              while (--i >= 0) {
-                if (typeof this.prerelease[i] === "number") {
-                  this.prerelease[i]++;
-                  i = -2;
-                }
-              }
-              if (i === -1) {
-                if (identifier === this.prerelease.join(".") && identifierBase === false) {
-                  throw new Error("invalid increment argument: identifier already exists");
-                }
-                this.prerelease.push(base);
-              }
-            }
-            if (identifier) {
-              let prerelease = [identifier, base];
-              if (identifierBase === false) {
-                prerelease = [identifier];
-              }
-              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-                if (isNaN(this.prerelease[1])) {
-                  this.prerelease = prerelease;
-                }
-              } else {
-                this.prerelease = prerelease;
-              }
-            }
-            break;
-          }
-          default:
-            throw new Error(`invalid increment argument: ${release}`);
-        }
-        this.raw = this.format();
-        if (this.build.length) {
-          this.raw += `+${this.build.join(".")}`;
         }
+      }
+    };
+    var CliBuilder = class _CliBuilder {
+      constructor({ binaryName = `...` } = {}) {
+        this.builders = [];
+        this.opts = { binaryName };
+      }
+      static build(cbs, opts = {}) {
+        return new _CliBuilder(opts).commands(cbs).compile();
+      }
+      getBuilderByIndex(n) {
+        if (!(n >= 0 && n < this.builders.length))
+          throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
+        return this.builders[n];
+      }
+      commands(cbs) {
+        for (const cb of cbs)
+          cb(this.command());
         return this;
       }
+      command() {
+        const builder = new CommandBuilder(this.builders.length, this.opts);
+        this.builders.push(builder);
+        return builder;
+      }
+      compile() {
+        const machines = [];
+        const contexts = [];
+        for (const builder of this.builders) {
+          const { machine: machine2, context } = builder.compile();
+          machines.push(machine2);
+          contexts.push(context);
+        }
+        const machine = makeAnyOfMachine(machines);
+        simplifyMachine(machine);
+        return {
+          machine,
+          contexts,
+          process: (input) => {
+            return runMachine(machine, input);
+          },
+          suggest: (input, partial) => {
+            return suggestMachine(machine, input, partial);
+          }
+        };
+      }
     };
-    module2.exports = SemVer3;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/compare.js
-var require_compare = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/compare.js"(exports2, module2) {
-    "use strict";
-    var SemVer3 = require_semver();
-    var compare = (a, b, loose) => new SemVer3(a, loose).compare(new SemVer3(b, loose));
-    module2.exports = compare;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/rcompare.js
-var require_rcompare = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/rcompare.js"(exports2, module2) {
-    "use strict";
-    var compare = require_compare();
-    var rcompare = (a, b, loose) => compare(b, a, loose);
-    module2.exports = rcompare;
+    exports2.CliBuilder = CliBuilder;
+    exports2.CommandBuilder = CommandBuilder;
+    exports2.NoLimits = NoLimits;
+    exports2.aggregateHelpStates = aggregateHelpStates;
+    exports2.cloneNode = cloneNode;
+    exports2.cloneTransition = cloneTransition;
+    exports2.debug = debug;
+    exports2.debugMachine = debugMachine;
+    exports2.execute = execute;
+    exports2.injectNode = injectNode;
+    exports2.isTerminalNode = isTerminalNode;
+    exports2.makeAnyOfMachine = makeAnyOfMachine;
+    exports2.makeNode = makeNode;
+    exports2.makeStateMachine = makeStateMachine;
+    exports2.reducers = reducers;
+    exports2.registerDynamic = registerDynamic;
+    exports2.registerShortcut = registerShortcut;
+    exports2.registerStatic = registerStatic;
+    exports2.runMachineInternal = runMachineInternal;
+    exports2.selectBestState = selectBestState;
+    exports2.simplifyMachine = simplifyMachine;
+    exports2.suggest = suggest;
+    exports2.tests = tests;
+    exports2.trimSmallerBranches = trimSmallerBranches;
+  }
+});
+
+// node_modules/clipanion/lib/platform/node.mjs
+var node_exports = {};
+__export(node_exports, {
+  getCaptureActivator: () => getCaptureActivator,
+  getDefaultColorDepth: () => getDefaultColorDepth
+});
+function getDefaultColorDepth() {
+  if (import_tty.default && `getColorDepth` in import_tty.default.WriteStream.prototype)
+    return import_tty.default.WriteStream.prototype.getColorDepth();
+  if (process.env.FORCE_COLOR === `0`)
+    return 1;
+  if (process.env.FORCE_COLOR === `1`)
+    return 8;
+  if (typeof process.stdout !== `undefined` && process.stdout.isTTY)
+    return 8;
+  return 1;
+}
+function getCaptureActivator(context) {
+  let contextStorage = gContextStorage;
+  if (typeof contextStorage === `undefined`) {
+    if (context.stdout === process.stdout && context.stderr === process.stderr)
+      return null;
+    const { AsyncLocalStorage: LazyAsyncLocalStorage } = require("async_hooks");
+    contextStorage = gContextStorage = new LazyAsyncLocalStorage();
+    const origStdoutWrite = process.stdout._write;
+    process.stdout._write = function(chunk, encoding, cb) {
+      const context2 = contextStorage.getStore();
+      if (typeof context2 === `undefined`)
+        return origStdoutWrite.call(this, chunk, encoding, cb);
+      return context2.stdout.write(chunk, encoding, cb);
+    };
+    const origStderrWrite = process.stderr._write;
+    process.stderr._write = function(chunk, encoding, cb) {
+      const context2 = contextStorage.getStore();
+      if (typeof context2 === `undefined`)
+        return origStderrWrite.call(this, chunk, encoding, cb);
+      return context2.stderr.write(chunk, encoding, cb);
+    };
+  }
+  return (fn2) => {
+    return contextStorage.run(context, fn2);
+  };
+}
+var import_tty, gContextStorage;
+var init_node = __esm({
+  "node_modules/clipanion/lib/platform/node.mjs"() {
+    import_tty = __toESM(require("tty"), 1);
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/parse.js
-var require_parse = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/parse.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/HelpCommand.js
+var require_HelpCommand = __commonJS({
+  "node_modules/clipanion/lib/advanced/HelpCommand.js"(exports2) {
     "use strict";
-    var SemVer3 = require_semver();
-    var parse4 = (version2, options, throwErrors = false) => {
-      if (version2 instanceof SemVer3) {
-        return version2;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_Command = require_Command();
+    var HelpCommand = class _HelpCommand extends advanced_Command.Command {
+      constructor(contexts) {
+        super();
+        this.contexts = contexts;
+        this.commands = [];
+      }
+      static from(state, contexts) {
+        const command = new _HelpCommand(contexts);
+        command.path = state.path;
+        for (const opt of state.options) {
+          switch (opt.name) {
+            case `-c`:
+              {
+                command.commands.push(Number(opt.value));
+              }
+              break;
+            case `-i`:
+              {
+                command.index = Number(opt.value);
+              }
+              break;
+          }
+        }
+        return command;
       }
-      try {
-        return new SemVer3(version2, options);
-      } catch (er) {
-        if (!throwErrors) {
-          return null;
+      async execute() {
+        let commands = this.commands;
+        if (typeof this.index !== `undefined` && this.index >= 0 && this.index < commands.length)
+          commands = [commands[this.index]];
+        if (commands.length === 0) {
+          this.context.stdout.write(this.cli.usage());
+        } else if (commands.length === 1) {
+          this.context.stdout.write(this.cli.usage(this.contexts[commands[0]].commandClass, { detailed: true }));
+        } else if (commands.length > 1) {
+          this.context.stdout.write(`Multiple commands match your selection:
+`);
+          this.context.stdout.write(`
+`);
+          let index = 0;
+          for (const command of this.commands)
+            this.context.stdout.write(this.cli.usage(this.contexts[command].commandClass, { prefix: `${index++}. `.padStart(5) }));
+          this.context.stdout.write(`
+`);
+          this.context.stdout.write(`Run again with -h=<index> to see the longer details of any of those commands.
+`);
         }
-        throw er;
       }
     };
-    module2.exports = parse4;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/valid.js
-var require_valid = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/valid.js"(exports2, module2) {
-    "use strict";
-    var parse4 = require_parse();
-    var valid = (version2, options) => {
-      const v = parse4(version2, options);
-      return v ? v.version : null;
-    };
-    module2.exports = valid;
+    exports2.HelpCommand = HelpCommand;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/lrucache.js
-var require_lrucache = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/internal/lrucache.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/Cli.js
+var require_Cli = __commonJS({
+  "node_modules/clipanion/lib/advanced/Cli.js"(exports2) {
     "use strict";
-    var LRUCache = class {
-      constructor() {
-        this.max = 1e3;
-        this.map = /* @__PURE__ */ new Map();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var constants2 = require_constants();
+    var core = require_core();
+    var format = require_format();
+    var platform5 = (init_node(), __toCommonJS(node_exports));
+    var advanced_Command = require_Command();
+    var advanced_HelpCommand = require_HelpCommand();
+    var errorCommandSymbol = /* @__PURE__ */ Symbol(`clipanion/errorCommand`);
+    async function runExit(...args) {
+      const { resolvedOptions, resolvedCommandClasses, resolvedArgv, resolvedContext } = resolveRunParameters(args);
+      const cli = Cli2.from(resolvedCommandClasses, resolvedOptions);
+      return cli.runExit(resolvedArgv, resolvedContext);
+    }
+    async function run(...args) {
+      const { resolvedOptions, resolvedCommandClasses, resolvedArgv, resolvedContext } = resolveRunParameters(args);
+      const cli = Cli2.from(resolvedCommandClasses, resolvedOptions);
+      return cli.run(resolvedArgv, resolvedContext);
+    }
+    function resolveRunParameters(args) {
+      let resolvedOptions;
+      let resolvedCommandClasses;
+      let resolvedArgv;
+      let resolvedContext;
+      if (typeof process !== `undefined` && typeof process.argv !== `undefined`)
+        resolvedArgv = process.argv.slice(2);
+      switch (args.length) {
+        case 1:
+          {
+            resolvedCommandClasses = args[0];
+          }
+          break;
+        case 2:
+          {
+            if (args[0] && args[0].prototype instanceof advanced_Command.Command || Array.isArray(args[0])) {
+              resolvedCommandClasses = args[0];
+              if (Array.isArray(args[1])) {
+                resolvedArgv = args[1];
+              } else {
+                resolvedContext = args[1];
+              }
+            } else {
+              resolvedOptions = args[0];
+              resolvedCommandClasses = args[1];
+            }
+          }
+          break;
+        case 3:
+          {
+            if (Array.isArray(args[2])) {
+              resolvedOptions = args[0];
+              resolvedCommandClasses = args[1];
+              resolvedArgv = args[2];
+            } else if (args[0] && args[0].prototype instanceof advanced_Command.Command || Array.isArray(args[0])) {
+              resolvedCommandClasses = args[0];
+              resolvedArgv = args[1];
+              resolvedContext = args[2];
+            } else {
+              resolvedOptions = args[0];
+              resolvedCommandClasses = args[1];
+              resolvedContext = args[2];
+            }
+          }
+          break;
+        default:
+          {
+            resolvedOptions = args[0];
+            resolvedCommandClasses = args[1];
+            resolvedArgv = args[2];
+            resolvedContext = args[3];
+          }
+          break;
       }
-      get(key) {
-        const value = this.map.get(key);
-        if (value === void 0) {
-          return void 0;
-        } else {
-          this.map.delete(key);
-          this.map.set(key, value);
-          return value;
-        }
+      if (typeof resolvedArgv === `undefined`)
+        throw new Error(`The argv parameter must be provided when running Clipanion outside of a Node context`);
+      return {
+        resolvedOptions,
+        resolvedCommandClasses,
+        resolvedArgv,
+        resolvedContext
+      };
+    }
+    var Cli2 = class _Cli {
+      constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
+        this.registrations = /* @__PURE__ */ new Map();
+        this.builder = new core.CliBuilder({ binaryName: binaryNameOpt });
+        this.binaryLabel = binaryLabel;
+        this.binaryName = binaryNameOpt;
+        this.binaryVersion = binaryVersion;
+        this.enableCapture = enableCapture;
+        this.enableColors = enableColors;
       }
-      delete(key) {
-        return this.map.delete(key);
+      /**
+       * Creates a new Cli and registers all commands passed as parameters.
+       *
+       * @param commandClasses The Commands to register
+       * @returns The created `Cli` instance
+       */
+      static from(commandClasses, options = {}) {
+        const cli = new _Cli(options);
+        const resolvedCommandClasses = Array.isArray(commandClasses) ? commandClasses : [commandClasses];
+        for (const commandClass of resolvedCommandClasses)
+          cli.register(commandClass);
+        return cli;
       }
-      set(key, value) {
-        const deleted = this.delete(key);
-        if (!deleted && value !== void 0) {
-          if (this.map.size >= this.max) {
-            const firstKey = this.map.keys().next().value;
-            this.delete(firstKey);
+      /**
+       * Registers a command inside the CLI.
+       */
+      register(commandClass) {
+        var _a;
+        const specs = /* @__PURE__ */ new Map();
+        const command = new commandClass();
+        for (const key in command) {
+          const value = command[key];
+          if (typeof value === `object` && value !== null && value[advanced_Command.Command.isOption]) {
+            specs.set(key, value);
+          }
+        }
+        const builder = this.builder.command();
+        const index = builder.cliIndex;
+        const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths;
+        if (typeof paths !== `undefined`)
+          for (const path16 of paths)
+            builder.addPath(path16);
+        this.registrations.set(commandClass, { specs, builder, index });
+        for (const [key, { definition }] of specs.entries())
+          definition(builder, key);
+        builder.setContext({
+          commandClass
+        });
+      }
+      process(input, userContext) {
+        const { contexts, process: process5 } = this.builder.compile();
+        const state = process5(input);
+        const context = {
+          ..._Cli.defaultContext,
+          ...userContext
+        };
+        switch (state.selectedIndex) {
+          case constants2.HELP_COMMAND_INDEX: {
+            const command = advanced_HelpCommand.HelpCommand.from(state, contexts);
+            command.context = context;
+            return command;
           }
-          this.map.set(key, value);
+          default:
+            {
+              const { commandClass } = contexts[state.selectedIndex];
+              const record = this.registrations.get(commandClass);
+              if (typeof record === `undefined`)
+                throw new Error(`Assertion failed: Expected the command class to have been registered.`);
+              const command = new commandClass();
+              command.context = context;
+              command.path = state.path;
+              try {
+                for (const [key, { transformer }] of record.specs.entries())
+                  command[key] = transformer(record.builder, key, state, context);
+                return command;
+              } catch (error) {
+                error[errorCommandSymbol] = command;
+                throw error;
+              }
+            }
+            break;
         }
-        return this;
       }
-    };
-    module2.exports = LRUCache;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/eq.js
-var require_eq = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/eq.js"(exports2, module2) {
-    "use strict";
-    var compare = require_compare();
-    var eq = (a, b, loose) => compare(a, b, loose) === 0;
-    module2.exports = eq;
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/neq.js
-var require_neq = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/neq.js"(exports2, module2) {
-    "use strict";
-    var compare = require_compare();
-    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
-    module2.exports = neq;
+      async run(input, userContext) {
+        var _a, _b;
+        let command;
+        const context = {
+          ..._Cli.defaultContext,
+          ...userContext
+        };
+        const colored = (_a = this.enableColors) !== null && _a !== void 0 ? _a : context.colorDepth > 1;
+        if (!Array.isArray(input)) {
+          command = input;
+        } else {
+          try {
+            command = this.process(input, context);
+          } catch (error) {
+            context.stdout.write(this.error(error, { colored }));
+            return 1;
+          }
+        }
+        if (command.help) {
+          context.stdout.write(this.usage(command, { colored, detailed: true }));
+          return 0;
+        }
+        command.context = context;
+        command.cli = {
+          binaryLabel: this.binaryLabel,
+          binaryName: this.binaryName,
+          binaryVersion: this.binaryVersion,
+          enableCapture: this.enableCapture,
+          enableColors: this.enableColors,
+          definitions: () => this.definitions(),
+          error: (error, opts) => this.error(error, opts),
+          format: (colored2) => this.format(colored2),
+          process: (input2, subContext) => this.process(input2, { ...context, ...subContext }),
+          run: (input2, subContext) => this.run(input2, { ...context, ...subContext }),
+          usage: (command2, opts) => this.usage(command2, opts)
+        };
+        const activate = this.enableCapture ? (_b = platform5.getCaptureActivator(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator;
+        let exitCode;
+        try {
+          exitCode = await activate(() => command.validateAndExecute().catch((error) => command.catch(error).then(() => 0)));
+        } catch (error) {
+          context.stdout.write(this.error(error, { colored, command }));
+          return 1;
+        }
+        return exitCode;
+      }
+      async runExit(input, context) {
+        process.exitCode = await this.run(input, context);
+      }
+      suggest(input, partial) {
+        const { suggest } = this.builder.compile();
+        return suggest(input, partial);
+      }
+      definitions({ colored = false } = {}) {
+        const data = [];
+        for (const [commandClass, { index }] of this.registrations) {
+          if (typeof commandClass.usage === `undefined`)
+            continue;
+          const { usage: path16 } = this.getUsageByIndex(index, { detailed: false });
+          const { usage, options } = this.getUsageByIndex(index, { detailed: true, inlineOptions: false });
+          const category = typeof commandClass.usage.category !== `undefined` ? format.formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0;
+          const description = typeof commandClass.usage.description !== `undefined` ? format.formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0;
+          const details = typeof commandClass.usage.details !== `undefined` ? format.formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0;
+          const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli]) => [format.formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli.replace(/\$0/g, this.binaryName)]) : void 0;
+          data.push({ path: path16, usage, category, description, details, examples, options });
+        }
+        return data;
+      }
+      usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
+        var _a;
+        if (command === null) {
+          for (const commandClass2 of this.registrations.keys()) {
+            const paths = commandClass2.paths;
+            const isDocumented = typeof commandClass2.usage !== `undefined`;
+            const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 && paths[0].length === 0;
+            const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path16) => path16.length === 0)) !== null && _a !== void 0 ? _a : false);
+            if (isDefault) {
+              if (command) {
+                command = null;
+                break;
+              } else {
+                command = commandClass2;
+              }
+            } else {
+              if (isDocumented) {
+                command = null;
+                continue;
+              }
+            }
+          }
+          if (command) {
+            detailed = true;
+          }
+        }
+        const commandClass = command !== null && command instanceof advanced_Command.Command ? command.constructor : command;
+        let result = ``;
+        if (!commandClass) {
+          const commandsByCategories = /* @__PURE__ */ new Map();
+          for (const [commandClass2, { index }] of this.registrations.entries()) {
+            if (typeof commandClass2.usage === `undefined`)
+              continue;
+            const category = typeof commandClass2.usage.category !== `undefined` ? format.formatMarkdownish(commandClass2.usage.category, { format: this.format(colored), paragraphs: false }) : null;
+            let categoryCommands = commandsByCategories.get(category);
+            if (typeof categoryCommands === `undefined`)
+              commandsByCategories.set(category, categoryCommands = []);
+            const { usage } = this.getUsageByIndex(index);
+            categoryCommands.push({ commandClass: commandClass2, usage });
+          }
+          const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) => {
+            if (a === null)
+              return -1;
+            if (b === null)
+              return 1;
+            return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
+          });
+          const hasLabel = typeof this.binaryLabel !== `undefined`;
+          const hasVersion = typeof this.binaryVersion !== `undefined`;
+          if (hasLabel || hasVersion) {
+            if (hasLabel && hasVersion)
+              result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}
+
+`;
+            else if (hasLabel)
+              result += `${this.format(colored).header(`${this.binaryLabel}`)}
+`;
+            else
+              result += `${this.format(colored).header(`${this.binaryVersion}`)}
+`;
+            result += `  ${this.format(colored).bold(prefix)}${this.binaryName} <command>
+`;
+          } else {
+            result += `${this.format(colored).bold(prefix)}${this.binaryName} <command>
+`;
+          }
+          for (const categoryName of categoryNames) {
+            const commands = commandsByCategories.get(categoryName).slice().sort((a, b) => {
+              return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
+            });
+            const header = categoryName !== null ? categoryName.trim() : `General commands`;
+            result += `
+`;
+            result += `${this.format(colored).header(`${header}`)}
+`;
+            for (const { commandClass: commandClass2, usage } of commands) {
+              const doc = commandClass2.usage.description || `undocumented`;
+              result += `
+`;
+              result += `  ${this.format(colored).bold(usage)}
+`;
+              result += `    ${format.formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
+            }
+          }
+          result += `
+`;
+          result += format.formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
+        } else {
+          if (!detailed) {
+            const { usage } = this.getUsageByRegistration(commandClass);
+            result += `${this.format(colored).bold(prefix)}${usage}
+`;
+          } else {
+            const { description = ``, details = ``, examples = [] } = commandClass.usage || {};
+            if (description !== ``) {
+              result += format.formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, ($0) => $0.toUpperCase());
+              result += `
+`;
+            }
+            if (details !== `` || examples.length > 0) {
+              result += `${this.format(colored).header(`Usage`)}
+`;
+              result += `
+`;
+            }
+            const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
+            result += `${this.format(colored).bold(prefix)}${usage}
+`;
+            if (options.length > 0) {
+              result += `
+`;
+              result += `${this.format(colored).header(`Options`)}
+`;
+              const maxDefinitionLength = options.reduce((length, option) => {
+                return Math.max(length, option.definition.length);
+              }, 0);
+              result += `
+`;
+              for (const { definition, description: description2 } of options) {
+                result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${format.formatMarkdownish(description2, { format: this.format(colored), paragraphs: false })}`;
+              }
+            }
+            if (details !== ``) {
+              result += `
+`;
+              result += `${this.format(colored).header(`Details`)}
+`;
+              result += `
+`;
+              result += format.formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
+            }
+            if (examples.length > 0) {
+              result += `
+`;
+              result += `${this.format(colored).header(`Examples`)}
+`;
+              for (const [description2, example] of examples) {
+                result += `
+`;
+                result += format.formatMarkdownish(description2, { format: this.format(colored), paragraphs: false });
+                result += `${example.replace(/^/m, `  ${this.format(colored).bold(prefix)}`).replace(/\$0/g, this.binaryName)}
+`;
+              }
+            }
+          }
+        }
+        return result;
+      }
+      error(error, _a) {
+        var _b;
+        var { colored, command = (_b = error[errorCommandSymbol]) !== null && _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
+        if (!error || typeof error !== `object` || !(`stack` in error))
+          error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
+        let result = ``;
+        let name2 = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
+        if (name2 === `Error`)
+          name2 = `Internal Error`;
+        result += `${this.format(colored).error(name2)}: ${error.message}
+`;
+        const meta = error.clipanion;
+        if (typeof meta !== `undefined`) {
+          if (meta.type === `usage`) {
+            result += `
+`;
+            result += this.usage(command);
+          }
+        } else {
+          if (error.stack) {
+            result += `${error.stack.replace(/^.*\n/, ``)}
+`;
+          }
+        }
+        return result;
+      }
+      format(colored) {
+        var _a;
+        return ((_a = colored !== null && colored !== void 0 ? colored : this.enableColors) !== null && _a !== void 0 ? _a : _Cli.defaultContext.colorDepth > 1) ? format.richFormat : format.textFormat;
+      }
+      getUsageByRegistration(klass, opts) {
+        const record = this.registrations.get(klass);
+        if (typeof record === `undefined`)
+          throw new Error(`Assertion failed: Unregistered command`);
+        return this.getUsageByIndex(record.index, opts);
+      }
+      getUsageByIndex(n, opts) {
+        return this.builder.getBuilderByIndex(n).usage(opts);
+      }
+    };
+    Cli2.defaultContext = {
+      env: process.env,
+      stdin: process.stdin,
+      stdout: process.stdout,
+      stderr: process.stderr,
+      colorDepth: platform5.getDefaultColorDepth()
+    };
+    function noopCaptureActivator(fn2) {
+      return fn2();
+    }
+    exports2.Cli = Cli2;
+    exports2.run = run;
+    exports2.runExit = runExit;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/gt.js
-var require_gt = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/gt.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/builtins/definitions.js
+var require_definitions = __commonJS({
+  "node_modules/clipanion/lib/advanced/builtins/definitions.js"(exports2) {
     "use strict";
-    var compare = require_compare();
-    var gt = (a, b, loose) => compare(a, b, loose) > 0;
-    module2.exports = gt;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_Command = require_Command();
+    var DefinitionsCommand = class extends advanced_Command.Command {
+      async execute() {
+        this.context.stdout.write(`${JSON.stringify(this.cli.definitions(), null, 2)}
+`);
+      }
+    };
+    DefinitionsCommand.paths = [[`--clipanion=definitions`]];
+    exports2.DefinitionsCommand = DefinitionsCommand;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/gte.js
-var require_gte = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/gte.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/builtins/help.js
+var require_help = __commonJS({
+  "node_modules/clipanion/lib/advanced/builtins/help.js"(exports2) {
     "use strict";
-    var compare = require_compare();
-    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
-    module2.exports = gte;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_Command = require_Command();
+    var HelpCommand = class extends advanced_Command.Command {
+      async execute() {
+        this.context.stdout.write(this.cli.usage());
+      }
+    };
+    HelpCommand.paths = [[`-h`], [`--help`]];
+    exports2.HelpCommand = HelpCommand;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/lt.js
-var require_lt = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/lt.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/builtins/version.js
+var require_version = __commonJS({
+  "node_modules/clipanion/lib/advanced/builtins/version.js"(exports2) {
     "use strict";
-    var compare = require_compare();
-    var lt = (a, b, loose) => compare(a, b, loose) < 0;
-    module2.exports = lt;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_Command = require_Command();
+    var VersionCommand = class extends advanced_Command.Command {
+      async execute() {
+        var _a;
+        this.context.stdout.write(`${(_a = this.cli.binaryVersion) !== null && _a !== void 0 ? _a : `<unknown>`}
+`);
+      }
+    };
+    VersionCommand.paths = [[`-v`], [`--version`]];
+    exports2.VersionCommand = VersionCommand;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/lte.js
-var require_lte = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/lte.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/builtins/index.js
+var require_builtins = __commonJS({
+  "node_modules/clipanion/lib/advanced/builtins/index.js"(exports2) {
     "use strict";
-    var compare = require_compare();
-    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
-    module2.exports = lte;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_builtins_definitions = require_definitions();
+    var advanced_builtins_help = require_help();
+    var advanced_builtins_version = require_version();
+    exports2.DefinitionsCommand = advanced_builtins_definitions.DefinitionsCommand;
+    exports2.HelpCommand = advanced_builtins_help.HelpCommand;
+    exports2.VersionCommand = advanced_builtins_version.VersionCommand;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/cmp.js
-var require_cmp = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/cmp.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/options/Array.js
+var require_Array = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/Array.js"(exports2) {
     "use strict";
-    var eq = require_eq();
-    var neq = require_neq();
-    var gt = require_gt();
-    var gte = require_gte();
-    var lt = require_lt();
-    var lte = require_lte();
-    var cmp = (a, op, b, loose) => {
-      switch (op) {
-        case "===":
-          if (typeof a === "object") {
-            a = a.version;
-          }
-          if (typeof b === "object") {
-            b = b.version;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_options_utils = require_utils();
+    function Array2(descriptor, initialValueBase, optsBase) {
+      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
+      const { arity = 1 } = opts;
+      const optNames = descriptor.split(`,`);
+      const nameSet = new Set(optNames);
+      return advanced_options_utils.makeCommandOption({
+        definition(builder) {
+          builder.addOption({
+            names: optNames,
+            arity,
+            hidden: opts === null || opts === void 0 ? void 0 : opts.hidden,
+            description: opts === null || opts === void 0 ? void 0 : opts.description,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state) {
+          let usedName;
+          let currentValue = typeof initialValue !== `undefined` ? [...initialValue] : void 0;
+          for (const { name: name2, value } of state.options) {
+            if (!nameSet.has(name2))
+              continue;
+            usedName = name2;
+            currentValue = currentValue !== null && currentValue !== void 0 ? currentValue : [];
+            currentValue.push(value);
           }
-          return a === b;
-        case "!==":
-          if (typeof a === "object") {
-            a = a.version;
+          if (typeof currentValue !== `undefined`) {
+            return advanced_options_utils.applyValidator(usedName !== null && usedName !== void 0 ? usedName : key, currentValue, opts.validator);
+          } else {
+            return currentValue;
           }
-          if (typeof b === "object") {
-            b = b.version;
+        }
+      });
+    }
+    exports2.Array = Array2;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/Boolean.js
+var require_Boolean = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/Boolean.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_options_utils = require_utils();
+    function Boolean2(descriptor, initialValueBase, optsBase) {
+      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
+      const optNames = descriptor.split(`,`);
+      const nameSet = new Set(optNames);
+      return advanced_options_utils.makeCommandOption({
+        definition(builder) {
+          builder.addOption({
+            names: optNames,
+            allowBinding: false,
+            arity: 0,
+            hidden: opts.hidden,
+            description: opts.description,
+            required: opts.required
+          });
+        },
+        transformer(builer, key, state) {
+          let currentValue = initialValue;
+          for (const { name: name2, value } of state.options) {
+            if (!nameSet.has(name2))
+              continue;
+            currentValue = value;
           }
-          return a !== b;
-        case "":
-        case "=":
-        case "==":
-          return eq(a, b, loose);
-        case "!=":
-          return neq(a, b, loose);
-        case ">":
-          return gt(a, b, loose);
-        case ">=":
-          return gte(a, b, loose);
-        case "<":
-          return lt(a, b, loose);
-        case "<=":
-          return lte(a, b, loose);
-        default:
-          throw new TypeError(`Invalid operator: ${op}`);
-      }
-    };
-    module2.exports = cmp;
+          return currentValue;
+        }
+      });
+    }
+    exports2.Boolean = Boolean2;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/comparator.js
-var require_comparator = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/comparator.js"(exports2, module2) {
+// node_modules/clipanion/lib/advanced/options/Counter.js
+var require_Counter = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/Counter.js"(exports2) {
     "use strict";
-    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
-    var Comparator = class _Comparator {
-      static get ANY() {
-        return ANY;
-      }
-      constructor(comp, options) {
-        options = parseOptions(options);
-        if (comp instanceof _Comparator) {
-          if (comp.loose === !!options.loose) {
-            return comp;
-          } else {
-            comp = comp.value;
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_options_utils = require_utils();
+    function Counter(descriptor, initialValueBase, optsBase) {
+      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
+      const optNames = descriptor.split(`,`);
+      const nameSet = new Set(optNames);
+      return advanced_options_utils.makeCommandOption({
+        definition(builder) {
+          builder.addOption({
+            names: optNames,
+            allowBinding: false,
+            arity: 0,
+            hidden: opts.hidden,
+            description: opts.description,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state) {
+          let currentValue = initialValue;
+          for (const { name: name2, value } of state.options) {
+            if (!nameSet.has(name2))
+              continue;
+            currentValue !== null && currentValue !== void 0 ? currentValue : currentValue = 0;
+            if (!value) {
+              currentValue = 0;
+            } else {
+              currentValue += 1;
+            }
           }
+          return currentValue;
         }
-        comp = comp.trim().split(/\s+/).join(" ");
-        debug2("comparator", comp, options);
-        this.options = options;
-        this.loose = !!options.loose;
-        this.parse(comp);
-        if (this.semver === ANY) {
-          this.value = "";
-        } else {
-          this.value = this.operator + this.semver.version;
+      });
+    }
+    exports2.Counter = Counter;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/Proxy.js
+var require_Proxy = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/Proxy.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_options_utils = require_utils();
+    function Proxy2(opts = {}) {
+      return advanced_options_utils.makeCommandOption({
+        definition(builder, key) {
+          var _a;
+          builder.addProxy({
+            name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state) {
+          return state.positionals.map(({ value }) => value);
         }
-        debug2("comp", this);
-      }
-      parse(comp) {
-        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-        const m = comp.match(r);
-        if (!m) {
-          throw new TypeError(`Invalid comparator: ${comp}`);
+      });
+    }
+    exports2.Proxy = Proxy2;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/Rest.js
+var require_Rest = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/Rest.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var core = require_core();
+    var advanced_options_utils = require_utils();
+    function Rest(opts = {}) {
+      return advanced_options_utils.makeCommandOption({
+        definition(builder, key) {
+          var _a;
+          builder.addRest({
+            name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state) {
+          const isRestPositional = (index) => {
+            const positional = state.positionals[index];
+            if (positional.extra === core.NoLimits)
+              return true;
+            if (positional.extra === false && index < builder.arity.leading.length)
+              return true;
+            return false;
+          };
+          let count = 0;
+          while (count < state.positionals.length && isRestPositional(count))
+            count += 1;
+          return state.positionals.splice(0, count).map(({ value }) => value);
         }
-        this.operator = m[1] !== void 0 ? m[1] : "";
-        if (this.operator === "=") {
-          this.operator = "";
+      });
+    }
+    exports2.Rest = Rest;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/String.js
+var require_String = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/String.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var core = require_core();
+    var advanced_options_utils = require_utils();
+    function StringOption(descriptor, initialValueBase, optsBase) {
+      const [initialValue, opts] = advanced_options_utils.rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
+      const { arity = 1 } = opts;
+      const optNames = descriptor.split(`,`);
+      const nameSet = new Set(optNames);
+      return advanced_options_utils.makeCommandOption({
+        definition(builder) {
+          builder.addOption({
+            names: optNames,
+            arity: opts.tolerateBoolean ? 0 : arity,
+            hidden: opts.hidden,
+            description: opts.description,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state, context) {
+          let usedName;
+          let currentValue = initialValue;
+          if (typeof opts.env !== `undefined` && context.env[opts.env]) {
+            usedName = opts.env;
+            currentValue = context.env[opts.env];
+          }
+          for (const { name: name2, value } of state.options) {
+            if (!nameSet.has(name2))
+              continue;
+            usedName = name2;
+            currentValue = value;
+          }
+          if (typeof currentValue === `string`) {
+            return advanced_options_utils.applyValidator(usedName !== null && usedName !== void 0 ? usedName : key, currentValue, opts.validator);
+          } else {
+            return currentValue;
+          }
         }
-        if (!m[2]) {
-          this.semver = ANY;
-        } else {
-          this.semver = new SemVer3(m[2], this.options.loose);
+      });
+    }
+    function StringPositional(opts = {}) {
+      const { required = true } = opts;
+      return advanced_options_utils.makeCommandOption({
+        definition(builder, key) {
+          var _a;
+          builder.addPositional({
+            name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
+            required: opts.required
+          });
+        },
+        transformer(builder, key, state) {
+          var _a;
+          for (let i = 0; i < state.positionals.length; ++i) {
+            if (state.positionals[i].extra === core.NoLimits)
+              continue;
+            if (required && state.positionals[i].extra === true)
+              continue;
+            if (!required && state.positionals[i].extra === false)
+              continue;
+            const [positional] = state.positionals.splice(i, 1);
+            return advanced_options_utils.applyValidator((_a = opts.name) !== null && _a !== void 0 ? _a : key, positional.value, opts.validator);
+          }
+          return void 0;
         }
+      });
+    }
+    function String2(descriptor, ...args) {
+      if (typeof descriptor === `string`) {
+        return StringOption(descriptor, ...args);
+      } else {
+        return StringPositional(descriptor);
       }
-      toString() {
-        return this.value;
+    }
+    exports2.String = String2;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/options/index.js
+var require_options = __commonJS({
+  "node_modules/clipanion/lib/advanced/options/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var advanced_options_utils = require_utils();
+    var advanced_options_Array = require_Array();
+    var advanced_options_Boolean = require_Boolean();
+    var advanced_options_Counter = require_Counter();
+    var advanced_options_Proxy = require_Proxy();
+    var advanced_options_Rest = require_Rest();
+    var advanced_options_String = require_String();
+    exports2.applyValidator = advanced_options_utils.applyValidator;
+    exports2.cleanValidationError = advanced_options_utils.cleanValidationError;
+    exports2.formatError = advanced_options_utils.formatError;
+    exports2.isOptionSymbol = advanced_options_utils.isOptionSymbol;
+    exports2.makeCommandOption = advanced_options_utils.makeCommandOption;
+    exports2.rerouteArguments = advanced_options_utils.rerouteArguments;
+    exports2.Array = advanced_options_Array.Array;
+    exports2.Boolean = advanced_options_Boolean.Boolean;
+    exports2.Counter = advanced_options_Counter.Counter;
+    exports2.Proxy = advanced_options_Proxy.Proxy;
+    exports2.Rest = advanced_options_Rest.Rest;
+    exports2.String = advanced_options_String.String;
+  }
+});
+
+// node_modules/clipanion/lib/advanced/index.js
+var require_advanced = __commonJS({
+  "node_modules/clipanion/lib/advanced/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var errors = require_errors();
+    var format = require_format();
+    var advanced_Command = require_Command();
+    var advanced_Cli = require_Cli();
+    var advanced_builtins_index = require_builtins();
+    var advanced_options_index = require_options();
+    exports2.UsageError = errors.UsageError;
+    exports2.formatMarkdownish = format.formatMarkdownish;
+    exports2.Command = advanced_Command.Command;
+    exports2.Cli = advanced_Cli.Cli;
+    exports2.run = advanced_Cli.run;
+    exports2.runExit = advanced_Cli.runExit;
+    exports2.Builtins = advanced_builtins_index;
+    exports2.Option = advanced_options_index;
+  }
+});
+
+// node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "node_modules/semver/internal/debug.js"(exports2, module2) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  }
+});
+
+// node_modules/semver/internal/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/semver/internal/constants.js"(exports2, module2) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "node_modules/semver/internal/re.js"(exports2, module2) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants2();
+    var debug = require_debug();
+    exports2 = module2.exports = {};
+    var re = exports2.re = [];
+    var safeRe = exports2.safeRe = [];
+    var src = exports2.src = [];
+    var safeSrc = exports2.safeSrc = [];
+    var t = exports2.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
       }
-      test(version2) {
-        debug2("Comparator.test", version2, this.options.loose);
-        if (this.semver === ANY || version2 === ANY) {
-          return true;
-        }
-        if (typeof version2 === "string") {
-          try {
-            version2 = new SemVer3(version2, this.options);
-          } catch (er) {
-            return false;
-          }
-        }
-        return cmp(version2, this.operator, this.semver, this.options);
+      return value;
+    };
+    var createToken = (name2, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name2, index, value);
+      t[name2] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports2.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports2.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports2.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "node_modules/semver/internal/parse-options.js"(exports2, module2) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
       }
-      intersects(comp, options) {
-        if (!(comp instanceof _Comparator)) {
-          throw new TypeError("a Comparator is required");
-        }
-        if (this.operator === "") {
-          if (this.value === "") {
-            return true;
-          }
-          return new Range3(comp.value, options).test(this.value);
-        } else if (comp.operator === "") {
-          if (comp.value === "") {
-            return true;
-          }
-          return new Range3(this.value, options).test(comp.semver);
-        }
-        options = parseOptions(options);
-        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
-          return false;
-        }
-        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
-          return false;
-        }
-        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
-          return true;
-        }
-        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
-          return true;
-        }
-        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
-          return true;
-        }
-        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
-          return true;
-        }
-        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
-          return true;
-        }
-        return false;
+      if (typeof options !== "object") {
+        return looseOption;
       }
+      return options;
     };
-    module2.exports = Comparator;
-    var parseOptions = require_parse_options();
-    var { safeRe: re, t } = require_re();
-    var cmp = require_cmp();
-    var debug2 = require_debug();
-    var SemVer3 = require_semver();
-    var Range3 = require_range();
+    module2.exports = parseOptions;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/range.js
-var require_range = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/range.js"(exports2, module2) {
+// node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "node_modules/semver/internal/identifiers.js"(exports2, module2) {
     "use strict";
-    var SPACE_CHARACTERS = /\s+/g;
-    var Range3 = class _Range {
-      constructor(range, options) {
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "node_modules/semver/classes/semver.js"(exports2, module2) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var SemVer3 = class _SemVer {
+      constructor(version2, options) {
         options = parseOptions(options);
-        if (range instanceof _Range) {
-          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-            return range;
+        if (version2 instanceof _SemVer) {
+          if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
+            return version2;
           } else {
-            return new _Range(range.raw, options);
+            version2 = version2.version;
           }
+        } else if (typeof version2 !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
         }
-        if (range instanceof Comparator) {
-          this.raw = range.value;
-          this.set = [[range]];
-          this.formatted = void 0;
-          return this;
+        if (version2.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
         }
+        debug("SemVer", version2, options);
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
-        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
-        if (!this.set.length) {
-          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version2}`);
         }
-        if (this.set.length > 1) {
-          const first = this.set[0];
-          this.set = this.set.filter((c) => !isNullSet(c[0]));
-          if (this.set.length === 0) {
-            this.set = [first];
-          } else if (this.set.length > 1) {
-            for (const c of this.set) {
-              if (c.length === 1 && isAny(c[0])) {
-                this.set = [c];
-                break;
-              }
-            }
-          }
+        this.raw = version2;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
         }
-        this.formatted = void 0;
-      }
-      get range() {
-        if (this.formatted === void 0) {
-          this.formatted = "";
-          for (let i = 0; i < this.set.length; i++) {
-            if (i > 0) {
-              this.formatted += "||";
-            }
-            const comps = this.set[i];
-            for (let k = 0; k < comps.length; k++) {
-              if (k > 0) {
-                this.formatted += " ";
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
               }
-              this.formatted += comps[k].toString().trim();
             }
-          }
+            return id;
+          });
         }
-        return this.formatted;
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
       }
       format() {
-        return this.range;
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
       }
       toString() {
-        return this.range;
+        return this.version;
       }
-      parseRange(range) {
-        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
-        const memoKey = memoOpts + ":" + range;
-        const cached = cache2.get(memoKey);
-        if (cached) {
-          return cached;
-        }
-        const loose = this.options.loose;
-        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-        debug2("hyphen replace", range);
-        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-        debug2("comparator trim", range);
-        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-        debug2("tilde trim", range);
-        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-        debug2("caret trim", range);
-        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
-        if (loose) {
-          rangeList = rangeList.filter((comp) => {
-            debug2("loose invalid filter", comp, this.options);
-            return !!comp.match(re[t.COMPARATORLOOSE]);
-          });
-        }
-        debug2("range list", rangeList);
-        const rangeMap = /* @__PURE__ */ new Map();
-        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
-        for (const comp of comparators) {
-          if (isNullSet(comp)) {
-            return [comp];
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
           }
-          rangeMap.set(comp.value, comp);
+          other = new _SemVer(other, this.options);
         }
-        if (rangeMap.size > 1 && rangeMap.has("")) {
-          rangeMap.delete("");
+        if (other.version === this.version) {
+          return 0;
         }
-        const result = [...rangeMap.values()];
-        cache2.set(memoKey, result);
-        return result;
+        return this.compareMain(other) || this.comparePre(other);
       }
-      intersects(range, options) {
-        if (!(range instanceof _Range)) {
-          throw new TypeError("a Range is required");
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
         }
-        return this.set.some((thisComparators) => {
-          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
-            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
-              return rangeComparators.every((rangeComparator) => {
-                return thisComparator.intersects(rangeComparator, options);
-              });
-            });
-          });
-        });
-      }
-      // if ANY of the sets match ALL of its comparators, then pass
-      test(version2) {
-        if (!version2) {
-          return false;
+        if (this.major < other.major) {
+          return -1;
         }
-        if (typeof version2 === "string") {
-          try {
-            version2 = new SemVer3(version2, this.options);
-          } catch (er) {
-            return false;
-          }
+        if (this.major > other.major) {
+          return 1;
         }
-        for (let i = 0; i < this.set.length; i++) {
-          if (testSet(this.set[i], version2, this.options)) {
-            return true;
-          }
+        if (this.minor < other.minor) {
+          return -1;
         }
-        return false;
-      }
-    };
-    module2.exports = Range3;
-    var LRU = require_lrucache();
-    var cache2 = new LRU();
-    var parseOptions = require_parse_options();
-    var Comparator = require_comparator();
-    var debug2 = require_debug();
-    var SemVer3 = require_semver();
-    var {
-      safeRe: re,
-      t,
-      comparatorTrimReplace,
-      tildeTrimReplace,
-      caretTrimReplace
-    } = require_re();
-    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
-    var isNullSet = (c) => c.value === "<0.0.0-0";
-    var isAny = (c) => c.value === "";
-    var isSatisfiable = (comparators, options) => {
-      let result = true;
-      const remainingComparators = comparators.slice();
-      let testComparator = remainingComparators.pop();
-      while (result && remainingComparators.length) {
-        result = remainingComparators.every((otherComparator) => {
-          return testComparator.intersects(otherComparator, options);
-        });
-        testComparator = remainingComparators.pop();
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
       }
-      return result;
-    };
-    var parseComparator = (comp, options) => {
-      comp = comp.replace(re[t.BUILD], "");
-      debug2("comp", comp, options);
-      comp = replaceCarets(comp, options);
-      debug2("caret", comp);
-      comp = replaceTildes(comp, options);
-      debug2("tildes", comp);
-      comp = replaceXRanges(comp, options);
-      debug2("xrange", comp);
-      comp = replaceStars(comp, options);
-      debug2("stars", comp);
-      return comp;
-    };
-    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
-    var replaceTildes = (comp, options) => {
-      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
-    };
-    var replaceTilde = (comp, options) => {
-      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      return comp.replace(r, (_, M, m, p, pr) => {
-        debug2("tilde", comp, _, M, m, p, pr);
-        let ret;
-        if (isX(M)) {
-          ret = "";
-        } else if (isX(m)) {
-          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
-        } else if (isX(p)) {
-          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
-        } else if (pr) {
-          debug2("replaceTilde pr", pr);
-          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
-        } else {
-          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
         }
-        debug2("tilde return", ret);
-        return ret;
-      });
-    };
-    var replaceCarets = (comp, options) => {
-      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
-    };
-    var replaceCaret = (comp, options) => {
-      debug2("caret", comp, options);
-      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-      const z = options.includePrerelease ? "-0" : "";
-      return comp.replace(r, (_, M, m, p, pr) => {
-        debug2("caret", comp, _, M, m, p, pr);
-        let ret;
-        if (isX(M)) {
-          ret = "";
-        } else if (isX(m)) {
-          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
-        } else if (isX(p)) {
-          if (M === "0") {
-            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
           } else {
-            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+            return compareIdentifiers(a, b);
           }
-        } else if (pr) {
-          debug2("replaceCaret pr", pr);
-          if (M === "0") {
-            if (m === "0") {
-              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
-            } else {
-              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
-            }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
           } else {
-            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+            return compareIdentifiers(a, b);
           }
-        } else {
-          debug2("no pr");
-          if (M === "0") {
-            if (m === "0") {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
-            } else {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
             }
-          } else {
-            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
           }
         }
-        debug2("caret return", ret);
-        return ret;
-      });
-    };
-    var replaceXRanges = (comp, options) => {
-      debug2("replaceXRanges", comp, options);
-      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
-    };
-    var replaceXRange = (comp, options) => {
-      comp = comp.trim();
-      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-        debug2("xRange", comp, ret, gtlt, M, m, p, pr);
-        const xM = isX(M);
-        const xm = xM || isX(m);
-        const xp = xm || isX(p);
-        const anyX = xp;
-        if (gtlt === "=" && anyX) {
-          gtlt = "";
-        }
-        pr = options.includePrerelease ? "-0" : "";
-        if (xM) {
-          if (gtlt === ">" || gtlt === "<") {
-            ret = "<0.0.0-0";
-          } else {
-            ret = "*";
-          }
-        } else if (gtlt && anyX) {
-          if (xm) {
-            m = 0;
-          }
-          p = 0;
-          if (gtlt === ">") {
-            gtlt = ">=";
-            if (xm) {
-              M = +M + 1;
-              m = 0;
-              p = 0;
-            } else {
-              m = +m + 1;
-              p = 0;
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
             }
-          } else if (gtlt === "<=") {
-            gtlt = "<";
-            if (xm) {
-              M = +M + 1;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
             } else {
-              m = +m + 1;
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
             }
-          }
-          if (gtlt === "<") {
-            pr = "-0";
-          }
-          ret = `${gtlt + M}.${m}.${p}${pr}`;
-        } else if (xm) {
-          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
-        } else if (xp) {
-          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
-        }
-        debug2("xRange return", ret);
-        return ret;
-      });
-    };
-    var replaceStars = (comp, options) => {
-      debug2("replaceStars", comp, options);
-      return comp.trim().replace(re[t.STAR], "");
-    };
-    var replaceGTE0 = (comp, options) => {
-      debug2("replaceGTE0", comp, options);
-      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
-    };
-    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
-      if (isX(fM)) {
-        from = "";
-      } else if (isX(fm)) {
-        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
-      } else if (isX(fp)) {
-        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
-      } else if (fpr) {
-        from = `>=${from}`;
-      } else {
-        from = `>=${from}${incPr ? "-0" : ""}`;
-      }
-      if (isX(tM)) {
-        to = "";
-      } else if (isX(tm)) {
-        to = `<${+tM + 1}.0.0-0`;
-      } else if (isX(tp)) {
-        to = `<${tM}.${+tm + 1}.0-0`;
-      } else if (tpr) {
-        to = `<=${tM}.${tm}.${tp}-${tpr}`;
-      } else if (incPr) {
-        to = `<${tM}.${tm}.${+tp + 1}-0`;
-      } else {
-        to = `<=${to}`;
-      }
-      return `${from} ${to}`.trim();
-    };
-    var testSet = (set, version2, options) => {
-      for (let i = 0; i < set.length; i++) {
-        if (!set[i].test(version2)) {
-          return false;
-        }
-      }
-      if (version2.prerelease.length && !options.includePrerelease) {
-        for (let i = 0; i < set.length; i++) {
-          debug2(set[i].semver);
-          if (set[i].semver === Comparator.ANY) {
-            continue;
-          }
-          if (set[i].semver.prerelease.length > 0) {
-            const allowed = set[i].semver;
-            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
-              return true;
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
             }
+            break;
           }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
         }
-        return false;
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
       }
-      return true;
     };
+    module2.exports = SemVer3;
   }
 });
 
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/ranges/valid.js
-var require_valid2 = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/ranges/valid.js"(exports2, module2) {
+// node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "node_modules/semver/functions/compare.js"(exports2, module2) {
     "use strict";
-    var Range3 = require_range();
-    var validRange = (range, options) => {
-      try {
-        return new Range3(range, options).range || "*";
-      } catch (er) {
-        return null;
+    var SemVer3 = require_semver();
+    var compare = (a, b, loose) => new SemVer3(a, loose).compare(new SemVer3(b, loose));
+    module2.exports = compare;
+  }
+});
+
+// node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "node_modules/semver/functions/rcompare.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = (a, b, loose) => compare(b, a, loose);
+    module2.exports = rcompare;
+  }
+});
+
+// node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "node_modules/semver/functions/parse.js"(exports2, module2) {
+    "use strict";
+    var SemVer3 = require_semver();
+    var parse4 = (version2, options, throwErrors = false) => {
+      if (version2 instanceof SemVer3) {
+        return version2;
+      }
+      try {
+        return new SemVer3(version2, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
       }
     };
-    module2.exports = validRange;
+    module2.exports = parse4;
   }
 });
 
-// .yarn/cache/ms-npm-2.1.3-81ff3cfac1-d924b57e73.zip/node_modules/ms/index.js
-var require_ms = __commonJS({
-  ".yarn/cache/ms-npm-2.1.3-81ff3cfac1-d924b57e73.zip/node_modules/ms/index.js"(exports2, module2) {
-    var s = 1e3;
-    var m = s * 60;
-    var h = m * 60;
-    var d = h * 24;
-    var w = d * 7;
-    var y = d * 365.25;
-    module2.exports = function(val, options) {
-      options = options || {};
-      var type = typeof val;
-      if (type === "string" && val.length > 0) {
-        return parse4(val);
-      } else if (type === "number" && isFinite(val)) {
-        return options.long ? fmtLong(val) : fmtShort(val);
-      }
-      throw new Error(
-        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
-      );
+// node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "node_modules/semver/functions/valid.js"(exports2, module2) {
+    "use strict";
+    var parse4 = require_parse();
+    var valid = (version2, options) => {
+      const v = parse4(version2, options);
+      return v ? v.version : null;
     };
-    function parse4(str) {
-      str = String(str);
-      if (str.length > 100) {
-        return;
-      }
-      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-        str
-      );
-      if (!match) {
-        return;
-      }
-      var n = parseFloat(match[1]);
-      var type = (match[2] || "ms").toLowerCase();
-      switch (type) {
-        case "years":
-        case "year":
-        case "yrs":
-        case "yr":
-        case "y":
-          return n * y;
-        case "weeks":
-        case "week":
-        case "w":
-          return n * w;
-        case "days":
-        case "day":
-        case "d":
-          return n * d;
-        case "hours":
-        case "hour":
-        case "hrs":
-        case "hr":
-        case "h":
-          return n * h;
-        case "minutes":
-        case "minute":
-        case "mins":
-        case "min":
-        case "m":
-          return n * m;
-        case "seconds":
-        case "second":
-        case "secs":
-        case "sec":
-        case "s":
-          return n * s;
-        case "milliseconds":
-        case "millisecond":
-        case "msecs":
-        case "msec":
-        case "ms":
-          return n;
-        default:
-          return void 0;
-      }
-    }
-    function fmtShort(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
-        return Math.round(ms / d) + "d";
-      }
-      if (msAbs >= h) {
-        return Math.round(ms / h) + "h";
-      }
-      if (msAbs >= m) {
-        return Math.round(ms / m) + "m";
-      }
-      if (msAbs >= s) {
-        return Math.round(ms / s) + "s";
-      }
-      return ms + "ms";
-    }
-    function fmtLong(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
-        return plural2(ms, msAbs, d, "day");
-      }
-      if (msAbs >= h) {
-        return plural2(ms, msAbs, h, "hour");
-      }
-      if (msAbs >= m) {
-        return plural2(ms, msAbs, m, "minute");
-      }
-      if (msAbs >= s) {
-        return plural2(ms, msAbs, s, "second");
-      }
-      return ms + " ms";
-    }
-    function plural2(ms, msAbs, n, name2) {
-      var isPlural = msAbs >= n * 1.5;
-      return Math.round(ms / n) + " " + name2 + (isPlural ? "s" : "");
-    }
+    module2.exports = valid;
   }
 });
 
-// .yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/common.js
-var require_common = __commonJS({
-  ".yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/common.js"(exports2, module2) {
-    function setup(env2) {
-      createDebug.debug = createDebug;
-      createDebug.default = createDebug;
-      createDebug.coerce = coerce;
-      createDebug.disable = disable;
-      createDebug.enable = enable;
-      createDebug.enabled = enabled;
-      createDebug.humanize = require_ms();
-      createDebug.destroy = destroy;
-      Object.keys(env2).forEach((key) => {
-        createDebug[key] = env2[key];
-      });
-      createDebug.names = [];
-      createDebug.skips = [];
-      createDebug.formatters = {};
-      function selectColor(namespace) {
-        let hash = 0;
-        for (let i = 0; i < namespace.length; i++) {
-          hash = (hash << 5) - hash + namespace.charCodeAt(i);
-          hash |= 0;
-        }
-        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+// node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "node_modules/semver/internal/lrucache.js"(exports2, module2) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
       }
-      createDebug.selectColor = selectColor;
-      function createDebug(namespace) {
-        let prevTime;
-        let enableOverride = null;
-        let namespacesCache;
-        let enabledCache;
-        function debug2(...args) {
-          if (!debug2.enabled) {
-            return;
-          }
-          const self2 = debug2;
-          const curr = Number(/* @__PURE__ */ new Date());
-          const ms = curr - (prevTime || curr);
-          self2.diff = ms;
-          self2.prev = prevTime;
-          self2.curr = curr;
-          prevTime = curr;
-          args[0] = createDebug.coerce(args[0]);
-          if (typeof args[0] !== "string") {
-            args.unshift("%O");
-          }
-          let index = 0;
-          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-            if (match === "%%") {
-              return "%";
-            }
-            index++;
-            const formatter = createDebug.formatters[format];
-            if (typeof formatter === "function") {
-              const val = args[index];
-              match = formatter.call(self2, val);
-              args.splice(index, 1);
-              index--;
-            }
-            return match;
-          });
-          createDebug.formatArgs.call(self2, args);
-          const logFn = self2.log || createDebug.log;
-          logFn.apply(self2, args);
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
         }
-        debug2.namespace = namespace;
-        debug2.useColors = createDebug.useColors();
-        debug2.color = createDebug.selectColor(namespace);
-        debug2.extend = extend;
-        debug2.destroy = createDebug.destroy;
-        Object.defineProperty(debug2, "enabled", {
-          enumerable: true,
-          configurable: false,
-          get: () => {
-            if (enableOverride !== null) {
-              return enableOverride;
-            }
-            if (namespacesCache !== createDebug.namespaces) {
-              namespacesCache = createDebug.namespaces;
-              enabledCache = createDebug.enabled(namespace);
-            }
-            return enabledCache;
-          },
-          set: (v) => {
-            enableOverride = v;
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
           }
-        });
-        if (typeof createDebug.init === "function") {
-          createDebug.init(debug2);
+          this.map.set(key, value);
         }
-        return debug2;
-      }
-      function extend(namespace, delimiter) {
-        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
-        newDebug.log = this.log;
-        return newDebug;
+        return this;
       }
-      function enable(namespaces) {
-        createDebug.save(namespaces);
-        createDebug.namespaces = namespaces;
-        createDebug.names = [];
-        createDebug.skips = [];
-        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
-        for (const ns of split) {
-          if (ns[0] === "-") {
-            createDebug.skips.push(ns.slice(1));
-          } else {
-            createDebug.names.push(ns);
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "node_modules/semver/functions/eq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module2.exports = eq;
+  }
+});
+
+// node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "node_modules/semver/functions/neq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module2.exports = neq;
+  }
+});
+
+// node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "node_modules/semver/functions/gt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt;
+  }
+});
+
+// node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "node_modules/semver/functions/gte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  }
+});
+
+// node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "node_modules/semver/functions/lt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  }
+});
+
+// node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "node_modules/semver/functions/lte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  }
+});
+
+// node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "node_modules/semver/functions/cmp.js"(exports2, module2) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
           }
-        }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
       }
-      function matchesTemplate(search, template) {
-        let searchIndex = 0;
-        let templateIndex = 0;
-        let starIndex = -1;
-        let matchIndex = 0;
-        while (searchIndex < search.length) {
-          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
-            if (template[templateIndex] === "*") {
-              starIndex = templateIndex;
-              matchIndex = searchIndex;
-              templateIndex++;
-            } else {
-              searchIndex++;
-              templateIndex++;
-            }
-          } else if (starIndex !== -1) {
-            templateIndex = starIndex + 1;
-            matchIndex++;
-            searchIndex = matchIndex;
+    };
+    module2.exports = cmp;
+  }
+});
+
+// node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "node_modules/semver/classes/comparator.js"(exports2, module2) {
+    "use strict";
+    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
           } else {
-            return false;
+            comp = comp.value;
           }
         }
-        while (templateIndex < template.length && template[templateIndex] === "*") {
-          templateIndex++;
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
         }
-        return templateIndex === template.length;
+        debug("comp", this);
       }
-      function disable() {
-        const namespaces = [
-          ...createDebug.names,
-          ...createDebug.skips.map((namespace) => "-" + namespace)
-        ].join(",");
-        createDebug.enable("");
-        return namespaces;
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer3(m[2], this.options.loose);
+        }
       }
-      function enabled(name2) {
-        for (const skip of createDebug.skips) {
-          if (matchesTemplate(name2, skip)) {
+      toString() {
+        return this.value;
+      }
+      test(version2) {
+        debug("Comparator.test", version2, this.options.loose);
+        if (this.semver === ANY || version2 === ANY) {
+          return true;
+        }
+        if (typeof version2 === "string") {
+          try {
+            version2 = new SemVer3(version2, this.options);
+          } catch (er) {
             return false;
           }
         }
-        for (const ns of createDebug.names) {
-          if (matchesTemplate(name2, ns)) {
+        return cmp(version2, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range3(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
             return true;
           }
+          return new Range3(this.value, options).test(comp.semver);
         }
-        return false;
-      }
-      function coerce(val) {
-        if (val instanceof Error) {
-          return val.stack || val.message;
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
         }
-        return val;
-      }
-      function destroy() {
-        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
       }
-      createDebug.enable(createDebug.load());
-      return createDebug;
-    }
-    module2.exports = setup;
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer3 = require_semver();
+    var Range3 = require_range();
   }
 });
 
-// .yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/browser.js
-var require_browser = __commonJS({
-  ".yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/browser.js"(exports2, module2) {
-    exports2.formatArgs = formatArgs;
-    exports2.save = save;
-    exports2.load = load;
-    exports2.useColors = useColors;
-    exports2.storage = localstorage();
-    exports2.destroy = /* @__PURE__ */ (() => {
-      let warned = false;
-      return () => {
-        if (!warned) {
-          warned = true;
-          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+// node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "node_modules/semver/classes/range.js"(exports2, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range3 = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
         }
-      };
-    })();
-    exports2.colors = [
-      "#0000CC",
-      "#0000FF",
-      "#0033CC",
-      "#0033FF",
-      "#0066CC",
-      "#0066FF",
-      "#0099CC",
-      "#0099FF",
-      "#00CC00",
-      "#00CC33",
-      "#00CC66",
-      "#00CC99",
-      "#00CCCC",
-      "#00CCFF",
-      "#3300CC",
-      "#3300FF",
-      "#3333CC",
-      "#3333FF",
-      "#3366CC",
-      "#3366FF",
-      "#3399CC",
-      "#3399FF",
-      "#33CC00",
-      "#33CC33",
-      "#33CC66",
-      "#33CC99",
-      "#33CCCC",
-      "#33CCFF",
-      "#6600CC",
-      "#6600FF",
-      "#6633CC",
-      "#6633FF",
-      "#66CC00",
-      "#66CC33",
-      "#9900CC",
-      "#9900FF",
-      "#9933CC",
-      "#9933FF",
-      "#99CC00",
-      "#99CC33",
-      "#CC0000",
-      "#CC0033",
-      "#CC0066",
-      "#CC0099",
-      "#CC00CC",
-      "#CC00FF",
-      "#CC3300",
-      "#CC3333",
-      "#CC3366",
-      "#CC3399",
-      "#CC33CC",
-      "#CC33FF",
-      "#CC6600",
-      "#CC6633",
-      "#CC9900",
-      "#CC9933",
-      "#CCCC00",
-      "#CCCC33",
-      "#FF0000",
-      "#FF0033",
-      "#FF0066",
-      "#FF0099",
-      "#FF00CC",
-      "#FF00FF",
-      "#FF3300",
-      "#FF3333",
-      "#FF3366",
-      "#FF3399",
-      "#FF33CC",
-      "#FF33FF",
-      "#FF6600",
-      "#FF6633",
-      "#FF9900",
-      "#FF9933",
-      "#FFCC00",
-      "#FFCC33"
-    ];
-    function useColors() {
-      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
-        return true;
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
       }
-      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-        return false;
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
       }
-      let m;
-      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
-      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
-      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
-      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
-    }
-    function formatArgs(args) {
-      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
-      if (!this.useColors) {
-        return;
+      format() {
+        return this.range;
       }
-      const c = "color: " + this.color;
-      args.splice(1, 0, c, "color: inherit");
-      let index = 0;
-      let lastC = 0;
-      args[0].replace(/%[a-zA-Z%]/g, (match) => {
-        if (match === "%%") {
-          return;
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache2.get(memoKey);
+        if (cached) {
+          return cached;
         }
-        index++;
-        if (match === "%c") {
-          lastC = index;
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
         }
-      });
-      args.splice(lastC, 0, c);
-    }
-    exports2.log = console.debug || console.log || (() => {
-    });
-    function save(namespaces) {
-      try {
-        if (namespaces) {
-          exports2.storage.setItem("debug", namespaces);
-        } else {
-          exports2.storage.removeItem("debug");
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
         }
-      } catch (error) {
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache2.set(memoKey, result);
+        return result;
       }
-    }
-    function load() {
-      let r;
-      try {
-        r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
-      } catch (error) {
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
       }
-      if (!r && typeof process !== "undefined" && "env" in process) {
-        r = process.env.DEBUG;
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version2) {
+        if (!version2) {
+          return false;
+        }
+        if (typeof version2 === "string") {
+          try {
+            version2 = new SemVer3(version2, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version2, this.options)) {
+            return true;
+          }
+        }
+        return false;
       }
-      return r;
-    }
-    function localstorage() {
-      try {
-        return localStorage;
-      } catch (error) {
+    };
+    module2.exports = Range3;
+    var LRU = require_lrucache();
+    var cache2 = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer3 = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
       }
-    }
-    module2.exports = require_common()(exports2);
-    var { formatters } = module2.exports;
-    formatters.j = function(v) {
-      try {
-        return JSON.stringify(v);
-      } catch (error) {
-        return "[UnexpectedJSONParseError]: " + error.message;
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version2, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version2)) {
+          return false;
+        }
+      }
+      if (version2.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
       }
+      return true;
     };
   }
 });
 
-// .yarn/cache/supports-color-npm-10.2.2-e43ac15f9f-fb28dd7e0c.zip/node_modules/supports-color/index.js
-var supports_color_exports = {};
-__export(supports_color_exports, {
-  createSupportsColor: () => createSupportsColor,
-  default: () => supports_color_default
-});
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-function envForceColor() {
-  if (!("FORCE_COLOR" in env)) {
-    return;
-  }
-  if (env.FORCE_COLOR === "true") {
-    return 1;
-  }
-  if (env.FORCE_COLOR === "false") {
-    return 0;
-  }
-  if (env.FORCE_COLOR.length === 0) {
-    return 1;
+// node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "node_modules/semver/ranges/valid.js"(exports2, module2) {
+    "use strict";
+    var Range3 = require_range();
+    var validRange = (range, options) => {
+      try {
+        return new Range3(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = validRange;
   }
-  const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  if (![0, 1, 2, 3].includes(level)) {
-    return;
-  }
-  return level;
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== void 0) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === void 0) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (import_node_process.default.platform === "win32") {
-    const osRelease = import_node_os.default.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
-      return 3;
+});
+
+// node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/ms/index.js"(exports2, module2) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module2.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse4(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse4(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
-      return 1;
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
     }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural2(ms, msAbs, d, "day");
       }
-      case "Apple_Terminal": {
-        return 2;
+      if (msAbs >= h) {
+        return plural2(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural2(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural2(ms, msAbs, s, "second");
       }
+      return ms + " ms";
     }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
-var init_supports_color = __esm({
-  ".yarn/cache/supports-color-npm-10.2.2-e43ac15f9f-fb28dd7e0c.zip/node_modules/supports-color/index.js"() {
-    import_node_process = __toESM(require("node:process"), 1);
-    import_node_os = __toESM(require("node:os"), 1);
-    import_node_tty = __toESM(require("node:tty"), 1);
-    ({ env } = import_node_process.default);
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      flagForceColor = 0;
-    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      flagForceColor = 1;
+    function plural2(ms, msAbs, n, name2) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name2 + (isPlural ? "s" : "");
     }
-    supportsColor = {
-      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
-      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
-    };
-    supports_color_default = supportsColor;
   }
 });
 
-// .yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/node.js
-var require_node2 = __commonJS({
-  ".yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/node.js"(exports2, module2) {
-    var tty2 = require("tty");
-    var util = require("util");
-    exports2.init = init;
-    exports2.log = log2;
-    exports2.formatArgs = formatArgs;
-    exports2.save = save;
-    exports2.load = load;
-    exports2.useColors = useColors;
-    exports2.destroy = util.deprecate(
-      () => {
-      },
-      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
-    );
-    exports2.colors = [6, 2, 3, 4, 5, 1];
-    try {
-      const supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
-      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
-        exports2.colors = [
-          20,
-          21,
-          26,
-          27,
-          32,
-          33,
-          38,
-          39,
-          40,
-          41,
-          42,
-          43,
-          44,
-          45,
-          56,
-          57,
-          62,
-          63,
-          68,
-          69,
-          74,
-          75,
-          76,
-          77,
-          78,
-          79,
-          80,
-          81,
-          92,
-          93,
-          98,
-          99,
-          112,
-          113,
-          128,
-          129,
-          134,
-          135,
-          148,
-          149,
-          160,
-          161,
-          162,
-          163,
-          164,
-          165,
-          166,
-          167,
-          168,
-          169,
-          170,
-          171,
-          172,
-          173,
-          178,
-          179,
-          184,
-          185,
-          196,
-          197,
-          198,
-          199,
-          200,
-          201,
-          202,
-          203,
-          204,
-          205,
-          206,
-          207,
-          208,
-          209,
-          214,
-          215,
-          220,
-          221
-        ];
-      }
-    } catch (error) {
-    }
-    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
-      return /^debug_/i.test(key);
-    }).reduce((obj, key) => {
-      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
-        return k.toUpperCase();
+// node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "node_modules/debug/src/common.js"(exports2, module2) {
+    function setup(env2) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env2).forEach((key) => {
+        createDebug[key] = env2[key];
       });
-      let val = process.env[key];
-      if (/^(yes|on|true|enabled)$/i.test(val)) {
-        val = true;
-      } else if (/^(no|off|false|disabled)$/i.test(val)) {
-        val = false;
-      } else if (val === "null") {
-        val = null;
-      } else {
-        val = Number(val);
-      }
-      obj[prop] = val;
-      return obj;
-    }, {});
-    function useColors() {
-      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty2.isatty(process.stderr.fd);
-    }
-    function formatArgs(args) {
-      const { namespace: name2, useColors: useColors2 } = this;
-      if (useColors2) {
-        const c = this.color;
-        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
-        const prefix = `  ${colorCode};1m${name2} \x1B[0m`;
-        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
-        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
-      } else {
-        args[0] = getDate() + name2 + " " + args[0];
-      }
-    }
-    function getDate() {
-      if (exports2.inspectOpts.hideDate) {
-        return "";
-      }
-      return (/* @__PURE__ */ new Date()).toISOString() + " ";
-    }
-    function log2(...args) {
-      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
-    }
-    function save(namespaces) {
-      if (namespaces) {
-        process.env.DEBUG = namespaces;
-      } else {
-        delete process.env.DEBUG;
-      }
-    }
-    function load() {
-      return process.env.DEBUG;
-    }
-    function init(debug2) {
-      debug2.inspectOpts = {};
-      const keys = Object.keys(exports2.inspectOpts);
-      for (let i = 0; i < keys.length; i++) {
-        debug2.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
-      }
-    }
-    module2.exports = require_common()(exports2);
-    var { formatters } = module2.exports;
-    formatters.o = function(v) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
-    };
-    formatters.O = function(v) {
-      this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts);
-    };
-  }
-});
-
-// .yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/index.js
-var require_src = __commonJS({
-  ".yarn/__virtual__/debug-virtual-436baa457e/0/cache/debug-npm-4.4.3-0105c6123a-d79136ec6c.zip/node_modules/debug/src/index.js"(exports2, module2) {
-    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
-      module2.exports = require_browser();
-    } else {
-      module2.exports = require_node2();
-    }
-  }
-});
-
-// .yarn/cache/proxy-from-env-npm-1.1.0-c13d07f26b-fe7dd8b1bd.zip/node_modules/proxy-from-env/index.js
-var require_proxy_from_env = __commonJS({
-  ".yarn/cache/proxy-from-env-npm-1.1.0-c13d07f26b-fe7dd8b1bd.zip/node_modules/proxy-from-env/index.js"(exports2) {
-    "use strict";
-    var parseUrl = require("url").parse;
-    var DEFAULT_PORTS = {
-      ftp: 21,
-      gopher: 70,
-      http: 80,
-      https: 443,
-      ws: 80,
-      wss: 443
-    };
-    var stringEndsWith = String.prototype.endsWith || function(s) {
-      return s.length <= this.length && this.indexOf(s, this.length - s.length) !== -1;
-    };
-    function getProxyForUrl(url) {
-      var parsedUrl = typeof url === "string" ? parseUrl(url) : url || {};
-      var proto = parsedUrl.protocol;
-      var hostname = parsedUrl.host;
-      var port = parsedUrl.port;
-      if (typeof hostname !== "string" || !hostname || typeof proto !== "string") {
-        return "";
-      }
-      proto = proto.split(":", 1)[0];
-      hostname = hostname.replace(/:\d*$/, "");
-      port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
-      if (!shouldProxy(hostname, port)) {
-        return "";
-      }
-      var proxy = getEnv("npm_config_" + proto + "_proxy") || getEnv(proto + "_proxy") || getEnv("npm_config_proxy") || getEnv("all_proxy");
-      if (proxy && proxy.indexOf("://") === -1) {
-        proxy = proto + "://" + proxy;
-      }
-      return proxy;
-    }
-    function shouldProxy(hostname, port) {
-      var NO_PROXY = (getEnv("npm_config_no_proxy") || getEnv("no_proxy")).toLowerCase();
-      if (!NO_PROXY) {
-        return true;
-      }
-      if (NO_PROXY === "*") {
-        return false;
-      }
-      return NO_PROXY.split(/[,\s]/).every(function(proxy) {
-        if (!proxy) {
-          return true;
-        }
-        var parsedProxy = proxy.match(/^(.+):(\d+)$/);
-        var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
-        var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
-        if (parsedProxyPort && parsedProxyPort !== port) {
-          return true;
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
         }
-        if (!/^[.*]/.test(parsedProxyHostname)) {
-          return hostname !== parsedProxyHostname;
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self2 = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self2, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug.log;
+          logFn.apply(self2, args);
         }
-        if (parsedProxyHostname.charAt(0) === "*") {
-          parsedProxyHostname = parsedProxyHostname.slice(1);
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
         }
-        return !stringEndsWith.call(hostname, parsedProxyHostname);
-      });
-    }
-    function getEnv(key) {
-      return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
-    }
-    exports2.getProxyForUrl = getProxyForUrl;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/errors.js
-var require_errors = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/errors.js"(exports2, module2) {
-    "use strict";
-    var kUndiciError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR");
-    var UndiciError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "UndiciError";
-        this.code = "UND_ERR";
+        return debug;
       }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kUndiciError] === true;
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
       }
-      [kUndiciError] = true;
-    };
-    var kConnectTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT");
-    var ConnectTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ConnectTimeoutError";
-        this.message = message || "Connect Timeout Error";
-        this.code = "UND_ERR_CONNECT_TIMEOUT";
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
       }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kConnectTimeoutError] === true;
-      }
-      [kConnectTimeoutError] = true;
-    };
-    var kHeadersTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT");
-    var HeadersTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "HeadersTimeoutError";
-        this.message = message || "Headers Timeout Error";
-        this.code = "UND_ERR_HEADERS_TIMEOUT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHeadersTimeoutError] === true;
-      }
-      [kHeadersTimeoutError] = true;
-    };
-    var kHeadersOverflowError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW");
-    var HeadersOverflowError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "HeadersOverflowError";
-        this.message = message || "Headers Overflow Error";
-        this.code = "UND_ERR_HEADERS_OVERFLOW";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHeadersOverflowError] === true;
-      }
-      [kHeadersOverflowError] = true;
-    };
-    var kBodyTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT");
-    var BodyTimeoutError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "BodyTimeoutError";
-        this.message = message || "Body Timeout Error";
-        this.code = "UND_ERR_BODY_TIMEOUT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kBodyTimeoutError] === true;
-      }
-      [kBodyTimeoutError] = true;
-    };
-    var kResponseStatusCodeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE");
-    var ResponseStatusCodeError = class extends UndiciError {
-      constructor(message, statusCode, headers, body) {
-        super(message);
-        this.name = "ResponseStatusCodeError";
-        this.message = message || "Response Status Code Error";
-        this.code = "UND_ERR_RESPONSE_STATUS_CODE";
-        this.body = body;
-        this.status = statusCode;
-        this.statusCode = statusCode;
-        this.headers = headers;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseStatusCodeError] === true;
-      }
-      [kResponseStatusCodeError] = true;
-    };
-    var kInvalidArgumentError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_ARG");
-    var InvalidArgumentError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InvalidArgumentError";
-        this.message = message || "Invalid Argument Error";
-        this.code = "UND_ERR_INVALID_ARG";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInvalidArgumentError] === true;
-      }
-      [kInvalidArgumentError] = true;
-    };
-    var kInvalidReturnValueError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE");
-    var InvalidReturnValueError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InvalidReturnValueError";
-        this.message = message || "Invalid Return Value Error";
-        this.code = "UND_ERR_INVALID_RETURN_VALUE";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInvalidReturnValueError] === true;
-      }
-      [kInvalidReturnValueError] = true;
-    };
-    var kAbortError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORT");
-    var AbortError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "AbortError";
-        this.message = message || "The operation was aborted";
-        this.code = "UND_ERR_ABORT";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kAbortError] === true;
-      }
-      [kAbortError] = true;
-    };
-    var kRequestAbortedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORTED");
-    var RequestAbortedError = class extends AbortError {
-      constructor(message) {
-        super(message);
-        this.name = "AbortError";
-        this.message = message || "Request aborted";
-        this.code = "UND_ERR_ABORTED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestAbortedError] === true;
-      }
-      [kRequestAbortedError] = true;
-    };
-    var kInformationalError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INFO");
-    var InformationalError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "InformationalError";
-        this.message = message || "Request information";
-        this.code = "UND_ERR_INFO";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kInformationalError] === true;
-      }
-      [kInformationalError] = true;
-    };
-    var kRequestContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH");
-    var RequestContentLengthMismatchError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "RequestContentLengthMismatchError";
-        this.message = message || "Request body length does not match content-length header";
-        this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestContentLengthMismatchError] === true;
-      }
-      [kRequestContentLengthMismatchError] = true;
-    };
-    var kResponseContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH");
-    var ResponseContentLengthMismatchError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ResponseContentLengthMismatchError";
-        this.message = message || "Response body length does not match content-length header";
-        this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseContentLengthMismatchError] === true;
-      }
-      [kResponseContentLengthMismatchError] = true;
-    };
-    var kClientDestroyedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_DESTROYED");
-    var ClientDestroyedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ClientDestroyedError";
-        this.message = message || "The client is destroyed";
-        this.code = "UND_ERR_DESTROYED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kClientDestroyedError] === true;
-      }
-      [kClientDestroyedError] = true;
-    };
-    var kClientClosedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CLOSED");
-    var ClientClosedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ClientClosedError";
-        this.message = message || "The client is closed";
-        this.code = "UND_ERR_CLOSED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kClientClosedError] === true;
-      }
-      [kClientClosedError] = true;
-    };
-    var kSocketError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_SOCKET");
-    var SocketError = class extends UndiciError {
-      constructor(message, socket) {
-        super(message);
-        this.name = "SocketError";
-        this.message = message || "Socket error";
-        this.code = "UND_ERR_SOCKET";
-        this.socket = socket;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kSocketError] === true;
-      }
-      [kSocketError] = true;
-    };
-    var kNotSupportedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED");
-    var NotSupportedError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "NotSupportedError";
-        this.message = message || "Not supported error";
-        this.code = "UND_ERR_NOT_SUPPORTED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kNotSupportedError] === true;
-      }
-      [kNotSupportedError] = true;
-    };
-    var kBalancedPoolMissingUpstreamError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM");
-    var BalancedPoolMissingUpstreamError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "MissingUpstreamError";
-        this.message = message || "No upstream has been added to the BalancedPool";
-        this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kBalancedPoolMissingUpstreamError] === true;
-      }
-      [kBalancedPoolMissingUpstreamError] = true;
-    };
-    var kHTTPParserError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HTTP_PARSER");
-    var HTTPParserError = class extends Error {
-      constructor(message, code2, data) {
-        super(message);
-        this.name = "HTTPParserError";
-        this.code = code2 ? `HPE_${code2}` : void 0;
-        this.data = data ? data.toString() : void 0;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kHTTPParserError] === true;
-      }
-      [kHTTPParserError] = true;
-    };
-    var kResponseExceededMaxSizeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE");
-    var ResponseExceededMaxSizeError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "ResponseExceededMaxSizeError";
-        this.message = message || "Response content exceeded max size";
-        this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseExceededMaxSizeError] === true;
-      }
-      [kResponseExceededMaxSizeError] = true;
-    };
-    var kRequestRetryError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_RETRY");
-    var RequestRetryError = class extends UndiciError {
-      constructor(message, code2, { headers, data }) {
-        super(message);
-        this.name = "RequestRetryError";
-        this.message = message || "Request retry error";
-        this.code = "UND_ERR_REQ_RETRY";
-        this.statusCode = code2;
-        this.data = data;
-        this.headers = headers;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kRequestRetryError] === true;
-      }
-      [kRequestRetryError] = true;
-    };
-    var kResponseError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE");
-    var ResponseError = class extends UndiciError {
-      constructor(message, code2, { headers, data }) {
-        super(message);
-        this.name = "ResponseError";
-        this.message = message || "Response error";
-        this.code = "UND_ERR_RESPONSE";
-        this.statusCode = code2;
-        this.data = data;
-        this.headers = headers;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kResponseError] === true;
-      }
-      [kResponseError] = true;
-    };
-    var kSecureProxyConnectionError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_PRX_TLS");
-    var SecureProxyConnectionError = class extends UndiciError {
-      constructor(cause, message, options) {
-        super(message, { cause, ...options ?? {} });
-        this.name = "SecureProxyConnectionError";
-        this.message = message || "Secure Proxy Connection failed";
-        this.code = "UND_ERR_PRX_TLS";
-        this.cause = cause;
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kSecureProxyConnectionError] === true;
-      }
-      [kSecureProxyConnectionError] = true;
-    };
-    var kMessageSizeExceededError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED");
-    var MessageSizeExceededError = class extends UndiciError {
-      constructor(message) {
-        super(message);
-        this.name = "MessageSizeExceededError";
-        this.message = message || "Max decompressed message size exceeded";
-        this.code = "UND_ERR_WS_MESSAGE_SIZE_EXCEEDED";
-      }
-      static [Symbol.hasInstance](instance) {
-        return instance && instance[kMessageSizeExceededError] === true;
-      }
-      get [kMessageSizeExceededError]() {
-        return true;
-      }
-    };
-    module2.exports = {
-      AbortError,
-      HTTPParserError,
-      UndiciError,
-      HeadersTimeoutError,
-      HeadersOverflowError,
-      BodyTimeoutError,
-      RequestContentLengthMismatchError,
-      ConnectTimeoutError,
-      ResponseStatusCodeError,
-      InvalidArgumentError,
-      InvalidReturnValueError,
-      RequestAbortedError,
-      ClientDestroyedError,
-      ClientClosedError,
-      InformationalError,
-      SocketError,
-      NotSupportedError,
-      ResponseContentLengthMismatchError,
-      BalancedPoolMissingUpstreamError,
-      ResponseExceededMaxSizeError,
-      RequestRetryError,
-      ResponseError,
-      SecureProxyConnectionError,
-      MessageSizeExceededError
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/symbols.js
-var require_symbols = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/symbols.js"(exports2, module2) {
-    module2.exports = {
-      kClose: /* @__PURE__ */ Symbol("close"),
-      kDestroy: /* @__PURE__ */ Symbol("destroy"),
-      kDispatch: /* @__PURE__ */ Symbol("dispatch"),
-      kUrl: /* @__PURE__ */ Symbol("url"),
-      kWriting: /* @__PURE__ */ Symbol("writing"),
-      kResuming: /* @__PURE__ */ Symbol("resuming"),
-      kQueue: /* @__PURE__ */ Symbol("queue"),
-      kConnect: /* @__PURE__ */ Symbol("connect"),
-      kConnecting: /* @__PURE__ */ Symbol("connecting"),
-      kKeepAliveDefaultTimeout: /* @__PURE__ */ Symbol("default keep alive timeout"),
-      kKeepAliveMaxTimeout: /* @__PURE__ */ Symbol("max keep alive timeout"),
-      kKeepAliveTimeoutThreshold: /* @__PURE__ */ Symbol("keep alive timeout threshold"),
-      kKeepAliveTimeoutValue: /* @__PURE__ */ Symbol("keep alive timeout"),
-      kKeepAlive: /* @__PURE__ */ Symbol("keep alive"),
-      kHeadersTimeout: /* @__PURE__ */ Symbol("headers timeout"),
-      kBodyTimeout: /* @__PURE__ */ Symbol("body timeout"),
-      kServerName: /* @__PURE__ */ Symbol("server name"),
-      kLocalAddress: /* @__PURE__ */ Symbol("local address"),
-      kHost: /* @__PURE__ */ Symbol("host"),
-      kNoRef: /* @__PURE__ */ Symbol("no ref"),
-      kBodyUsed: /* @__PURE__ */ Symbol("used"),
-      kBody: /* @__PURE__ */ Symbol("abstracted request body"),
-      kRunning: /* @__PURE__ */ Symbol("running"),
-      kBlocking: /* @__PURE__ */ Symbol("blocking"),
-      kPending: /* @__PURE__ */ Symbol("pending"),
-      kSize: /* @__PURE__ */ Symbol("size"),
-      kBusy: /* @__PURE__ */ Symbol("busy"),
-      kQueued: /* @__PURE__ */ Symbol("queued"),
-      kFree: /* @__PURE__ */ Symbol("free"),
-      kConnected: /* @__PURE__ */ Symbol("connected"),
-      kClosed: /* @__PURE__ */ Symbol("closed"),
-      kNeedDrain: /* @__PURE__ */ Symbol("need drain"),
-      kReset: /* @__PURE__ */ Symbol("reset"),
-      kDestroyed: /* @__PURE__ */ Symbol.for("nodejs.stream.destroyed"),
-      kResume: /* @__PURE__ */ Symbol("resume"),
-      kOnError: /* @__PURE__ */ Symbol("on error"),
-      kMaxHeadersSize: /* @__PURE__ */ Symbol("max headers size"),
-      kRunningIdx: /* @__PURE__ */ Symbol("running index"),
-      kPendingIdx: /* @__PURE__ */ Symbol("pending index"),
-      kError: /* @__PURE__ */ Symbol("error"),
-      kClients: /* @__PURE__ */ Symbol("clients"),
-      kClient: /* @__PURE__ */ Symbol("client"),
-      kParser: /* @__PURE__ */ Symbol("parser"),
-      kOnDestroyed: /* @__PURE__ */ Symbol("destroy callbacks"),
-      kPipelining: /* @__PURE__ */ Symbol("pipelining"),
-      kSocket: /* @__PURE__ */ Symbol("socket"),
-      kHostHeader: /* @__PURE__ */ Symbol("host header"),
-      kConnector: /* @__PURE__ */ Symbol("connector"),
-      kStrictContentLength: /* @__PURE__ */ Symbol("strict content length"),
-      kMaxRedirections: /* @__PURE__ */ Symbol("maxRedirections"),
-      kMaxRequests: /* @__PURE__ */ Symbol("maxRequestsPerClient"),
-      kProxy: /* @__PURE__ */ Symbol("proxy agent options"),
-      kCounter: /* @__PURE__ */ Symbol("socket request counter"),
-      kInterceptors: /* @__PURE__ */ Symbol("dispatch interceptors"),
-      kMaxResponseSize: /* @__PURE__ */ Symbol("max response size"),
-      kHTTP2Session: /* @__PURE__ */ Symbol("http2Session"),
-      kHTTP2SessionState: /* @__PURE__ */ Symbol("http2Session state"),
-      kRetryHandlerDefaultRetry: /* @__PURE__ */ Symbol("retry agent default retry"),
-      kConstruct: /* @__PURE__ */ Symbol("constructable"),
-      kListeners: /* @__PURE__ */ Symbol("listeners"),
-      kHTTPContext: /* @__PURE__ */ Symbol("http context"),
-      kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"),
-      kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"),
-      kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"),
-      kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent")
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/constants.js
-var require_constants2 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/constants.js"(exports2, module2) {
-    "use strict";
-    var headerNameLowerCasedRecord = {};
-    var wellknownHeaderNames = [
-      "Accept",
-      "Accept-Encoding",
-      "Accept-Language",
-      "Accept-Ranges",
-      "Access-Control-Allow-Credentials",
-      "Access-Control-Allow-Headers",
-      "Access-Control-Allow-Methods",
-      "Access-Control-Allow-Origin",
-      "Access-Control-Expose-Headers",
-      "Access-Control-Max-Age",
-      "Access-Control-Request-Headers",
-      "Access-Control-Request-Method",
-      "Age",
-      "Allow",
-      "Alt-Svc",
-      "Alt-Used",
-      "Authorization",
-      "Cache-Control",
-      "Clear-Site-Data",
-      "Connection",
-      "Content-Disposition",
-      "Content-Encoding",
-      "Content-Language",
-      "Content-Length",
-      "Content-Location",
-      "Content-Range",
-      "Content-Security-Policy",
-      "Content-Security-Policy-Report-Only",
-      "Content-Type",
-      "Cookie",
-      "Cross-Origin-Embedder-Policy",
-      "Cross-Origin-Opener-Policy",
-      "Cross-Origin-Resource-Policy",
-      "Date",
-      "Device-Memory",
-      "Downlink",
-      "ECT",
-      "ETag",
-      "Expect",
-      "Expect-CT",
-      "Expires",
-      "Forwarded",
-      "From",
-      "Host",
-      "If-Match",
-      "If-Modified-Since",
-      "If-None-Match",
-      "If-Range",
-      "If-Unmodified-Since",
-      "Keep-Alive",
-      "Last-Modified",
-      "Link",
-      "Location",
-      "Max-Forwards",
-      "Origin",
-      "Permissions-Policy",
-      "Pragma",
-      "Proxy-Authenticate",
-      "Proxy-Authorization",
-      "RTT",
-      "Range",
-      "Referer",
-      "Referrer-Policy",
-      "Refresh",
-      "Retry-After",
-      "Sec-WebSocket-Accept",
-      "Sec-WebSocket-Extensions",
-      "Sec-WebSocket-Key",
-      "Sec-WebSocket-Protocol",
-      "Sec-WebSocket-Version",
-      "Server",
-      "Server-Timing",
-      "Service-Worker-Allowed",
-      "Service-Worker-Navigation-Preload",
-      "Set-Cookie",
-      "SourceMap",
-      "Strict-Transport-Security",
-      "Supports-Loading-Mode",
-      "TE",
-      "Timing-Allow-Origin",
-      "Trailer",
-      "Transfer-Encoding",
-      "Upgrade",
-      "Upgrade-Insecure-Requests",
-      "User-Agent",
-      "Vary",
-      "Via",
-      "WWW-Authenticate",
-      "X-Content-Type-Options",
-      "X-DNS-Prefetch-Control",
-      "X-Frame-Options",
-      "X-Permitted-Cross-Domain-Policies",
-      "X-Powered-By",
-      "X-Requested-With",
-      "X-XSS-Protection"
-    ];
-    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-      const key = wellknownHeaderNames[i];
-      const lowerCasedKey = key.toLowerCase();
-      headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey;
-    }
-    Object.setPrototypeOf(headerNameLowerCasedRecord, null);
-    module2.exports = {
-      wellknownHeaderNames,
-      headerNameLowerCasedRecord
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/tree.js
-var require_tree = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/tree.js"(exports2, module2) {
-    "use strict";
-    var {
-      wellknownHeaderNames,
-      headerNameLowerCasedRecord
-    } = require_constants2();
-    var TstNode = class _TstNode {
-      /** @type {any} */
-      value = null;
-      /** @type {null | TstNode} */
-      left = null;
-      /** @type {null | TstNode} */
-      middle = null;
-      /** @type {null | TstNode} */
-      right = null;
-      /** @type {number} */
-      code;
-      /**
-       * @param {string} key
-       * @param {any} value
-       * @param {number} index
-       */
-      constructor(key, value, index) {
-        if (index === void 0 || index >= key.length) {
-          throw new TypeError("Unreachable");
-        }
-        const code2 = this.code = key.charCodeAt(index);
-        if (code2 > 127) {
-          throw new TypeError("key must be ascii string");
-        }
-        if (key.length !== ++index) {
-          this.middle = new _TstNode(key, value, index);
-        } else {
-          this.value = value;
-        }
-      }
-      /**
-       * @param {string} key
-       * @param {any} value
-       */
-      add(key, value) {
-        const length = key.length;
-        if (length === 0) {
-          throw new TypeError("Unreachable");
-        }
-        let index = 0;
-        let node = this;
-        while (true) {
-          const code2 = key.charCodeAt(index);
-          if (code2 > 127) {
-            throw new TypeError("key must be ascii string");
-          }
-          if (node.code === code2) {
-            if (length === ++index) {
-              node.value = value;
-              break;
-            } else if (node.middle !== null) {
-              node = node.middle;
-            } else {
-              node.middle = new _TstNode(key, value, index);
-              break;
-            }
-          } else if (node.code < code2) {
-            if (node.left !== null) {
-              node = node.left;
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
             } else {
-              node.left = new _TstNode(key, value, index);
-              break;
+              searchIndex++;
+              templateIndex++;
             }
-          } else if (node.right !== null) {
-            node = node.right;
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
           } else {
-            node.right = new _TstNode(key, value, index);
-            break;
+            return false;
           }
         }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
       }
-      /**
-       * @param {Uint8Array} key
-       * @return {TstNode | null}
-       */
-      search(key) {
-        const keylength = key.length;
-        let index = 0;
-        let node = this;
-        while (node !== null && index < keylength) {
-          let code2 = key[index];
-          if (code2 <= 90 && code2 >= 65) {
-            code2 |= 32;
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name2) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name2, skip)) {
+            return false;
           }
-          while (node !== null) {
-            if (code2 === node.code) {
-              if (keylength === ++index) {
-                return node;
-              }
-              node = node.middle;
-              break;
-            }
-            node = node.code < code2 ? node.left : node.right;
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name2, ns)) {
+            return true;
           }
         }
-        return null;
+        return false;
       }
-    };
-    var TernarySearchTree = class {
-      /** @type {TstNode | null} */
-      node = null;
-      /**
-       * @param {string} key
-       * @param {any} value
-       * */
-      insert(key, value) {
-        if (this.node === null) {
-          this.node = new TstNode(key, value, 0);
-        } else {
-          this.node.add(key, value);
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
         }
+        return val;
       }
-      /**
-       * @param {Uint8Array} key
-       * @return {any}
-       */
-      lookup(key) {
-        return this.node?.search(key)?.value ?? null;
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
       }
-    };
-    var tree = new TernarySearchTree();
-    for (let i = 0; i < wellknownHeaderNames.length; ++i) {
-      const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]];
-      tree.insert(key, key);
+      createDebug.enable(createDebug.load());
+      return createDebug;
     }
-    module2.exports = {
-      TernarySearchTree,
-      tree
-    };
+    module2.exports = setup;
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/util.js
-var require_util = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/util.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols();
-    var { IncomingMessage } = require("node:http");
-    var stream = require("node:stream");
-    var net = require("node:net");
-    var { Blob: Blob2 } = require("node:buffer");
-    var nodeUtil = require("node:util");
-    var { stringify } = require("node:querystring");
-    var { EventEmitter: EE3 } = require("node:events");
-    var { InvalidArgumentError } = require_errors();
-    var { headerNameLowerCasedRecord } = require_constants2();
-    var { tree } = require_tree();
-    var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
-    var BodyAsyncIterable = class {
-      constructor(body) {
-        this[kBody] = body;
-        this[kBodyUsed] = false;
-      }
-      async *[Symbol.asyncIterator]() {
-        assert5(!this[kBodyUsed], "disturbed");
-        this[kBodyUsed] = true;
-        yield* this[kBody];
-      }
-    };
-    function wrapRequestBody(body) {
-      if (isStream2(body)) {
-        if (bodyLength(body) === 0) {
-          body.on("data", function() {
-            assert5(false);
-          });
-        }
-        if (typeof body.readableDidRead !== "boolean") {
-          body[kBodyUsed] = false;
-          EE3.prototype.on.call(body, "data", function() {
-            this[kBodyUsed] = true;
-          });
-        }
-        return body;
-      } else if (body && typeof body.pipeTo === "function") {
-        return new BodyAsyncIterable(body);
-      } else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) {
-        return new BodyAsyncIterable(body);
-      } else {
-        return body;
-      }
-    }
-    function nop() {
-    }
-    function isStream2(obj) {
-      return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
-    }
-    function isBlobLike(object) {
-      if (object === null) {
-        return false;
-      } else if (object instanceof Blob2) {
-        return true;
-      } else if (typeof object !== "object") {
-        return false;
-      } else {
-        const sTag = object[Symbol.toStringTag];
-        return (sTag === "Blob" || sTag === "File") && ("stream" in object && typeof object.stream === "function" || "arrayBuffer" in object && typeof object.arrayBuffer === "function");
-      }
-    }
-    function buildURL(url, queryParams) {
-      if (url.includes("?") || url.includes("#")) {
-        throw new Error('Query params cannot be passed when url already contains "?" or "#".');
-      }
-      const stringified = stringify(queryParams);
-      if (stringified) {
-        url += "?" + stringified;
-      }
-      return url;
-    }
-    function isValidPort(port) {
-      const value = parseInt(port, 10);
-      return value === Number(port) && value >= 0 && value <= 65535;
-    }
-    function isHttpOrHttpsPrefixed(value) {
-      return value != null && value[0] === "h" && value[1] === "t" && value[2] === "t" && value[3] === "p" && (value[4] === ":" || value[4] === "s" && value[5] === ":");
-    }
-    function parseURL(url) {
-      if (typeof url === "string") {
-        url = new URL(url);
-        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-        }
-        return url;
-      }
-      if (!url || typeof url !== "object") {
-        throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
-      }
-      if (!(url instanceof URL)) {
-        if (url.port != null && url.port !== "" && isValidPort(url.port) === false) {
-          throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
-        }
-        if (url.path != null && typeof url.path !== "string") {
-          throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
-        }
-        if (url.pathname != null && typeof url.pathname !== "string") {
-          throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
-        }
-        if (url.hostname != null && typeof url.hostname !== "string") {
-          throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
-        }
-        if (url.origin != null && typeof url.origin !== "string") {
-          throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
-        }
-        if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-        }
-        const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
-        let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path16 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
-        if (origin[origin.length - 1] === "/") {
-          origin = origin.slice(0, origin.length - 1);
-        }
-        if (path16 && path16[0] !== "/") {
-          path16 = `/${path16}`;
+// node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/debug/src/browser.js"(exports2, module2) {
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.storage = localstorage();
+    exports2.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
         }
-        return new URL(`${origin}${path16}`);
-      }
-      if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
-        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
-      }
-      return url;
-    }
-    function parseOrigin(url) {
-      url = parseURL(url);
-      if (url.pathname !== "/" || url.search || url.hash) {
-        throw new InvalidArgumentError("invalid url");
-      }
-      return url;
-    }
-    function getHostname(host) {
-      if (host[0] === "[") {
-        const idx2 = host.indexOf("]");
-        assert5(idx2 !== -1);
-        return host.substring(1, idx2);
-      }
-      const idx = host.indexOf(":");
-      if (idx === -1) return host;
-      return host.substring(0, idx);
-    }
-    function getServerName(host) {
-      if (!host) {
-        return null;
-      }
-      assert5(typeof host === "string");
-      const servername = getHostname(host);
-      if (net.isIP(servername)) {
-        return "";
+      };
+    })();
+    exports2.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
       }
-      return servername;
-    }
-    function deepClone(obj) {
-      return JSON.parse(JSON.stringify(obj));
-    }
-    function isAsyncIterable(obj) {
-      return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
-    }
-    function isIterable(obj) {
-      return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
-    }
-    function bodyLength(body) {
-      if (body == null) {
-        return 0;
-      } else if (isStream2(body)) {
-        const state = body._readableState;
-        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
-      } else if (isBlobLike(body)) {
-        return body.size != null ? body.size : null;
-      } else if (isBuffer(body)) {
-        return body.byteLength;
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
       }
-      return null;
-    }
-    function isDestroyed(body) {
-      return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body));
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
     }
-    function destroy(stream2, err) {
-      if (stream2 == null || !isStream2(stream2) || isDestroyed(stream2)) {
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
+      if (!this.useColors) {
         return;
       }
-      if (typeof stream2.destroy === "function") {
-        if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) {
-          stream2.socket = null;
-        }
-        stream2.destroy(err);
-      } else if (err) {
-        queueMicrotask(() => {
-          stream2.emit("error", err);
-        });
-      }
-      if (stream2.destroyed !== true) {
-        stream2[kDestroyed] = true;
-      }
-    }
-    var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
-    function parseKeepAliveTimeout(val) {
-      const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
-      return m ? parseInt(m[1], 10) * 1e3 : null;
-    }
-    function headerNameToString(value) {
-      return typeof value === "string" ? headerNameLowerCasedRecord[value] ?? value.toLowerCase() : tree.lookup(value) ?? value.toString("latin1").toLowerCase();
-    }
-    function bufferToLowerCasedHeaderName(value) {
-      return tree.lookup(value) ?? value.toString("latin1").toLowerCase();
-    }
-    function parseHeaders(headers, obj) {
-      if (obj === void 0) obj = {};
-      for (let i = 0; i < headers.length; i += 2) {
-        const key = headerNameToString(headers[i]);
-        let val = obj[key];
-        if (val) {
-          if (typeof val === "string") {
-            val = [val];
-            obj[key] = val;
-          }
-          val.push(headers[i + 1].toString("utf8"));
-        } else {
-          const headersValue = headers[i + 1];
-          if (typeof headersValue === "string") {
-            obj[key] = headersValue;
-          } else {
-            obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
-          }
-        }
-      }
-      if ("content-length" in obj && "content-disposition" in obj) {
-        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
-      }
-      return obj;
-    }
-    function parseRawHeaders(headers) {
-      const len = headers.length;
-      const ret = new Array(len);
-      let hasContentLength = false;
-      let contentDispositionIdx = -1;
-      let key;
-      let val;
-      let kLen = 0;
-      for (let n = 0; n < headers.length; n += 2) {
-        key = headers[n];
-        val = headers[n + 1];
-        typeof key !== "string" && (key = key.toString());
-        typeof val !== "string" && (val = val.toString("utf8"));
-        kLen = key.length;
-        if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) {
-          hasContentLength = true;
-        } else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
-          contentDispositionIdx = n + 1;
-        }
-        ret[n] = key;
-        ret[n + 1] = val;
-      }
-      if (hasContentLength && contentDispositionIdx !== -1) {
-        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
-      }
-      return ret;
-    }
-    function isBuffer(buffer) {
-      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
-    }
-    function validateHandler(handler, method, upgrade) {
-      if (!handler || typeof handler !== "object") {
-        throw new InvalidArgumentError("handler must be an object");
-      }
-      if (typeof handler.onConnect !== "function") {
-        throw new InvalidArgumentError("invalid onConnect method");
-      }
-      if (typeof handler.onError !== "function") {
-        throw new InvalidArgumentError("invalid onError method");
-      }
-      if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) {
-        throw new InvalidArgumentError("invalid onBodySent method");
-      }
-      if (upgrade || method === "CONNECT") {
-        if (typeof handler.onUpgrade !== "function") {
-          throw new InvalidArgumentError("invalid onUpgrade method");
-        }
-      } else {
-        if (typeof handler.onHeaders !== "function") {
-          throw new InvalidArgumentError("invalid onHeaders method");
-        }
-        if (typeof handler.onData !== "function") {
-          throw new InvalidArgumentError("invalid onData method");
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
         }
-        if (typeof handler.onComplete !== "function") {
-          throw new InvalidArgumentError("invalid onComplete method");
+        index++;
+        if (match === "%c") {
+          lastC = index;
         }
-      }
-    }
-    function isDisturbed(body) {
-      return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]));
-    }
-    function isErrored(body) {
-      return !!(body && stream.isErrored(body));
-    }
-    function isReadable2(body) {
-      return !!(body && stream.isReadable(body));
-    }
-    function getSocketInfo(socket) {
-      return {
-        localAddress: socket.localAddress,
-        localPort: socket.localPort,
-        remoteAddress: socket.remoteAddress,
-        remotePort: socket.remotePort,
-        remoteFamily: socket.remoteFamily,
-        timeout: socket.timeout,
-        bytesWritten: socket.bytesWritten,
-        bytesRead: socket.bytesRead
-      };
+      });
+      args.splice(lastC, 0, c);
     }
-    function ReadableStreamFrom(iterable) {
-      let iterator;
-      return new ReadableStream(
-        {
-          async start() {
-            iterator = iterable[Symbol.asyncIterator]();
-          },
-          async pull(controller) {
-            const { done, value } = await iterator.next();
-            if (done) {
-              queueMicrotask(() => {
-                controller.close();
-                controller.byobRequest?.respond(0);
-              });
-            } else {
-              const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
-              if (buf.byteLength) {
-                controller.enqueue(new Uint8Array(buf));
-              }
-            }
-            return controller.desiredSize > 0;
-          },
-          async cancel(reason) {
-            await iterator.return();
-          },
-          type: "bytes"
+    exports2.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports2.storage.setItem("debug", namespaces);
+        } else {
+          exports2.storage.removeItem("debug");
         }
-      );
-    }
-    function isFormDataLike(object) {
-      return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
-    }
-    function addAbortListener(signal, listener) {
-      if ("addEventListener" in signal) {
-        signal.addEventListener("abort", listener, { once: true });
-        return () => signal.removeEventListener("abort", listener);
-      }
-      signal.addListener("abort", listener);
-      return () => signal.removeListener("abort", listener);
-    }
-    var hasToWellFormed = typeof String.prototype.toWellFormed === "function";
-    var hasIsWellFormed = typeof String.prototype.isWellFormed === "function";
-    function toUSVString(val) {
-      return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val);
-    }
-    function isUSVString(val) {
-      return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`;
-    }
-    function isTokenCharCode(c) {
-      switch (c) {
-        case 34:
-        case 40:
-        case 41:
-        case 44:
-        case 47:
-        case 58:
-        case 59:
-        case 60:
-        case 61:
-        case 62:
-        case 63:
-        case 64:
-        case 91:
-        case 92:
-        case 93:
-        case 123:
-        case 125:
-          return false;
-        default:
-          return c >= 33 && c <= 126;
+      } catch (error) {
       }
     }
-    function isValidHTTPToken(characters) {
-      if (characters.length === 0) {
-        return false;
+    function load() {
+      let r;
+      try {
+        r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
+      } catch (error) {
       }
-      for (let i = 0; i < characters.length; ++i) {
-        if (!isTokenCharCode(characters.charCodeAt(i))) {
-          return false;
-        }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
       }
-      return true;
-    }
-    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
-    function isValidHeaderValue(characters) {
-      return !headerCharRegex.test(characters);
-    }
-    function parseRangeHeader(range) {
-      if (range == null || range === "") return { start: 0, end: null, size: null };
-      const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
-      return m ? {
-        start: parseInt(m[1]),
-        end: m[2] ? parseInt(m[2]) : null,
-        size: m[3] ? parseInt(m[3]) : null
-      } : null;
-    }
-    function addListener(obj, name2, listener) {
-      const listeners = obj[kListeners] ??= [];
-      listeners.push([name2, listener]);
-      obj.on(name2, listener);
-      return obj;
+      return r;
     }
-    function removeAllListeners(obj) {
-      for (const [name2, listener] of obj[kListeners] ?? []) {
-        obj.removeListener(name2, listener);
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
       }
-      obj[kListeners] = null;
     }
-    function errorRequest(client, request, err) {
+    module2.exports = require_common()(exports2);
+    var { formatters } = module2.exports;
+    formatters.j = function(v) {
       try {
-        request.onError(err);
-        assert5(request.aborted);
-      } catch (err2) {
-        client.emit("error", err2);
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
       }
-    }
-    var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
-    kEnumerableProperty.enumerable = true;
-    var normalizedMethodRecordsBase = {
-      delete: "DELETE",
-      DELETE: "DELETE",
-      get: "GET",
-      GET: "GET",
-      head: "HEAD",
-      HEAD: "HEAD",
-      options: "OPTIONS",
-      OPTIONS: "OPTIONS",
-      post: "POST",
-      POST: "POST",
-      put: "PUT",
-      PUT: "PUT"
-    };
-    var normalizedMethodRecords = {
-      ...normalizedMethodRecordsBase,
-      patch: "patch",
-      PATCH: "PATCH"
-    };
-    Object.setPrototypeOf(normalizedMethodRecordsBase, null);
-    Object.setPrototypeOf(normalizedMethodRecords, null);
-    module2.exports = {
-      kEnumerableProperty,
-      nop,
-      isDisturbed,
-      isErrored,
-      isReadable: isReadable2,
-      toUSVString,
-      isUSVString,
-      isBlobLike,
-      parseOrigin,
-      parseURL,
-      getServerName,
-      isStream: isStream2,
-      isIterable,
-      isAsyncIterable,
-      isDestroyed,
-      headerNameToString,
-      bufferToLowerCasedHeaderName,
-      addListener,
-      removeAllListeners,
-      errorRequest,
-      parseRawHeaders,
-      parseHeaders,
-      parseKeepAliveTimeout,
-      destroy,
-      bodyLength,
-      deepClone,
-      ReadableStreamFrom,
-      isBuffer,
-      validateHandler,
-      getSocketInfo,
-      isFormDataLike,
-      buildURL,
-      addAbortListener,
-      isValidHTTPToken,
-      isValidHeaderValue,
-      isTokenCharCode,
-      parseRangeHeader,
-      normalizedMethodRecordsBase,
-      normalizedMethodRecords,
-      isValidPort,
-      isHttpOrHttpsPrefixed,
-      nodeMajor,
-      nodeMinor,
-      safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"],
-      wrapRequestBody
     };
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/readable.js
-var require_readable = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/readable.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { Readable: Readable2 } = require("node:stream");
-    var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors();
-    var util = require_util();
-    var { ReadableStreamFrom } = require_util();
-    var kConsume = /* @__PURE__ */ Symbol("kConsume");
-    var kReading = /* @__PURE__ */ Symbol("kReading");
-    var kBody = /* @__PURE__ */ Symbol("kBody");
-    var kAbort = /* @__PURE__ */ Symbol("kAbort");
-    var kContentType = /* @__PURE__ */ Symbol("kContentType");
-    var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
-    var noop3 = () => {
-    };
-    var BodyReadable = class extends Readable2 {
-      constructor({
-        resume,
-        abort,
-        contentType = "",
-        contentLength,
-        highWaterMark = 64 * 1024
-        // Same as nodejs fs streams.
-      }) {
-        super({
-          autoDestroy: true,
-          read: resume,
-          highWaterMark
-        });
-        this._readableState.dataEmitted = false;
-        this[kAbort] = abort;
-        this[kConsume] = null;
-        this[kBody] = null;
-        this[kContentType] = contentType;
-        this[kContentLength] = contentLength;
-        this[kReading] = false;
-      }
-      destroy(err) {
-        if (!err && !this._readableState.endEmitted) {
-          err = new RequestAbortedError();
-        }
-        if (err) {
-          this[kAbort]();
-        }
-        return super.destroy(err);
-      }
-      _destroy(err, callback) {
-        if (!this[kReading]) {
-          setImmediate(() => {
-            callback(err);
-          });
-        } else {
-          callback(err);
-        }
-      }
-      on(ev, ...args) {
-        if (ev === "data" || ev === "readable") {
-          this[kReading] = true;
-        }
-        return super.on(ev, ...args);
-      }
-      addListener(ev, ...args) {
-        return this.on(ev, ...args);
-      }
-      off(ev, ...args) {
-        const ret = super.off(ev, ...args);
-        if (ev === "data" || ev === "readable") {
-          this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
-        }
-        return ret;
-      }
-      removeListener(ev, ...args) {
-        return this.off(ev, ...args);
-      }
-      push(chunk) {
-        if (this[kConsume] && chunk !== null) {
-          consumePush(this[kConsume], chunk);
-          return this[kReading] ? super.push(chunk) : true;
-        }
-        return super.push(chunk);
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-text
-      async text() {
-        return consume(this, "text");
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-json
-      async json() {
-        return consume(this, "json");
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-blob
-      async blob() {
-        return consume(this, "blob");
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-bytes
-      async bytes() {
-        return consume(this, "bytes");
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
-      async arrayBuffer() {
-        return consume(this, "arrayBuffer");
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-formdata
-      async formData() {
-        throw new NotSupportedError();
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-bodyused
-      get bodyUsed() {
-        return util.isDisturbed(this);
-      }
-      // https://fetch.spec.whatwg.org/#dom-body-body
-      get body() {
-        if (!this[kBody]) {
-          this[kBody] = ReadableStreamFrom(this);
-          if (this[kConsume]) {
-            this[kBody].getReader();
-            assert5(this[kBody].locked);
-          }
-        }
-        return this[kBody];
-      }
-      async dump(opts) {
-        let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024;
-        const signal = opts?.signal;
-        if (signal != null && (typeof signal !== "object" || !("aborted" in signal))) {
-          throw new InvalidArgumentError("signal must be an AbortSignal");
-        }
-        signal?.throwIfAborted();
-        if (this._readableState.closeEmitted) {
-          return null;
-        }
-        return await new Promise((resolve, reject) => {
-          if (this[kContentLength] > limit) {
-            this.destroy(new AbortError());
-          }
-          const onAbort = () => {
-            this.destroy(signal.reason ?? new AbortError());
-          };
-          signal?.addEventListener("abort", onAbort);
-          this.on("close", function() {
-            signal?.removeEventListener("abort", onAbort);
-            if (signal?.aborted) {
-              reject(signal.reason ?? new AbortError());
-            } else {
-              resolve(null);
-            }
-          }).on("error", noop3).on("data", function(chunk) {
-            limit -= chunk.length;
-            if (limit <= 0) {
-              this.destroy();
-            }
-          }).resume();
-        });
-      }
-    };
-    function isLocked(self2) {
-      return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
-    }
-    function isUnusable(self2) {
-      return util.isDisturbed(self2) || isLocked(self2);
-    }
-    async function consume(stream, type) {
-      assert5(!stream[kConsume]);
-      return new Promise((resolve, reject) => {
-        if (isUnusable(stream)) {
-          const rState = stream._readableState;
-          if (rState.destroyed && rState.closeEmitted === false) {
-            stream.on("error", (err) => {
-              reject(err);
-            }).on("close", () => {
-              reject(new TypeError("unusable"));
-            });
-          } else {
-            reject(rState.errored ?? new TypeError("unusable"));
-          }
-        } else {
-          queueMicrotask(() => {
-            stream[kConsume] = {
-              type,
-              stream,
-              resolve,
-              reject,
-              length: 0,
-              body: []
-            };
-            stream.on("error", function(err) {
-              consumeFinish(this[kConsume], err);
-            }).on("close", function() {
-              if (this[kConsume].body !== null) {
-                consumeFinish(this[kConsume], new RequestAbortedError());
-              }
-            });
-            consumeStart(stream[kConsume]);
-          });
-        }
-      });
-    }
-    function consumeStart(consume2) {
-      if (consume2.body === null) {
-        return;
-      }
-      const { _readableState: state } = consume2.stream;
-      if (state.bufferIndex) {
-        const start = state.bufferIndex;
-        const end = state.buffer.length;
-        for (let n = start; n < end; n++) {
-          consumePush(consume2, state.buffer[n]);
-        }
-      } else {
-        for (const chunk of state.buffer) {
-          consumePush(consume2, chunk);
-        }
-      }
-      if (state.endEmitted) {
-        consumeEnd(this[kConsume]);
-      } else {
-        consume2.stream.on("end", function() {
-          consumeEnd(this[kConsume]);
-        });
-      }
-      consume2.stream.resume();
-      while (consume2.stream.read() != null) {
-      }
-    }
-    function chunksDecode(chunks, length) {
-      if (chunks.length === 0 || length === 0) {
-        return "";
-      }
-      const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length);
-      const bufferLength = buffer.length;
-      const start = bufferLength > 2 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191 ? 3 : 0;
-      return buffer.utf8Slice(start, bufferLength);
+// node_modules/supports-color/index.js
+var supports_color_exports = {};
+__export(supports_color_exports, {
+  createSupportsColor: () => createSupportsColor,
+  default: () => supports_color_default
+});
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if (!("FORCE_COLOR" in env)) {
+    return;
+  }
+  if (env.FORCE_COLOR === "true") {
+    return 1;
+  }
+  if (env.FORCE_COLOR === "false") {
+    return 0;
+  }
+  if (env.FORCE_COLOR.length === 0) {
+    return 1;
+  }
+  const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  if (![0, 1, 2, 3].includes(level)) {
+    return;
+  }
+  return level;
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    function chunksConcat(chunks, length) {
-      if (chunks.length === 0 || length === 0) {
-        return new Uint8Array(0);
-      }
-      if (chunks.length === 1) {
-        return new Uint8Array(chunks[0]);
-      }
-      const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer);
-      let offset = 0;
-      for (let i = 0; i < chunks.length; ++i) {
-        const chunk = chunks[i];
-        buffer.set(chunk, offset);
-        offset += chunk.length;
-      }
-      return buffer;
+    if (hasFlag("color=256")) {
+      return 2;
     }
-    function consumeEnd(consume2) {
-      const { type, body, resolve, stream, length } = consume2;
-      try {
-        if (type === "text") {
-          resolve(chunksDecode(body, length));
-        } else if (type === "json") {
-          resolve(JSON.parse(chunksDecode(body, length)));
-        } else if (type === "arrayBuffer") {
-          resolve(chunksConcat(body, length).buffer);
-        } else if (type === "blob") {
-          resolve(new Blob(body, { type: stream[kContentType] }));
-        } else if (type === "bytes") {
-          resolve(chunksConcat(body, length));
-        }
-        consumeFinish(consume2);
-      } catch (err) {
-        stream.destroy(err);
-      }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
-    function consumePush(consume2, chunk) {
-      consume2.length += chunk.length;
-      consume2.body.push(chunk);
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
     }
-    function consumeFinish(consume2, err) {
-      if (consume2.body === null) {
-        return;
-      }
-      if (err) {
-        consume2.reject(err);
-      } else {
-        consume2.resolve();
-      }
-      consume2.type = null;
-      consume2.stream = null;
-      consume2.resolve = null;
-      consume2.reject = null;
-      consume2.length = 0;
-      consume2.body = null;
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
     }
-    module2.exports = { Readable: BodyReadable, chunksDecode };
+    return min;
   }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/util.js
-var require_util2 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/util.js"(exports2, module2) {
-    var assert5 = require("node:assert");
-    var {
-      ResponseStatusCodeError
-    } = require_errors();
-    var { chunksDecode } = require_readable();
-    var CHUNK_LIMIT = 128 * 1024;
-    async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
-      assert5(body);
-      let chunks = [];
-      let length = 0;
-      try {
-        for await (const chunk of body) {
-          chunks.push(chunk);
-          length += chunk.length;
-          if (length > CHUNK_LIMIT) {
-            chunks = [];
-            length = 0;
-            break;
-          }
-        }
-      } catch {
-        chunks = [];
-        length = 0;
-      }
-      const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`;
-      if (statusCode === 204 || !contentType || !length) {
-        queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)));
-        return;
-      }
-      const stackTraceLimit = Error.stackTraceLimit;
-      Error.stackTraceLimit = 0;
-      let payload;
-      try {
-        if (isContentTypeApplicationJson(contentType)) {
-          payload = JSON.parse(chunksDecode(chunks, length));
-        } else if (isContentTypeText(contentType)) {
-          payload = chunksDecode(chunks, length);
-        }
-      } catch {
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit;
-      }
-      queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)));
-    }
-    var isContentTypeApplicationJson = (contentType) => {
-      return contentType.length > 15 && contentType[11] === "/" && contentType[0] === "a" && contentType[1] === "p" && contentType[2] === "p" && contentType[3] === "l" && contentType[4] === "i" && contentType[5] === "c" && contentType[6] === "a" && contentType[7] === "t" && contentType[8] === "i" && contentType[9] === "o" && contentType[10] === "n" && contentType[12] === "j" && contentType[13] === "s" && contentType[14] === "o" && contentType[15] === "n";
-    };
-    var isContentTypeText = (contentType) => {
-      return contentType.length > 4 && contentType[4] === "/" && contentType[0] === "t" && contentType[1] === "e" && contentType[2] === "x" && contentType[3] === "t";
-    };
-    module2.exports = {
-      getResolveErrorBodyCallback,
-      isContentTypeApplicationJson,
-      isContentTypeText
-    };
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
   }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-request.js
-var require_api_request = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-request.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { Readable: Readable2 } = require_readable();
-    var { InvalidArgumentError, RequestAbortedError } = require_errors();
-    var util = require_util();
-    var { getResolveErrorBodyCallback } = require_util2();
-    var { AsyncResource } = require("node:async_hooks");
-    var RequestHandler = class extends AsyncResource {
-      constructor(opts, callback) {
-        if (!opts || typeof opts !== "object") {
-          throw new InvalidArgumentError("invalid opts");
-        }
-        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts;
-        try {
-          if (typeof callback !== "function") {
-            throw new InvalidArgumentError("invalid callback");
-          }
-          if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) {
-            throw new InvalidArgumentError("invalid highWaterMark");
-          }
-          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
-            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
-          }
-          if (method === "CONNECT") {
-            throw new InvalidArgumentError("invalid method");
-          }
-          if (onInfo && typeof onInfo !== "function") {
-            throw new InvalidArgumentError("invalid onInfo callback");
-          }
-          super("UNDICI_REQUEST");
-        } catch (err) {
-          if (util.isStream(body)) {
-            util.destroy(body.on("error", util.nop), err);
-          }
-          throw err;
-        }
-        this.method = method;
-        this.responseHeaders = responseHeaders || null;
-        this.opaque = opaque || null;
-        this.callback = callback;
-        this.res = null;
-        this.abort = null;
-        this.body = body;
-        this.trailers = {};
-        this.context = null;
-        this.onInfo = onInfo || null;
-        this.throwOnError = throwOnError;
-        this.highWaterMark = highWaterMark;
-        this.signal = signal;
-        this.reason = null;
-        this.removeAbortListener = null;
-        if (util.isStream(body)) {
-          body.on("error", (err) => {
-            this.onError(err);
-          });
-        }
-        if (this.signal) {
-          if (this.signal.aborted) {
-            this.reason = this.signal.reason ?? new RequestAbortedError();
-          } else {
-            this.removeAbortListener = util.addAbortListener(this.signal, () => {
-              this.reason = this.signal.reason ?? new RequestAbortedError();
-              if (this.res) {
-                util.destroy(this.res.on("error", util.nop), this.reason);
-              } else if (this.abort) {
-                this.abort(this.reason);
-              }
-              if (this.removeAbortListener) {
-                this.res?.off("close", this.removeAbortListener);
-                this.removeAbortListener();
-                this.removeAbortListener = null;
-              }
-            });
-          }
-        }
-      }
-      onConnect(abort, context) {
-        if (this.reason) {
-          abort(this.reason);
-          return;
-        }
-        assert5(this.callback);
-        this.abort = abort;
-        this.context = context;
-      }
-      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-        const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this;
-        const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-        if (statusCode < 200) {
-          if (this.onInfo) {
-            this.onInfo({ statusCode, headers });
-          }
-          return;
-        }
-        const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
-        const contentType = parsedHeaders["content-type"];
-        const contentLength = parsedHeaders["content-length"];
-        const res = new Readable2({
-          resume,
-          abort,
-          contentType,
-          contentLength: this.method !== "HEAD" && contentLength ? Number(contentLength) : null,
-          highWaterMark
-        });
-        if (this.removeAbortListener) {
-          res.on("close", this.removeAbortListener);
-        }
-        this.callback = null;
-        this.res = res;
-        if (callback !== null) {
-          if (this.throwOnError && statusCode >= 400) {
-            this.runInAsyncScope(
-              getResolveErrorBodyCallback,
-              null,
-              { callback, body: res, contentType, statusCode, statusMessage, headers }
-            );
-          } else {
-            this.runInAsyncScope(callback, null, null, {
-              statusCode,
-              headers,
-              trailers: this.trailers,
-              opaque,
-              body: res,
-              context
-            });
-          }
-        }
-      }
-      onData(chunk) {
-        return this.res.push(chunk);
-      }
-      onComplete(trailers) {
-        util.parseHeaders(trailers, this.trailers);
-        this.res.push(null);
-      }
-      onError(err) {
-        const { res, callback, body, opaque } = this;
-        if (callback) {
-          this.callback = null;
-          queueMicrotask(() => {
-            this.runInAsyncScope(callback, null, err, { opaque });
-          });
-        }
-        if (res) {
-          this.res = null;
-          queueMicrotask(() => {
-            util.destroy(res, err);
-          });
-        }
-        if (body) {
-          this.body = null;
-          util.destroy(body, err);
-        }
-        if (this.removeAbortListener) {
-          res?.off("close", this.removeAbortListener);
-          this.removeAbortListener();
-          this.removeAbortListener = null;
-        }
-      }
-    };
-    function request(opts, callback) {
-      if (callback === void 0) {
-        return new Promise((resolve, reject) => {
-          request.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
-          });
-        });
-      }
-      try {
-        this.dispatch(opts, new RequestHandler(opts, callback));
-      } catch (err) {
-        if (typeof callback !== "function") {
-          throw err;
-        }
-        const opaque = opts?.opaque;
-        queueMicrotask(() => callback(err, { opaque }));
-      }
-    }
-    module2.exports = request;
-    module2.exports.RequestHandler = RequestHandler;
+  if (env.COLORTERM === "truecolor") {
+    return 3;
   }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/abort-signal.js
-var require_abort_signal = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/abort-signal.js"(exports2, module2) {
-    var { addAbortListener } = require_util();
-    var { RequestAbortedError } = require_errors();
-    var kListener = /* @__PURE__ */ Symbol("kListener");
-    var kSignal = /* @__PURE__ */ Symbol("kSignal");
-    function abort(self2) {
-      if (self2.abort) {
-        self2.abort(self2[kSignal]?.reason);
-      } else {
-        self2.reason = self2[kSignal]?.reason ?? new RequestAbortedError();
-      }
-      removeSignal(self2);
-    }
-    function addSignal(self2, signal) {
-      self2.reason = null;
-      self2[kSignal] = null;
-      self2[kListener] = null;
-      if (!signal) {
-        return;
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
       }
-      if (signal.aborted) {
-        abort(self2);
-        return;
+      case "Apple_Terminal": {
+        return 2;
       }
-      self2[kSignal] = signal;
-      self2[kListener] = () => {
-        abort(self2);
-      };
-      addAbortListener(self2[kSignal], self2[kListener]);
     }
-    function removeSignal(self2) {
-      if (!self2[kSignal]) {
-        return;
-      }
-      if ("removeEventListener" in self2[kSignal]) {
-        self2[kSignal].removeEventListener("abort", self2[kListener]);
-      } else {
-        self2[kSignal].removeListener("abort", self2[kListener]);
-      }
-      self2[kSignal] = null;
-      self2[kListener] = null;
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/supports-color/index.js"() {
+    import_node_process = __toESM(require("node:process"), 1);
+    import_node_os = __toESM(require("node:os"), 1);
+    import_node_tty = __toESM(require("node:tty"), 1);
+    ({ env } = import_node_process.default);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
     }
-    module2.exports = {
-      addSignal,
-      removeSignal
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
     };
+    supports_color_default = supportsColor;
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-stream.js
-var require_api_stream = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-stream.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { finished, PassThrough } = require("node:stream");
-    var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
-    var util = require_util();
-    var { getResolveErrorBodyCallback } = require_util2();
-    var { AsyncResource } = require("node:async_hooks");
-    var { addSignal, removeSignal } = require_abort_signal();
-    var StreamHandler = class extends AsyncResource {
-      constructor(opts, factory, callback) {
-        if (!opts || typeof opts !== "object") {
-          throw new InvalidArgumentError("invalid opts");
-        }
-        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
-        try {
-          if (typeof callback !== "function") {
-            throw new InvalidArgumentError("invalid callback");
-          }
-          if (typeof factory !== "function") {
-            throw new InvalidArgumentError("invalid factory");
-          }
-          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
-            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
-          }
-          if (method === "CONNECT") {
-            throw new InvalidArgumentError("invalid method");
-          }
-          if (onInfo && typeof onInfo !== "function") {
-            throw new InvalidArgumentError("invalid onInfo callback");
-          }
-          super("UNDICI_STREAM");
-        } catch (err) {
-          if (util.isStream(body)) {
-            util.destroy(body.on("error", util.nop), err);
-          }
-          throw err;
-        }
-        this.responseHeaders = responseHeaders || null;
-        this.opaque = opaque || null;
-        this.factory = factory;
-        this.callback = callback;
-        this.res = null;
-        this.abort = null;
-        this.context = null;
-        this.trailers = null;
-        this.body = body;
-        this.onInfo = onInfo || null;
-        this.throwOnError = throwOnError || false;
-        if (util.isStream(body)) {
-          body.on("error", (err) => {
-            this.onError(err);
-          });
-        }
-        addSignal(this, signal);
-      }
-      onConnect(abort, context) {
-        if (this.reason) {
-          abort(this.reason);
-          return;
-        }
-        assert5(this.callback);
-        this.abort = abort;
-        this.context = context;
-      }
-      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-        const { factory, opaque, context, callback, responseHeaders } = this;
-        const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-        if (statusCode < 200) {
-          if (this.onInfo) {
-            this.onInfo({ statusCode, headers });
-          }
-          return;
-        }
-        this.factory = null;
-        let res;
-        if (this.throwOnError && statusCode >= 400) {
-          const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
-          const contentType = parsedHeaders["content-type"];
-          res = new PassThrough();
-          this.callback = null;
-          this.runInAsyncScope(
-            getResolveErrorBodyCallback,
-            null,
-            { callback, body: res, contentType, statusCode, statusMessage, headers }
-          );
-        } else {
-          if (factory === null) {
-            return;
-          }
-          res = this.runInAsyncScope(factory, null, {
-            statusCode,
-            headers,
-            opaque,
-            context
-          });
-          if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
-            throw new InvalidReturnValueError("expected Writable");
-          }
-          finished(res, { readable: false }, (err) => {
-            const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this;
-            this.res = null;
-            if (err || !res2.readable) {
-              util.destroy(res2, err);
-            }
-            this.callback = null;
-            this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers });
-            if (err) {
-              abort();
-            }
-          });
-        }
-        res.on("drain", resume);
-        this.res = res;
-        const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState?.needDrain;
-        return needDrain !== true;
-      }
-      onData(chunk) {
-        const { res } = this;
-        return res ? res.write(chunk) : true;
-      }
-      onComplete(trailers) {
-        const { res } = this;
-        removeSignal(this);
-        if (!res) {
-          return;
-        }
-        this.trailers = util.parseHeaders(trailers);
-        res.end();
-      }
-      onError(err) {
-        const { res, callback, opaque, body } = this;
-        removeSignal(this);
-        this.factory = null;
-        if (res) {
-          this.res = null;
-          util.destroy(res, err);
-        } else if (callback) {
-          this.callback = null;
-          queueMicrotask(() => {
-            this.runInAsyncScope(callback, null, err, { opaque });
-          });
-        }
-        if (body) {
-          this.body = null;
-          util.destroy(body, err);
-        }
-      }
-    };
-    function stream(opts, factory, callback) {
-      if (callback === void 0) {
-        return new Promise((resolve, reject) => {
-          stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve(data);
-          });
-        });
-      }
-      try {
-        this.dispatch(opts, new StreamHandler(opts, factory, callback));
-      } catch (err) {
-        if (typeof callback !== "function") {
-          throw err;
-        }
-        const opaque = opts?.opaque;
-        queueMicrotask(() => callback(err, { opaque }));
+// node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "node_modules/debug/src/node.js"(exports2, module2) {
+    var tty3 = require("tty");
+    var util = require("util");
+    exports2.init = init;
+    exports2.log = log2;
+    exports2.formatArgs = formatArgs;
+    exports2.save = save;
+    exports2.load = load;
+    exports2.useColors = useColors;
+    exports2.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports2.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
+      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
+        exports2.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
       }
+    } catch (error) {
     }
-    module2.exports = stream;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-pipeline.js
-var require_api_pipeline = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) {
-    "use strict";
-    var {
-      Readable: Readable2,
-      Duplex,
-      PassThrough
-    } = require("node:stream");
-    var {
-      InvalidArgumentError,
-      InvalidReturnValueError,
-      RequestAbortedError
-    } = require_errors();
-    var util = require_util();
-    var { AsyncResource } = require("node:async_hooks");
-    var { addSignal, removeSignal } = require_abort_signal();
-    var assert5 = require("node:assert");
-    var kResume = /* @__PURE__ */ Symbol("resume");
-    var PipelineRequest = class extends Readable2 {
-      constructor() {
-        super({ autoDestroy: true });
-        this[kResume] = null;
-      }
-      _read() {
-        const { [kResume]: resume } = this;
-        if (resume) {
-          this[kResume] = null;
-          resume();
-        }
+    exports2.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
       }
-      _destroy(err, callback) {
-        this._read();
-        callback(err);
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty3.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name2, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name2} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name2 + " " + args[0];
       }
-    };
-    var PipelineResponse = class extends Readable2 {
-      constructor(resume) {
-        super({ autoDestroy: true });
-        this[kResume] = resume;
+    }
+    function getDate() {
+      if (exports2.inspectOpts.hideDate) {
+        return "";
       }
-      _read() {
-        this[kResume]();
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log2(...args) {
+      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
       }
-      _destroy(err, callback) {
-        if (!err && !this._readableState.endEmitted) {
-          err = new RequestAbortedError();
-        }
-        callback(err);
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports2.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
       }
+    }
+    module2.exports = require_common()(exports2);
+    var { formatters } = module2.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
     };
-    var PipelineHandler = class extends AsyncResource {
-      constructor(opts, handler) {
-        if (!opts || typeof opts !== "object") {
-          throw new InvalidArgumentError("invalid opts");
-        }
-        if (typeof handler !== "function") {
-          throw new InvalidArgumentError("invalid handler");
-        }
-        const { signal, method, opaque, onInfo, responseHeaders } = opts;
-        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
-          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
-        }
-        if (method === "CONNECT") {
-          throw new InvalidArgumentError("invalid method");
-        }
-        if (onInfo && typeof onInfo !== "function") {
-          throw new InvalidArgumentError("invalid onInfo callback");
-        }
-        super("UNDICI_PIPELINE");
-        this.opaque = opaque || null;
-        this.responseHeaders = responseHeaders || null;
-        this.handler = handler;
-        this.abort = null;
-        this.context = null;
-        this.onInfo = onInfo || null;
-        this.req = new PipelineRequest().on("error", util.nop);
-        this.ret = new Duplex({
-          readableObjectMode: opts.objectMode,
-          autoDestroy: true,
-          read: () => {
-            const { body } = this;
-            if (body?.resume) {
-              body.resume();
-            }
-          },
-          write: (chunk, encoding, callback) => {
-            const { req } = this;
-            if (req.push(chunk, encoding) || req._readableState.destroyed) {
-              callback();
-            } else {
-              req[kResume] = callback;
-            }
-          },
-          destroy: (err, callback) => {
-            const { body, req, res, ret, abort } = this;
-            if (!err && !ret._readableState.endEmitted) {
-              err = new RequestAbortedError();
-            }
-            if (abort && err) {
-              abort();
-            }
-            util.destroy(body, err);
-            util.destroy(req, err);
-            util.destroy(res, err);
-            removeSignal(this);
-            callback(err);
-          }
-        }).on("prefinish", () => {
-          const { req } = this;
-          req.push(null);
-        });
-        this.res = null;
-        addSignal(this, signal);
-      }
-      onConnect(abort, context) {
-        const { ret, res } = this;
-        if (this.reason) {
-          abort(this.reason);
-          return;
-        }
-        assert5(!res, "pipeline cannot be retried");
-        assert5(!ret.destroyed);
-        this.abort = abort;
-        this.context = context;
-      }
-      onHeaders(statusCode, rawHeaders, resume) {
-        const { opaque, handler, context } = this;
-        if (statusCode < 200) {
-          if (this.onInfo) {
-            const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-            this.onInfo({ statusCode, headers });
-          }
-          return;
-        }
-        this.res = new PipelineResponse(resume);
-        let body;
-        try {
-          this.handler = null;
-          const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-          body = this.runInAsyncScope(handler, null, {
-            statusCode,
-            headers,
-            opaque,
-            body: this.res,
-            context
-          });
-        } catch (err) {
-          this.res.on("error", util.nop);
-          throw err;
-        }
-        if (!body || typeof body.on !== "function") {
-          throw new InvalidReturnValueError("expected Readable");
-        }
-        body.on("data", (chunk) => {
-          const { ret, body: body2 } = this;
-          if (!ret.push(chunk) && body2.pause) {
-            body2.pause();
-          }
-        }).on("error", (err) => {
-          const { ret } = this;
-          util.destroy(ret, err);
-        }).on("end", () => {
-          const { ret } = this;
-          ret.push(null);
-        }).on("close", () => {
-          const { ret } = this;
-          if (!ret._readableState.ended) {
-            util.destroy(ret, new RequestAbortedError());
-          }
-        });
-        this.body = body;
-      }
-      onData(chunk) {
-        const { res } = this;
-        return res.push(chunk);
-      }
-      onComplete(trailers) {
-        const { res } = this;
-        res.push(null);
-      }
-      onError(err) {
-        const { ret } = this;
-        this.handler = null;
-        util.destroy(ret, err);
-      }
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
     };
-    function pipeline(opts, handler) {
-      try {
-        const pipelineHandler = new PipelineHandler(opts, handler);
-        this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
-        return pipelineHandler.ret;
-      } catch (err) {
-        return new PassThrough().destroy(err);
-      }
-    }
-    module2.exports = pipeline;
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-upgrade.js
-var require_api_upgrade = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) {
-    "use strict";
-    var { InvalidArgumentError, SocketError } = require_errors();
-    var { AsyncResource } = require("node:async_hooks");
-    var util = require_util();
-    var { addSignal, removeSignal } = require_abort_signal();
-    var assert5 = require("node:assert");
-    var UpgradeHandler = class extends AsyncResource {
-      constructor(opts, callback) {
-        if (!opts || typeof opts !== "object") {
-          throw new InvalidArgumentError("invalid opts");
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        const { signal, opaque, responseHeaders } = opts;
-        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
-          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
-        }
-        super("UNDICI_UPGRADE");
-        this.responseHeaders = responseHeaders || null;
-        this.opaque = opaque || null;
-        this.callback = callback;
-        this.abort = null;
-        this.context = null;
-        addSignal(this, signal);
-      }
-      onConnect(abort, context) {
-        if (this.reason) {
-          abort(this.reason);
-          return;
-        }
-        assert5(this.callback);
-        this.abort = abort;
-        this.context = null;
-      }
-      onHeaders() {
-        throw new SocketError("bad upgrade", null);
-      }
-      onUpgrade(statusCode, rawHeaders, socket) {
-        assert5(statusCode === 101);
-        const { callback, opaque, context } = this;
-        removeSignal(this);
-        this.callback = null;
-        const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-        this.runInAsyncScope(callback, null, null, {
-          headers,
-          socket,
-          opaque,
-          context
-        });
-      }
-      onError(err) {
-        const { callback, opaque } = this;
-        removeSignal(this);
-        if (callback) {
-          this.callback = null;
-          queueMicrotask(() => {
-            this.runInAsyncScope(callback, null, err, { opaque });
-          });
-        }
-      }
-    };
-    function upgrade(opts, callback) {
-      if (callback === void 0) {
-        return new Promise((resolve, reject) => {
-          upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
-          });
-        });
-      }
-      try {
-        const upgradeHandler = new UpgradeHandler(opts, callback);
-        this.dispatch({
-          ...opts,
-          method: opts.method || "GET",
-          upgrade: opts.protocol || "Websocket"
-        }, upgradeHandler);
-      } catch (err) {
-        if (typeof callback !== "function") {
-          throw err;
-        }
-        const opaque = opts?.opaque;
-        queueMicrotask(() => callback(err, { opaque }));
-      }
+// node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "node_modules/debug/src/index.js"(exports2, module2) {
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module2.exports = require_browser();
+    } else {
+      module2.exports = require_node();
     }
-    module2.exports = upgrade;
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-connect.js
-var require_api_connect = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-connect.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { AsyncResource } = require("node:async_hooks");
-    var { InvalidArgumentError, SocketError } = require_errors();
-    var util = require_util();
-    var { addSignal, removeSignal } = require_abort_signal();
-    var ConnectHandler = class extends AsyncResource {
-      constructor(opts, callback) {
-        if (!opts || typeof opts !== "object") {
-          throw new InvalidArgumentError("invalid opts");
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        const { signal, opaque, responseHeaders } = opts;
-        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
-          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
-        }
-        super("UNDICI_CONNECT");
-        this.opaque = opaque || null;
-        this.responseHeaders = responseHeaders || null;
-        this.callback = callback;
-        this.abort = null;
-        addSignal(this, signal);
-      }
-      onConnect(abort, context) {
-        if (this.reason) {
-          abort(this.reason);
-          return;
-        }
-        assert5(this.callback);
-        this.abort = abort;
-        this.context = context;
-      }
-      onHeaders() {
-        throw new SocketError("bad connect", null);
-      }
-      onUpgrade(statusCode, rawHeaders, socket) {
-        const { callback, opaque, context } = this;
-        removeSignal(this);
-        this.callback = null;
-        let headers = rawHeaders;
-        if (headers != null) {
-          headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
-        }
-        this.runInAsyncScope(callback, null, null, {
-          statusCode,
-          headers,
-          socket,
-          opaque,
-          context
-        });
-      }
-      onError(err) {
-        const { callback, opaque } = this;
-        removeSignal(this);
-        if (callback) {
-          this.callback = null;
-          queueMicrotask(() => {
-            this.runInAsyncScope(callback, null, err, { opaque });
-          });
-        }
-      }
+// node_modules/minipass/dist/esm/index.js
+var import_node_events, import_node_stream, import_node_string_decoder, proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass;
+var init_esm = __esm({
+  "node_modules/minipass/dist/esm/index.js"() {
+    import_node_events = require("node:events");
+    import_node_stream = __toESM(require("node:stream"), 1);
+    import_node_string_decoder = require("node:string_decoder");
+    proc = typeof process === "object" && process ? process : {
+      stdout: null,
+      stderr: null
     };
-    function connect(opts, callback) {
-      if (callback === void 0) {
-        return new Promise((resolve, reject) => {
-          connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
-          });
-        });
-      }
-      try {
-        const connectHandler = new ConnectHandler(opts, callback);
-        this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
-      } catch (err) {
-        if (typeof callback !== "function") {
-          throw err;
-        }
-        const opaque = opts?.opaque;
-        queueMicrotask(() => callback(err, { opaque }));
-      }
-    }
-    module2.exports = connect;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/index.js
-var require_api = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports.request = require_api_request();
-    module2.exports.stream = require_api_stream();
-    module2.exports.pipeline = require_api_pipeline();
-    module2.exports.upgrade = require_api_upgrade();
-    module2.exports.connect = require_api_connect();
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher.js
-var require_dispatcher = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
-    "use strict";
-    var EventEmitter2 = require("node:events");
-    var Dispatcher = class extends EventEmitter2 {
-      dispatch() {
-        throw new Error("not implemented");
+    isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof import_node_stream.default || isReadable(s) || isWritable(s));
+    isReadable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
+    s.pipe !== import_node_stream.default.Writable.prototype.pipe;
+    isWritable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.write === "function" && typeof s.end === "function";
+    EOF = /* @__PURE__ */ Symbol("EOF");
+    MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
+    EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
+    EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
+    EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
+    CLOSED = /* @__PURE__ */ Symbol("closed");
+    READ = /* @__PURE__ */ Symbol("read");
+    FLUSH = /* @__PURE__ */ Symbol("flush");
+    FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
+    ENCODING = /* @__PURE__ */ Symbol("encoding");
+    DECODER = /* @__PURE__ */ Symbol("decoder");
+    FLOWING = /* @__PURE__ */ Symbol("flowing");
+    PAUSED = /* @__PURE__ */ Symbol("paused");
+    RESUME = /* @__PURE__ */ Symbol("resume");
+    BUFFER = /* @__PURE__ */ Symbol("buffer");
+    PIPES = /* @__PURE__ */ Symbol("pipes");
+    BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
+    BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
+    BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
+    OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
+    DESTROYED = /* @__PURE__ */ Symbol("destroyed");
+    ERROR = /* @__PURE__ */ Symbol("error");
+    EMITDATA = /* @__PURE__ */ Symbol("emitData");
+    EMITEND = /* @__PURE__ */ Symbol("emitEnd");
+    EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
+    ASYNC = /* @__PURE__ */ Symbol("async");
+    ABORT = /* @__PURE__ */ Symbol("abort");
+    ABORTED = /* @__PURE__ */ Symbol("aborted");
+    SIGNAL = /* @__PURE__ */ Symbol("signal");
+    DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
+    DISCARDED = /* @__PURE__ */ Symbol("discarded");
+    defer = (fn2) => Promise.resolve().then(fn2);
+    nodefer = (fn2) => fn2();
+    isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
+    isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
+    isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+    Pipe = class {
+      src;
+      dest;
+      opts;
+      ondrain;
+      constructor(src, dest, opts) {
+        this.src = src;
+        this.dest = dest;
+        this.opts = opts;
+        this.ondrain = () => src[RESUME]();
+        this.dest.on("drain", this.ondrain);
       }
-      close() {
-        throw new Error("not implemented");
+      unpipe() {
+        this.dest.removeListener("drain", this.ondrain);
       }
-      destroy() {
-        throw new Error("not implemented");
+      // only here for the prototype
+      /* c8 ignore start */
+      proxyErrors(_er) {
       }
-      compose(...args) {
-        const interceptors = Array.isArray(args[0]) ? args[0] : args;
-        let dispatch = this.dispatch.bind(this);
-        for (const interceptor of interceptors) {
-          if (interceptor == null) {
-            continue;
-          }
-          if (typeof interceptor !== "function") {
-            throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`);
-          }
-          dispatch = interceptor(dispatch);
-          if (dispatch == null || typeof dispatch !== "function" || dispatch.length !== 2) {
-            throw new TypeError("invalid interceptor");
-          }
-        }
-        return new ComposedDispatcher(this, dispatch);
+      /* c8 ignore stop */
+      end() {
+        this.unpipe();
+        if (this.opts.end)
+          this.dest.end();
       }
     };
-    var ComposedDispatcher = class extends Dispatcher {
-      #dispatcher = null;
-      #dispatch = null;
-      constructor(dispatcher, dispatch) {
-        super();
-        this.#dispatcher = dispatcher;
-        this.#dispatch = dispatch;
-      }
-      dispatch(...args) {
-        this.#dispatch(...args);
-      }
-      close(...args) {
-        return this.#dispatcher.close(...args);
+    PipeProxyErrors = class extends Pipe {
+      unpipe() {
+        this.src.removeListener("error", this.proxyErrors);
+        super.unpipe();
       }
-      destroy(...args) {
-        return this.#dispatcher.destroy(...args);
+      constructor(src, dest, opts) {
+        super(src, dest, opts);
+        this.proxyErrors = (er) => this.dest.emit("error", er);
+        src.on("error", this.proxyErrors);
       }
     };
-    module2.exports = Dispatcher;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js
-var require_dispatcher_base = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports2, module2) {
-    "use strict";
-    var Dispatcher = require_dispatcher();
-    var {
-      ClientDestroyedError,
-      ClientClosedError,
-      InvalidArgumentError
-    } = require_errors();
-    var { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require_symbols();
-    var kOnDestroyed = /* @__PURE__ */ Symbol("onDestroyed");
-    var kOnClosed = /* @__PURE__ */ Symbol("onClosed");
-    var kInterceptedDispatch = /* @__PURE__ */ Symbol("Intercepted Dispatch");
-    var kWebSocketOptions = /* @__PURE__ */ Symbol("webSocketOptions");
-    var DispatcherBase = class extends Dispatcher {
-      constructor(opts) {
+    isObjectModeOptions = (o) => !!o.objectMode;
+    isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
+    Minipass = class extends import_node_events.EventEmitter {
+      [FLOWING] = false;
+      [PAUSED] = false;
+      [PIPES] = [];
+      [BUFFER] = [];
+      [OBJECTMODE];
+      [ENCODING];
+      [ASYNC];
+      [DECODER];
+      [EOF] = false;
+      [EMITTED_END] = false;
+      [EMITTING_END] = false;
+      [CLOSED] = false;
+      [EMITTED_ERROR] = null;
+      [BUFFERLENGTH] = 0;
+      [DESTROYED] = false;
+      [SIGNAL];
+      [ABORTED] = false;
+      [DATALISTENERS] = 0;
+      [DISCARDED] = false;
+      /**
+       * true if the stream can be written
+       */
+      writable = true;
+      /**
+       * true if the stream can be read
+       */
+      readable = true;
+      /**
+       * If `RType` is Buffer, then options do not need to be provided.
+       * Otherwise, an options object must be provided to specify either
+       * {@link Minipass.SharedOptions.objectMode} or
+       * {@link Minipass.SharedOptions.encoding}, as appropriate.
+       */
+      constructor(...args) {
+        const options = args[0] || {};
         super();
-        this[kDestroyed] = false;
-        this[kOnDestroyed] = null;
-        this[kClosed] = false;
-        this[kOnClosed] = [];
-        this[kWebSocketOptions] = opts?.webSocket ?? {};
-      }
-      get webSocketOptions() {
-        return {
-          maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024
-        };
-      }
-      get destroyed() {
-        return this[kDestroyed];
-      }
-      get closed() {
-        return this[kClosed];
-      }
-      get interceptors() {
-        return this[kInterceptors];
-      }
-      set interceptors(newInterceptors) {
-        if (newInterceptors) {
-          for (let i = newInterceptors.length - 1; i >= 0; i--) {
-            const interceptor = this[kInterceptors][i];
-            if (typeof interceptor !== "function") {
-              throw new InvalidArgumentError("interceptor must be an function");
-            }
-          }
+        if (options.objectMode && typeof options.encoding === "string") {
+          throw new TypeError("Encoding and objectMode may not be used together");
         }
-        this[kInterceptors] = newInterceptors;
-      }
-      close(callback) {
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.close((err, data) => {
-              return err ? reject(err) : resolve(data);
-            });
-          });
+        if (isObjectModeOptions(options)) {
+          this[OBJECTMODE] = true;
+          this[ENCODING] = null;
+        } else if (isEncodingOptions(options)) {
+          this[ENCODING] = options.encoding;
+          this[OBJECTMODE] = false;
+        } else {
+          this[OBJECTMODE] = false;
+          this[ENCODING] = null;
         }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
+        this[ASYNC] = !!options.async;
+        this[DECODER] = this[ENCODING] ? new import_node_string_decoder.StringDecoder(this[ENCODING]) : null;
+        if (options && options.debugExposeBuffer === true) {
+          Object.defineProperty(this, "buffer", { get: () => this[BUFFER] });
         }
-        if (this[kDestroyed]) {
-          queueMicrotask(() => callback(new ClientDestroyedError(), null));
-          return;
+        if (options && options.debugExposePipes === true) {
+          Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
         }
-        if (this[kClosed]) {
-          if (this[kOnClosed]) {
-            this[kOnClosed].push(callback);
+        const { signal } = options;
+        if (signal) {
+          this[SIGNAL] = signal;
+          if (signal.aborted) {
+            this[ABORT]();
           } else {
-            queueMicrotask(() => callback(null, null));
+            signal.addEventListener("abort", () => this[ABORT]());
           }
-          return;
         }
-        this[kClosed] = true;
-        this[kOnClosed].push(callback);
-        const onClosed = () => {
-          const callbacks = this[kOnClosed];
-          this[kOnClosed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kClose]().then(() => this.destroy()).then(() => {
-          queueMicrotask(onClosed);
-        });
       }
-      destroy(err, callback) {
-        if (typeof err === "function") {
-          callback = err;
-          err = null;
-        }
-        if (callback === void 0) {
-          return new Promise((resolve, reject) => {
-            this.destroy(err, (err2, data) => {
-              return err2 ? (
-                /* istanbul ignore next: should never error */
-                reject(err2)
-              ) : resolve(data);
-            });
-          });
-        }
-        if (typeof callback !== "function") {
-          throw new InvalidArgumentError("invalid callback");
-        }
-        if (this[kDestroyed]) {
-          if (this[kOnDestroyed]) {
-            this[kOnDestroyed].push(callback);
-          } else {
-            queueMicrotask(() => callback(null, null));
-          }
-          return;
-        }
-        if (!err) {
-          err = new ClientDestroyedError();
-        }
-        this[kDestroyed] = true;
-        this[kOnDestroyed] = this[kOnDestroyed] || [];
-        this[kOnDestroyed].push(callback);
-        const onDestroyed = () => {
-          const callbacks = this[kOnDestroyed];
-          this[kOnDestroyed] = null;
-          for (let i = 0; i < callbacks.length; i++) {
-            callbacks[i](null, null);
-          }
-        };
-        this[kDestroy](err).then(() => {
-          queueMicrotask(onDestroyed);
-        });
+      /**
+       * The amount of data stored in the buffer waiting to be read.
+       *
+       * For Buffer strings, this will be the total byte length.
+       * For string encoding streams, this will be the string character length,
+       * according to JavaScript's `string.length` logic.
+       * For objectMode streams, this is a count of the items waiting to be
+       * emitted.
+       */
+      get bufferLength() {
+        return this[BUFFERLENGTH];
       }
-      [kInterceptedDispatch](opts, handler) {
-        if (!this[kInterceptors] || this[kInterceptors].length === 0) {
-          this[kInterceptedDispatch] = this[kDispatch];
-          return this[kDispatch](opts, handler);
-        }
-        let dispatch = this[kDispatch].bind(this);
-        for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
-          dispatch = this[kInterceptors][i](dispatch);
-        }
-        this[kInterceptedDispatch] = dispatch;
-        return dispatch(opts, handler);
+      /**
+       * The `BufferEncoding` currently in use, or `null`
+       */
+      get encoding() {
+        return this[ENCODING];
       }
-      dispatch(opts, handler) {
-        if (!handler || typeof handler !== "object") {
-          throw new InvalidArgumentError("handler must be an object");
-        }
-        try {
-          if (!opts || typeof opts !== "object") {
-            throw new InvalidArgumentError("opts must be an object.");
-          }
-          if (this[kDestroyed] || this[kOnDestroyed]) {
-            throw new ClientDestroyedError();
-          }
-          if (this[kClosed]) {
-            throw new ClientClosedError();
-          }
-          return this[kInterceptedDispatch](opts, handler);
-        } catch (err) {
-          if (typeof handler.onError !== "function") {
-            throw new InvalidArgumentError("invalid onError method");
-          }
-          handler.onError(err);
-          return false;
-        }
+      /**
+       * @deprecated - This is a read only property
+       */
+      set encoding(_enc) {
+        throw new Error("Encoding must be set at instantiation time");
       }
-    };
-    module2.exports = DispatcherBase;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/fixed-queue.js
-var require_fixed_queue = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/fixed-queue.js"(exports2, module2) {
-    "use strict";
-    var kSize = 2048;
-    var kMask = kSize - 1;
-    var FixedCircularBuffer = class {
-      constructor() {
-        this.bottom = 0;
-        this.top = 0;
-        this.list = new Array(kSize);
-        this.next = null;
+      /**
+       * @deprecated - Encoding may only be set at instantiation time
+       */
+      setEncoding(_enc) {
+        throw new Error("Encoding must be set at instantiation time");
       }
-      isEmpty() {
-        return this.top === this.bottom;
+      /**
+       * True if this is an objectMode stream
+       */
+      get objectMode() {
+        return this[OBJECTMODE];
       }
-      isFull() {
-        return (this.top + 1 & kMask) === this.bottom;
+      /**
+       * @deprecated - This is a read-only property
+       */
+      set objectMode(_om) {
+        throw new Error("objectMode must be set at instantiation time");
       }
-      push(data) {
-        this.list[this.top] = data;
-        this.top = this.top + 1 & kMask;
+      /**
+       * true if this is an async stream
+       */
+      get ["async"]() {
+        return this[ASYNC];
       }
-      shift() {
-        const nextItem = this.list[this.bottom];
-        if (nextItem === void 0)
-          return null;
-        this.list[this.bottom] = void 0;
-        this.bottom = this.bottom + 1 & kMask;
-        return nextItem;
+      /**
+       * Set to true to make this stream async.
+       *
+       * Once set, it cannot be unset, as this would potentially cause incorrect
+       * behavior.  Ie, a sync stream can be made async, but an async stream
+       * cannot be safely made sync.
+       */
+      set ["async"](a) {
+        this[ASYNC] = this[ASYNC] || !!a;
       }
-    };
-    module2.exports = class FixedQueue {
-      constructor() {
-        this.head = this.tail = new FixedCircularBuffer();
+      // drop everything and get out of the flow completely
+      [ABORT]() {
+        this[ABORTED] = true;
+        this.emit("abort", this[SIGNAL]?.reason);
+        this.destroy(this[SIGNAL]?.reason);
       }
-      isEmpty() {
-        return this.head.isEmpty();
+      /**
+       * True if the stream has been aborted.
+       */
+      get aborted() {
+        return this[ABORTED];
       }
-      push(data) {
-        if (this.head.isFull()) {
-          this.head = this.head.next = new FixedCircularBuffer();
-        }
-        this.head.push(data);
+      /**
+       * No-op setter. Stream aborted status is set via the AbortSignal provided
+       * in the constructor options.
+       */
+      set aborted(_) {
       }
-      shift() {
-        const tail = this.tail;
-        const next = tail.shift();
-        if (tail.isEmpty() && tail.next !== null) {
-          this.tail = tail.next;
+      write(chunk, encoding, cb) {
+        if (this[ABORTED])
+          return false;
+        if (this[EOF])
+          throw new Error("write after end");
+        if (this[DESTROYED]) {
+          this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
+          return true;
         }
-        return next;
-      }
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-stats.js
-var require_pool_stats = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-stats.js"(exports2, module2) {
-    var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
-    var kPool = /* @__PURE__ */ Symbol("pool");
-    var PoolStats = class {
-      constructor(pool) {
-        this[kPool] = pool;
-      }
-      get connected() {
-        return this[kPool][kConnected];
-      }
-      get free() {
-        return this[kPool][kFree];
-      }
-      get pending() {
-        return this[kPool][kPending];
-      }
-      get queued() {
-        return this[kPool][kQueued];
-      }
-      get running() {
-        return this[kPool][kRunning];
-      }
-      get size() {
-        return this[kPool][kSize];
-      }
-    };
-    module2.exports = PoolStats;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-base.js
-var require_pool_base = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-base.js"(exports2, module2) {
-    "use strict";
-    var DispatcherBase = require_dispatcher_base();
-    var FixedQueue = require_fixed_queue();
-    var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
-    var PoolStats = require_pool_stats();
-    var kClients = /* @__PURE__ */ Symbol("clients");
-    var kNeedDrain = /* @__PURE__ */ Symbol("needDrain");
-    var kQueue = /* @__PURE__ */ Symbol("queue");
-    var kClosedResolve = /* @__PURE__ */ Symbol("closed resolve");
-    var kOnDrain = /* @__PURE__ */ Symbol("onDrain");
-    var kOnConnect = /* @__PURE__ */ Symbol("onConnect");
-    var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect");
-    var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError");
-    var kGetDispatcher = /* @__PURE__ */ Symbol("get dispatcher");
-    var kAddClient = /* @__PURE__ */ Symbol("add client");
-    var kRemoveClient = /* @__PURE__ */ Symbol("remove client");
-    var kStats = /* @__PURE__ */ Symbol("stats");
-    var PoolBase = class extends DispatcherBase {
-      constructor(opts) {
-        super(opts);
-        this[kQueue] = new FixedQueue();
-        this[kClients] = [];
-        this[kQueued] = 0;
-        const pool = this;
-        this[kOnDrain] = function onDrain(origin, targets) {
-          const queue = pool[kQueue];
-          let needDrain = false;
-          while (!needDrain) {
-            const item = queue.shift();
-            if (!item) {
-              break;
-            }
-            pool[kQueued]--;
-            needDrain = !this.dispatch(item.opts, item.handler);
-          }
-          this[kNeedDrain] = needDrain;
-          if (!this[kNeedDrain] && pool[kNeedDrain]) {
-            pool[kNeedDrain] = false;
-            pool.emit("drain", origin, [pool, ...targets]);
-          }
-          if (pool[kClosedResolve] && queue.isEmpty()) {
-            Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = "utf8";
+        }
+        if (!encoding)
+          encoding = "utf8";
+        const fn2 = this[ASYNC] ? defer : nodefer;
+        if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+          if (isArrayBufferView(chunk)) {
+            chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+          } else if (isArrayBufferLike(chunk)) {
+            chunk = Buffer.from(chunk);
+          } else if (typeof chunk !== "string") {
+            throw new Error("Non-contiguous data written to non-objectMode stream");
           }
-        };
-        this[kOnConnect] = (origin, targets) => {
-          pool.emit("connect", origin, [pool, ...targets]);
-        };
-        this[kOnDisconnect] = (origin, targets, err) => {
-          pool.emit("disconnect", origin, [pool, ...targets], err);
-        };
-        this[kOnConnectionError] = (origin, targets, err) => {
-          pool.emit("connectionError", origin, [pool, ...targets], err);
-        };
-        this[kStats] = new PoolStats(this);
-      }
-      get [kBusy]() {
-        return this[kNeedDrain];
-      }
-      get [kConnected]() {
-        return this[kClients].filter((client) => client[kConnected]).length;
-      }
-      get [kFree]() {
-        return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
-      }
-      get [kPending]() {
-        let ret = this[kQueued];
-        for (const { [kPending]: pending } of this[kClients]) {
-          ret += pending;
         }
-        return ret;
-      }
-      get [kRunning]() {
-        let ret = 0;
-        for (const { [kRunning]: running } of this[kClients]) {
-          ret += running;
+        if (this[OBJECTMODE]) {
+          if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
+            this[FLUSH](true);
+          if (this[FLOWING])
+            this.emit("data", chunk);
+          else
+            this[BUFFERPUSH](chunk);
+          if (this[BUFFERLENGTH] !== 0)
+            this.emit("readable");
+          if (cb)
+            fn2(cb);
+          return this[FLOWING];
         }
-        return ret;
-      }
-      get [kSize]() {
-        let ret = this[kQueued];
-        for (const { [kSize]: size } of this[kClients]) {
-          ret += size;
+        if (!chunk.length) {
+          if (this[BUFFERLENGTH] !== 0)
+            this.emit("readable");
+          if (cb)
+            fn2(cb);
+          return this[FLOWING];
         }
-        return ret;
-      }
-      get stats() {
-        return this[kStats];
-      }
-      async [kClose]() {
-        if (this[kQueue].isEmpty()) {
-          await Promise.all(this[kClients].map((c) => c.close()));
-        } else {
-          await new Promise((resolve) => {
-            this[kClosedResolve] = resolve;
-          });
+        if (typeof chunk === "string" && // unless it is a string already ready for us to use
+        !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) {
+          chunk = Buffer.from(chunk, encoding);
         }
-      }
-      async [kDestroy](err) {
-        while (true) {
-          const item = this[kQueue].shift();
-          if (!item) {
-            break;
-          }
-          item.handler.onError(err);
-        }
-        await Promise.all(this[kClients].map((c) => c.destroy(err)));
-      }
-      [kDispatch](opts, handler) {
-        const dispatcher = this[kGetDispatcher]();
-        if (!dispatcher) {
-          this[kNeedDrain] = true;
-          this[kQueue].push({ opts, handler });
-          this[kQueued]++;
-        } else if (!dispatcher.dispatch(opts, handler)) {
-          dispatcher[kNeedDrain] = true;
-          this[kNeedDrain] = !this[kGetDispatcher]();
-        }
-        return !this[kNeedDrain];
-      }
-      [kAddClient](client) {
-        client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
-        this[kClients].push(client);
-        if (this[kNeedDrain]) {
-          queueMicrotask(() => {
-            if (this[kNeedDrain]) {
-              this[kOnDrain](client[kUrl], [this, client]);
-            }
-          });
+        if (Buffer.isBuffer(chunk) && this[ENCODING]) {
+          chunk = this[DECODER].write(chunk);
         }
-        return this;
-      }
-      [kRemoveClient](client) {
-        client.close(() => {
-          const idx = this[kClients].indexOf(client);
-          if (idx !== -1) {
-            this[kClients].splice(idx, 1);
-          }
-        });
-        this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
-      }
-    };
-    module2.exports = {
-      PoolBase,
-      kClients,
-      kNeedDrain,
-      kAddClient,
-      kRemoveClient,
-      kGetDispatcher
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/diagnostics.js
-var require_diagnostics = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/diagnostics.js"(exports2, module2) {
-    "use strict";
-    var diagnosticsChannel = require("node:diagnostics_channel");
-    var util = require("node:util");
-    var undiciDebugLog = util.debuglog("undici");
-    var fetchDebuglog = util.debuglog("fetch");
-    var websocketDebuglog = util.debuglog("websocket");
-    var isClientSet = false;
-    var channels = {
-      // Client
-      beforeConnect: diagnosticsChannel.channel("undici:client:beforeConnect"),
-      connected: diagnosticsChannel.channel("undici:client:connected"),
-      connectError: diagnosticsChannel.channel("undici:client:connectError"),
-      sendHeaders: diagnosticsChannel.channel("undici:client:sendHeaders"),
-      // Request
-      create: diagnosticsChannel.channel("undici:request:create"),
-      bodySent: diagnosticsChannel.channel("undici:request:bodySent"),
-      headers: diagnosticsChannel.channel("undici:request:headers"),
-      trailers: diagnosticsChannel.channel("undici:request:trailers"),
-      error: diagnosticsChannel.channel("undici:request:error"),
-      // WebSocket
-      open: diagnosticsChannel.channel("undici:websocket:open"),
-      close: diagnosticsChannel.channel("undici:websocket:close"),
-      socketError: diagnosticsChannel.channel("undici:websocket:socket_error"),
-      ping: diagnosticsChannel.channel("undici:websocket:ping"),
-      pong: diagnosticsChannel.channel("undici:websocket:pong")
-    };
-    if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
-      const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog;
-      diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
-        const {
-          connectParams: { version: version2, protocol, port, host }
-        } = evt;
-        debuglog(
-          "connecting to %s using %s%s",
-          `${host}${port ? `:${port}` : ""}`,
-          protocol,
-          version2
-        );
-      });
-      diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
-        const {
-          connectParams: { version: version2, protocol, port, host }
-        } = evt;
-        debuglog(
-          "connected to %s using %s%s",
-          `${host}${port ? `:${port}` : ""}`,
-          protocol,
-          version2
-        );
-      });
-      diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
-        const {
-          connectParams: { version: version2, protocol, port, host },
-          error
-        } = evt;
-        debuglog(
-          "connection to %s using %s%s errored - %s",
-          `${host}${port ? `:${port}` : ""}`,
-          protocol,
-          version2,
-          error.message
-        );
-      });
-      diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
-        const {
-          request: { method, path: path16, origin }
-        } = evt;
-        debuglog("sending request to %s %s/%s", method, origin, path16);
-      });
-      diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => {
-        const {
-          request: { method, path: path16, origin },
-          response: { statusCode }
-        } = evt;
-        debuglog(
-          "received response to %s %s/%s - HTTP %d",
-          method,
-          origin,
-          path16,
-          statusCode
-        );
-      });
-      diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => {
-        const {
-          request: { method, path: path16, origin }
-        } = evt;
-        debuglog("trailers received from %s %s/%s", method, origin, path16);
-      });
-      diagnosticsChannel.channel("undici:request:error").subscribe((evt) => {
-        const {
-          request: { method, path: path16, origin },
-          error
-        } = evt;
-        debuglog(
-          "request to %s %s/%s errored - %s",
-          method,
-          origin,
-          path16,
-          error.message
-        );
-      });
-      isClientSet = true;
-    }
-    if (websocketDebuglog.enabled) {
-      if (!isClientSet) {
-        const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog;
-        diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => {
-          const {
-            connectParams: { version: version2, protocol, port, host }
-          } = evt;
-          debuglog(
-            "connecting to %s%s using %s%s",
-            host,
-            port ? `:${port}` : "",
-            protocol,
-            version2
-          );
-        });
-        diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => {
-          const {
-            connectParams: { version: version2, protocol, port, host }
-          } = evt;
-          debuglog(
-            "connected to %s%s using %s%s",
-            host,
-            port ? `:${port}` : "",
-            protocol,
-            version2
-          );
-        });
-        diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => {
-          const {
-            connectParams: { version: version2, protocol, port, host },
-            error
-          } = evt;
-          debuglog(
-            "connection to %s%s using %s%s errored - %s",
-            host,
-            port ? `:${port}` : "",
-            protocol,
-            version2,
-            error.message
-          );
-        });
-        diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
-          const {
-            request: { method, path: path16, origin }
-          } = evt;
-          debuglog("sending request to %s %s/%s", method, origin, path16);
-        });
+        if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
+          this[FLUSH](true);
+        if (this[FLOWING])
+          this.emit("data", chunk);
+        else
+          this[BUFFERPUSH](chunk);
+        if (this[BUFFERLENGTH] !== 0)
+          this.emit("readable");
+        if (cb)
+          fn2(cb);
+        return this[FLOWING];
       }
-      diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => {
-        const {
-          address: { address, port }
-        } = evt;
-        websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : "");
-      });
-      diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => {
-        const { websocket, code: code2, reason } = evt;
-        websocketDebuglog(
-          "closed connection to %s - %s %s",
-          websocket.url,
-          code2,
-          reason
-        );
-      });
-      diagnosticsChannel.channel("undici:websocket:socket_error").subscribe((err) => {
-        websocketDebuglog("connection errored - %s", err.message);
-      });
-      diagnosticsChannel.channel("undici:websocket:ping").subscribe((evt) => {
-        websocketDebuglog("ping received");
-      });
-      diagnosticsChannel.channel("undici:websocket:pong").subscribe((evt) => {
-        websocketDebuglog("pong received");
-      });
-    }
-    module2.exports = {
-      channels
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/request.js
-var require_request = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/request.js"(exports2, module2) {
-    "use strict";
-    var {
-      InvalidArgumentError,
-      NotSupportedError
-    } = require_errors();
-    var assert5 = require("node:assert");
-    var {
-      isValidHTTPToken,
-      isValidHeaderValue,
-      isStream: isStream2,
-      destroy,
-      isBuffer,
-      isFormDataLike,
-      isIterable,
-      isBlobLike,
-      buildURL,
-      validateHandler,
-      getServerName,
-      normalizedMethodRecords
-    } = require_util();
-    var { channels } = require_diagnostics();
-    var { headerNameLowerCasedRecord } = require_constants2();
-    var invalidPathRegex = /[^\u0021-\u00ff]/;
-    var kHandler = /* @__PURE__ */ Symbol("handler");
-    var Request = class {
-      constructor(origin, {
-        path: path16,
-        method,
-        body,
-        headers,
-        query,
-        idempotent,
-        blocking,
-        upgrade,
-        headersTimeout,
-        bodyTimeout,
-        reset,
-        throwOnError,
-        expectContinue,
-        servername
-      }, handler) {
-        if (typeof path16 !== "string") {
-          throw new InvalidArgumentError("path must be a string");
-        } else if (path16[0] !== "/" && !(path16.startsWith("http://") || path16.startsWith("https://")) && method !== "CONNECT") {
-          throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path16)) {
-          throw new InvalidArgumentError("invalid request path");
-        }
-        if (typeof method !== "string") {
-          throw new InvalidArgumentError("method must be a string");
-        } else if (normalizedMethodRecords[method] === void 0 && !isValidHTTPToken(method)) {
-          throw new InvalidArgumentError("invalid request method");
-        }
-        if (upgrade && typeof upgrade !== "string") {
-          throw new InvalidArgumentError("upgrade must be a string");
-        }
-        if (upgrade && !isValidHeaderValue(upgrade)) {
-          throw new InvalidArgumentError("invalid upgrade header");
-        }
-        if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
-          throw new InvalidArgumentError("invalid headersTimeout");
-        }
-        if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
-          throw new InvalidArgumentError("invalid bodyTimeout");
-        }
-        if (reset != null && typeof reset !== "boolean") {
-          throw new InvalidArgumentError("invalid reset");
-        }
-        if (expectContinue != null && typeof expectContinue !== "boolean") {
-          throw new InvalidArgumentError("invalid expectContinue");
-        }
-        this.headersTimeout = headersTimeout;
-        this.bodyTimeout = bodyTimeout;
-        this.throwOnError = throwOnError === true;
-        this.method = method;
-        this.abort = null;
-        if (body == null) {
-          this.body = null;
-        } else if (isStream2(body)) {
-          this.body = body;
-          const rState = this.body._readableState;
-          if (!rState || !rState.autoDestroy) {
-            this.endHandler = function autoDestroy() {
-              destroy(this);
-            };
-            this.body.on("end", this.endHandler);
-          }
-          this.errorHandler = (err) => {
-            if (this.abort) {
-              this.abort(err);
-            } else {
-              this.error = err;
-            }
-          };
-          this.body.on("error", this.errorHandler);
-        } else if (isBuffer(body)) {
-          this.body = body.byteLength ? body : null;
-        } else if (ArrayBuffer.isView(body)) {
-          this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
-        } else if (body instanceof ArrayBuffer) {
-          this.body = body.byteLength ? Buffer.from(body) : null;
-        } else if (typeof body === "string") {
-          this.body = body.length ? Buffer.from(body) : null;
-        } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
-          this.body = body;
-        } else {
-          throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
-        }
-        this.completed = false;
-        this.aborted = false;
-        this.upgrade = upgrade || null;
-        this.path = query ? buildURL(path16, query) : path16;
-        this.origin = origin;
-        this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
-        this.blocking = blocking == null ? false : blocking;
-        this.reset = reset == null ? null : reset;
-        this.host = null;
-        this.contentLength = null;
-        this.contentType = null;
-        this.headers = [];
-        this.expectContinue = expectContinue != null ? expectContinue : false;
-        if (Array.isArray(headers)) {
-          if (headers.length % 2 !== 0) {
-            throw new InvalidArgumentError("headers array must be even");
-          }
-          for (let i = 0; i < headers.length; i += 2) {
-            processHeader(this, headers[i], headers[i + 1]);
-          }
-        } else if (headers && typeof headers === "object") {
-          if (headers[Symbol.iterator]) {
-            for (const header of headers) {
-              if (!Array.isArray(header) || header.length !== 2) {
-                throw new InvalidArgumentError("headers must be in key-value pair format");
-              }
-              processHeader(this, header[0], header[1]);
-            }
-          } else {
-            const keys = Object.keys(headers);
-            for (let i = 0; i < keys.length; ++i) {
-              processHeader(this, keys[i], headers[keys[i]]);
-            }
-          }
-        } else if (headers != null) {
-          throw new InvalidArgumentError("headers must be an object or an array");
+      /**
+       * Low-level explicit read method.
+       *
+       * In objectMode, the argument is ignored, and one item is returned if
+       * available.
+       *
+       * `n` is the number of bytes (or in the case of encoding streams,
+       * characters) to consume. If `n` is not provided, then the entire buffer
+       * is returned, or `null` is returned if no data is available.
+       *
+       * If `n` is greater that the amount of data in the internal buffer,
+       * then `null` is returned.
+       */
+      read(n) {
+        if (this[DESTROYED])
+          return null;
+        this[DISCARDED] = false;
+        if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) {
+          this[MAYBE_EMIT_END]();
+          return null;
         }
-        validateHandler(handler, method, upgrade);
-        this.servername = servername || getServerName(this.host);
-        this[kHandler] = handler;
-        if (channels.create.hasSubscribers) {
-          channels.create.publish({ request: this });
+        if (this[OBJECTMODE])
+          n = null;
+        if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
+          this[BUFFER] = [
+            this[ENCODING] ? this[BUFFER].join("") : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
+          ];
         }
+        const ret = this[READ](n || null, this[BUFFER][0]);
+        this[MAYBE_EMIT_END]();
+        return ret;
       }
-      onBodySent(chunk) {
-        if (this[kHandler].onBodySent) {
-          try {
-            return this[kHandler].onBodySent(chunk);
-          } catch (err) {
-            this.abort(err);
+      [READ](n, chunk) {
+        if (this[OBJECTMODE])
+          this[BUFFERSHIFT]();
+        else {
+          const c = chunk;
+          if (n === c.length || n === null)
+            this[BUFFERSHIFT]();
+          else if (typeof c === "string") {
+            this[BUFFER][0] = c.slice(n);
+            chunk = c.slice(0, n);
+            this[BUFFERLENGTH] -= n;
+          } else {
+            this[BUFFER][0] = c.subarray(n);
+            chunk = c.subarray(0, n);
+            this[BUFFERLENGTH] -= n;
           }
         }
+        this.emit("data", chunk);
+        if (!this[BUFFER].length && !this[EOF])
+          this.emit("drain");
+        return chunk;
       }
-      onRequestSent() {
-        if (channels.bodySent.hasSubscribers) {
-          channels.bodySent.publish({ request: this });
-        }
-        if (this[kHandler].onRequestSent) {
-          try {
-            return this[kHandler].onRequestSent();
-          } catch (err) {
-            this.abort(err);
-          }
-        }
-      }
-      onConnect(abort) {
-        assert5(!this.aborted);
-        assert5(!this.completed);
-        if (this.error) {
-          abort(this.error);
-        } else {
-          this.abort = abort;
-          return this[kHandler].onConnect(abort);
-        }
-      }
-      onResponseStarted() {
-        return this[kHandler].onResponseStarted?.();
-      }
-      onHeaders(statusCode, headers, resume, statusText) {
-        assert5(!this.aborted);
-        assert5(!this.completed);
-        if (channels.headers.hasSubscribers) {
-          channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
-        }
-        try {
-          return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
-        } catch (err) {
-          this.abort(err);
-        }
-      }
-      onData(chunk) {
-        assert5(!this.aborted);
-        assert5(!this.completed);
-        try {
-          return this[kHandler].onData(chunk);
-        } catch (err) {
-          this.abort(err);
-          return false;
-        }
-      }
-      onUpgrade(statusCode, headers, socket) {
-        assert5(!this.aborted);
-        assert5(!this.completed);
-        return this[kHandler].onUpgrade(statusCode, headers, socket);
-      }
-      onComplete(trailers) {
-        this.onFinally();
-        assert5(!this.aborted);
-        this.completed = true;
-        if (channels.trailers.hasSubscribers) {
-          channels.trailers.publish({ request: this, trailers });
-        }
-        try {
-          return this[kHandler].onComplete(trailers);
-        } catch (err) {
-          this.onError(err);
-        }
-      }
-      onError(error) {
-        this.onFinally();
-        if (channels.error.hasSubscribers) {
-          channels.error.publish({ request: this, error });
-        }
-        if (this.aborted) {
-          return;
-        }
-        this.aborted = true;
-        return this[kHandler].onError(error);
-      }
-      onFinally() {
-        if (this.errorHandler) {
-          this.body.off("error", this.errorHandler);
-          this.errorHandler = null;
+      end(chunk, encoding, cb) {
+        if (typeof chunk === "function") {
+          cb = chunk;
+          chunk = void 0;
         }
-        if (this.endHandler) {
-          this.body.off("end", this.endHandler);
-          this.endHandler = null;
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = "utf8";
         }
-      }
-      addHeader(key, value) {
-        processHeader(this, key, value);
+        if (chunk !== void 0)
+          this.write(chunk, encoding);
+        if (cb)
+          this.once("end", cb);
+        this[EOF] = true;
+        this.writable = false;
+        if (this[FLOWING] || !this[PAUSED])
+          this[MAYBE_EMIT_END]();
         return this;
       }
-    };
-    function processHeader(request, key, val) {
-      if (val && (typeof val === "object" && !Array.isArray(val))) {
-        throw new InvalidArgumentError(`invalid ${key} header`);
-      } else if (val === void 0) {
-        return;
-      }
-      let headerName = headerNameLowerCasedRecord[key];
-      if (headerName === void 0) {
-        headerName = key.toLowerCase();
-        if (headerNameLowerCasedRecord[headerName] === void 0 && !isValidHTTPToken(headerName)) {
-          throw new InvalidArgumentError("invalid header key");
-        }
-      }
-      if (Array.isArray(val)) {
-        const arr = [];
-        for (let i = 0; i < val.length; i++) {
-          if (typeof val[i] === "string") {
-            if (!isValidHeaderValue(val[i])) {
-              throw new InvalidArgumentError(`invalid ${key} header`);
-            }
-            arr.push(val[i]);
-          } else if (val[i] === null) {
-            arr.push("");
-          } else if (typeof val[i] === "object") {
-            throw new InvalidArgumentError(`invalid ${key} header`);
-          } else {
-            arr.push(`${val[i]}`);
-          }
-        }
-        val = arr;
-      } else if (typeof val === "string") {
-        if (!isValidHeaderValue(val)) {
-          throw new InvalidArgumentError(`invalid ${key} header`);
-        }
-      } else if (val === null) {
-        val = "";
-      } else {
-        val = `${val}`;
-      }
-      if (headerName === "host") {
-        if (request.host !== null) {
-          throw new InvalidArgumentError("duplicate host header");
-        }
-        if (typeof val !== "string") {
-          throw new InvalidArgumentError("invalid host header");
-        }
-        request.host = val;
-      } else if (headerName === "content-length") {
-        if (request.contentLength !== null) {
-          throw new InvalidArgumentError("duplicate content-length header");
-        }
-        request.contentLength = parseInt(val, 10);
-        if (!Number.isFinite(request.contentLength)) {
-          throw new InvalidArgumentError("invalid content-length header");
-        }
-      } else if (request.contentType === null && headerName === "content-type") {
-        request.contentType = val;
-        request.headers.push(key, val);
-      } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
-        throw new InvalidArgumentError(`invalid ${headerName} header`);
-      } else if (headerName === "connection") {
-        const value = typeof val === "string" ? val.toLowerCase() : null;
-        if (value !== "close" && value !== "keep-alive") {
-          throw new InvalidArgumentError("invalid connection header");
-        }
-        if (value === "close") {
-          request.reset = true;
-        }
-      } else if (headerName === "expect") {
-        throw new NotSupportedError("expect header not supported");
-      } else {
-        request.headers.push(key, val);
-      }
-    }
-    module2.exports = Request;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/util/timers.js
-var require_timers = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/util/timers.js"(exports2, module2) {
-    "use strict";
-    var fastNow = 0;
-    var RESOLUTION_MS = 1e3;
-    var TICK_MS = (RESOLUTION_MS >> 1) - 1;
-    var fastNowTimeout;
-    var kFastTimer = /* @__PURE__ */ Symbol("kFastTimer");
-    var fastTimers = [];
-    var NOT_IN_LIST = -2;
-    var TO_BE_CLEARED = -1;
-    var PENDING2 = 0;
-    var ACTIVE = 1;
-    function onTick() {
-      fastNow += TICK_MS;
-      let idx = 0;
-      let len = fastTimers.length;
-      while (idx < len) {
-        const timer = fastTimers[idx];
-        if (timer._state === PENDING2) {
-          timer._idleStart = fastNow - TICK_MS;
-          timer._state = ACTIVE;
-        } else if (timer._state === ACTIVE && fastNow >= timer._idleStart + timer._idleTimeout) {
-          timer._state = TO_BE_CLEARED;
-          timer._idleStart = -1;
-          timer._onTimeout(timer._timerArg);
-        }
-        if (timer._state === TO_BE_CLEARED) {
-          timer._state = NOT_IN_LIST;
-          if (--len !== 0) {
-            fastTimers[idx] = fastTimers[len];
-          }
-        } else {
-          ++idx;
-        }
-      }
-      fastTimers.length = len;
-      if (fastTimers.length !== 0) {
-        refreshTimeout();
-      }
-    }
-    function refreshTimeout() {
-      if (fastNowTimeout) {
-        fastNowTimeout.refresh();
-      } else {
-        clearTimeout(fastNowTimeout);
-        fastNowTimeout = setTimeout(onTick, TICK_MS);
-        if (fastNowTimeout.unref) {
-          fastNowTimeout.unref();
+      // don't let the internal resume be overwritten
+      [RESUME]() {
+        if (this[DESTROYED])
+          return;
+        if (!this[DATALISTENERS] && !this[PIPES].length) {
+          this[DISCARDED] = true;
         }
+        this[PAUSED] = false;
+        this[FLOWING] = true;
+        this.emit("resume");
+        if (this[BUFFER].length)
+          this[FLUSH]();
+        else if (this[EOF])
+          this[MAYBE_EMIT_END]();
+        else
+          this.emit("drain");
       }
-    }
-    var FastTimer = class {
-      [kFastTimer] = true;
       /**
-       * The state of the timer, which can be one of the following:
-       * - NOT_IN_LIST (-2)
-       * - TO_BE_CLEARED (-1)
-       * - PENDING (0)
-       * - ACTIVE (1)
-       *
-       * @type {-2|-1|0|1}
-       * @private
-       */
-      _state = NOT_IN_LIST;
-      /**
-       * The number of milliseconds to wait before calling the callback.
+       * Resume the stream if it is currently in a paused state
        *
-       * @type {number}
-       * @private
+       * If called when there are no pipe destinations or `data` event listeners,
+       * this will place the stream in a "discarded" state, where all data will
+       * be thrown away. The discarded state is removed if a pipe destination or
+       * data handler is added, if pause() is called, or if any synchronous or
+       * asynchronous iteration is started.
        */
-      _idleTimeout = -1;
+      resume() {
+        return this[RESUME]();
+      }
       /**
-       * The time in milliseconds when the timer was started. This value is used to
-       * calculate when the timer should expire.
-       *
-       * @type {number}
-       * @default -1
-       * @private
+       * Pause the stream
        */
-      _idleStart = -1;
+      pause() {
+        this[FLOWING] = false;
+        this[PAUSED] = true;
+        this[DISCARDED] = false;
+      }
       /**
-       * The function to be executed when the timer expires.
-       * @type {Function}
-       * @private
+       * true if the stream has been forcibly destroyed
        */
-      _onTimeout;
+      get destroyed() {
+        return this[DESTROYED];
+      }
       /**
-       * The argument to be passed to the callback when the timer expires.
-       *
-       * @type {*}
-       * @private
+       * true if the stream is currently in a flowing state, meaning that
+       * any writes will be immediately emitted.
        */
-      _timerArg;
+      get flowing() {
+        return this[FLOWING];
+      }
       /**
-       * @constructor
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should wait
-       * before the specified function or code is executed.
-       * @param {*} arg
+       * true if the stream is currently in a paused state
        */
-      constructor(callback, delay, arg) {
-        this._onTimeout = callback;
-        this._idleTimeout = delay;
-        this._timerArg = arg;
-        this.refresh();
+      get paused() {
+        return this[PAUSED];
+      }
+      [BUFFERPUSH](chunk) {
+        if (this[OBJECTMODE])
+          this[BUFFERLENGTH] += 1;
+        else
+          this[BUFFERLENGTH] += chunk.length;
+        this[BUFFER].push(chunk);
+      }
+      [BUFFERSHIFT]() {
+        if (this[OBJECTMODE])
+          this[BUFFERLENGTH] -= 1;
+        else
+          this[BUFFERLENGTH] -= this[BUFFER][0].length;
+        return this[BUFFER].shift();
+      }
+      [FLUSH](noDrain = false) {
+        do {
+        } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
+        if (!noDrain && !this[BUFFER].length && !this[EOF])
+          this.emit("drain");
+      }
+      [FLUSHCHUNK](chunk) {
+        this.emit("data", chunk);
+        return this[FLOWING];
       }
       /**
-       * Sets the timer's start time to the current time, and reschedules the timer
-       * to call its callback at the previously specified duration adjusted to the
-       * current time.
-       * Using this on a timer that has already called its callback will reactivate
-       * the timer.
+       * Pipe all data emitted by this stream into the destination provided.
        *
-       * @returns {void}
+       * Triggers the flow of data.
        */
-      refresh() {
-        if (this._state === NOT_IN_LIST) {
-          fastTimers.push(this);
-        }
-        if (!fastNowTimeout || fastTimers.length === 1) {
-          refreshTimeout();
+      pipe(dest, opts) {
+        if (this[DESTROYED])
+          return dest;
+        this[DISCARDED] = false;
+        const ended = this[EMITTED_END];
+        opts = opts || {};
+        if (dest === proc.stdout || dest === proc.stderr)
+          opts.end = false;
+        else
+          opts.end = opts.end !== false;
+        opts.proxyErrors = !!opts.proxyErrors;
+        if (ended) {
+          if (opts.end)
+            dest.end();
+        } else {
+          this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
+          if (this[ASYNC])
+            defer(() => this[RESUME]());
+          else
+            this[RESUME]();
         }
-        this._state = PENDING2;
+        return dest;
       }
       /**
-       * The `clear` method cancels the timer, preventing it from executing.
+       * Fully unhook a piped destination stream.
        *
-       * @returns {void}
-       * @private
+       * If the destination stream was the only consumer of this stream (ie,
+       * there are no other piped destinations or `'data'` event listeners)
+       * then the flow of data will stop until there is another consumer or
+       * {@link Minipass#resume} is explicitly called.
        */
-      clear() {
-        this._state = TO_BE_CLEARED;
-        this._idleStart = -1;
+      unpipe(dest) {
+        const p = this[PIPES].find((p2) => p2.dest === dest);
+        if (p) {
+          if (this[PIPES].length === 1) {
+            if (this[FLOWING] && this[DATALISTENERS] === 0) {
+              this[FLOWING] = false;
+            }
+            this[PIPES] = [];
+          } else
+            this[PIPES].splice(this[PIPES].indexOf(p), 1);
+          p.unpipe();
+        }
       }
-    };
-    module2.exports = {
       /**
-       * The setTimeout() method sets a timer which executes a function once the
-       * timer expires.
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should
-       * wait before the specified function or code is executed.
-       * @param {*} [arg] An optional argument to be passed to the callback function
-       * when the timer expires.
-       * @returns {NodeJS.Timeout|FastTimer}
+       * Alias for {@link Minipass#on}
        */
-      setTimeout(callback, delay, arg) {
-        return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
-      },
+      addListener(ev, handler) {
+        return this.on(ev, handler);
+      }
       /**
-       * The clearTimeout method cancels an instantiated Timer previously created
-       * by calling setTimeout.
+       * Mostly identical to `EventEmitter.on`, with the following
+       * behavior differences to prevent data loss and unnecessary hangs:
+       *
+       * - Adding a 'data' event handler will trigger the flow of data
        *
-       * @param {NodeJS.Timeout|FastTimer} timeout
+       * - Adding a 'readable' event handler when there is data waiting to be read
+       *   will cause 'readable' to be emitted immediately.
+       *
+       * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+       *   already passed will cause the event to be emitted immediately and all
+       *   handlers removed.
+       *
+       * - Adding an 'error' event handler after an error has been emitted will
+       *   cause the event to be re-emitted immediately with the error previously
+       *   raised.
        */
-      clearTimeout(timeout) {
-        if (timeout[kFastTimer]) {
-          timeout.clear();
-        } else {
-          clearTimeout(timeout);
+      on(ev, handler) {
+        const ret = super.on(ev, handler);
+        if (ev === "data") {
+          this[DISCARDED] = false;
+          this[DATALISTENERS]++;
+          if (!this[PIPES].length && !this[FLOWING]) {
+            this[RESUME]();
+          }
+        } else if (ev === "readable" && this[BUFFERLENGTH] !== 0) {
+          super.emit("readable");
+        } else if (isEndish(ev) && this[EMITTED_END]) {
+          super.emit(ev);
+          this.removeAllListeners(ev);
+        } else if (ev === "error" && this[EMITTED_ERROR]) {
+          const h = handler;
+          if (this[ASYNC])
+            defer(() => h.call(this, this[EMITTED_ERROR]));
+          else
+            h.call(this, this[EMITTED_ERROR]);
         }
-      },
+        return ret;
+      }
       /**
-       * The setFastTimeout() method sets a fastTimer which executes a function once
-       * the timer expires.
-       * @param {Function} callback A function to be executed after the timer
-       * expires.
-       * @param {number} delay The time, in milliseconds that the timer should
-       * wait before the specified function or code is executed.
-       * @param {*} [arg] An optional argument to be passed to the callback function
-       * when the timer expires.
-       * @returns {FastTimer}
+       * Alias for {@link Minipass#off}
        */
-      setFastTimeout(callback, delay, arg) {
-        return new FastTimer(callback, delay, arg);
-      },
+      removeListener(ev, handler) {
+        return this.off(ev, handler);
+      }
       /**
-       * The clearTimeout method cancels an instantiated FastTimer previously
-       * created by calling setFastTimeout.
+       * Mostly identical to `EventEmitter.off`
        *
-       * @param {FastTimer} timeout
+       * If a 'data' event handler is removed, and it was the last consumer
+       * (ie, there are no pipe destinations or other 'data' event listeners),
+       * then the flow of data will stop until there is another consumer or
+       * {@link Minipass#resume} is explicitly called.
        */
-      clearFastTimeout(timeout) {
-        timeout.clear();
-      },
+      off(ev, handler) {
+        const ret = super.off(ev, handler);
+        if (ev === "data") {
+          this[DATALISTENERS] = this.listeners("data").length;
+          if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) {
+            this[FLOWING] = false;
+          }
+        }
+        return ret;
+      }
       /**
-       * The now method returns the value of the internal fast timer clock.
+       * Mostly identical to `EventEmitter.removeAllListeners`
        *
-       * @returns {number}
-       */
-      now() {
-        return fastNow;
-      },
-      /**
-       * Trigger the onTick function to process the fastTimers array.
-       * Exported for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
-       * @param {number} [delay=0] The delay in milliseconds to add to the now value.
+       * If all 'data' event handlers are removed, and they were the last consumer
+       * (ie, there are no pipe destinations), then the flow of data will stop
+       * until there is another consumer or {@link Minipass#resume} is explicitly
+       * called.
        */
-      tick(delay = 0) {
-        fastNow += delay - RESOLUTION_MS + 1;
-        onTick();
-        onTick();
-      },
+      removeAllListeners(ev) {
+        const ret = super.removeAllListeners(ev);
+        if (ev === "data" || ev === void 0) {
+          this[DATALISTENERS] = 0;
+          if (!this[DISCARDED] && !this[PIPES].length) {
+            this[FLOWING] = false;
+          }
+        }
+        return ret;
+      }
       /**
-       * Reset FastTimers.
-       * Exported for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
+       * true if the 'end' event has been emitted
        */
-      reset() {
-        fastNow = 0;
-        fastTimers.length = 0;
-        clearTimeout(fastNowTimeout);
-        fastNowTimeout = null;
-      },
+      get emittedEnd() {
+        return this[EMITTED_END];
+      }
+      [MAYBE_EMIT_END]() {
+        if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF]) {
+          this[EMITTING_END] = true;
+          this.emit("end");
+          this.emit("prefinish");
+          this.emit("finish");
+          if (this[CLOSED])
+            this.emit("close");
+          this[EMITTING_END] = false;
+        }
+      }
       /**
-       * Exporting for testing purposes only.
-       * Marking as deprecated to discourage any use outside of testing.
-       * @deprecated
+       * Mostly identical to `EventEmitter.emit`, with the following
+       * behavior differences to prevent data loss and unnecessary hangs:
+       *
+       * If the stream has been destroyed, and the event is something other
+       * than 'close' or 'error', then `false` is returned and no handlers
+       * are called.
+       *
+       * If the event is 'end', and has already been emitted, then the event
+       * is ignored. If the stream is in a paused or non-flowing state, then
+       * the event will be deferred until data flow resumes. If the stream is
+       * async, then handlers will be called on the next tick rather than
+       * immediately.
+       *
+       * If the event is 'close', and 'end' has not yet been emitted, then
+       * the event will be deferred until after 'end' is emitted.
+       *
+       * If the event is 'error', and an AbortSignal was provided for the stream,
+       * and there are no listeners, then the event is ignored, matching the
+       * behavior of node core streams in the presense of an AbortSignal.
+       *
+       * If the event is 'finish' or 'prefinish', then all listeners will be
+       * removed after emitting the event, to prevent double-firing.
        */
-      kFastTimer
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/connect.js
-var require_connect = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/connect.js"(exports2, module2) {
-    "use strict";
-    var net = require("node:net");
-    var assert5 = require("node:assert");
-    var util = require_util();
-    var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
-    var timers = require_timers();
-    function noop3() {
-    }
-    var tls;
-    var SessionCache;
-    if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
-      SessionCache = class WeakSessionCache {
-        constructor(maxCachedSessions) {
-          this._maxCachedSessions = maxCachedSessions;
-          this._sessionCache = /* @__PURE__ */ new Map();
-          this._sessionRegistry = new global.FinalizationRegistry((key) => {
-            if (this._sessionCache.size < this._maxCachedSessions) {
-              return;
-            }
-            const ref = this._sessionCache.get(key);
-            if (ref !== void 0 && ref.deref() === void 0) {
-              this._sessionCache.delete(key);
-            }
-          });
-        }
-        get(sessionKey) {
-          const ref = this._sessionCache.get(sessionKey);
-          return ref ? ref.deref() : null;
-        }
-        set(sessionKey, session) {
-          if (this._maxCachedSessions === 0) {
-            return;
-          }
-          this._sessionCache.set(sessionKey, new WeakRef(session));
-          this._sessionRegistry.register(session, sessionKey);
-        }
-      };
-    } else {
-      SessionCache = class SimpleSessionCache {
-        constructor(maxCachedSessions) {
-          this._maxCachedSessions = maxCachedSessions;
-          this._sessionCache = /* @__PURE__ */ new Map();
+      emit(ev, ...args) {
+        const data = args[0];
+        if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) {
+          return false;
+        } else if (ev === "data") {
+          return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data);
+        } else if (ev === "end") {
+          return this[EMITEND]();
+        } else if (ev === "close") {
+          this[CLOSED] = true;
+          if (!this[EMITTED_END] && !this[DESTROYED])
+            return false;
+          const ret2 = super.emit("close");
+          this.removeAllListeners("close");
+          return ret2;
+        } else if (ev === "error") {
+          this[EMITTED_ERROR] = data;
+          super.emit(ERROR, data);
+          const ret2 = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
+          this[MAYBE_EMIT_END]();
+          return ret2;
+        } else if (ev === "resume") {
+          const ret2 = super.emit("resume");
+          this[MAYBE_EMIT_END]();
+          return ret2;
+        } else if (ev === "finish" || ev === "prefinish") {
+          const ret2 = super.emit(ev);
+          this.removeAllListeners(ev);
+          return ret2;
         }
-        get(sessionKey) {
-          return this._sessionCache.get(sessionKey);
+        const ret = super.emit(ev, ...args);
+        this[MAYBE_EMIT_END]();
+        return ret;
+      }
+      [EMITDATA](data) {
+        for (const p of this[PIPES]) {
+          if (p.dest.write(data) === false)
+            this.pause();
         }
-        set(sessionKey, session) {
-          if (this._maxCachedSessions === 0) {
-            return;
-          }
-          if (this._sessionCache.size >= this._maxCachedSessions) {
-            const { value: oldestKey } = this._sessionCache.keys().next();
-            this._sessionCache.delete(oldestKey);
+        const ret = this[DISCARDED] ? false : super.emit("data", data);
+        this[MAYBE_EMIT_END]();
+        return ret;
+      }
+      [EMITEND]() {
+        if (this[EMITTED_END])
+          return false;
+        this[EMITTED_END] = true;
+        this.readable = false;
+        return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]();
+      }
+      [EMITEND2]() {
+        if (this[DECODER]) {
+          const data = this[DECODER].end();
+          if (data) {
+            for (const p of this[PIPES]) {
+              p.dest.write(data);
+            }
+            if (!this[DISCARDED])
+              super.emit("data", data);
           }
-          this._sessionCache.set(sessionKey, session);
         }
-      };
-    }
-    function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
-      if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
-        throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
-      }
-      const options = { path: socketPath, ...opts };
-      const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
-      timeout = timeout == null ? 1e4 : timeout;
-      allowH2 = allowH2 != null ? allowH2 : false;
-      return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
-        let socket;
-        if (protocol === "https:") {
-          if (!tls) {
-            tls = require("node:tls");
-          }
-          servername = servername || options.servername || util.getServerName(host) || null;
-          const sessionKey = servername || hostname;
-          assert5(sessionKey);
-          const session = customSession || sessionCache.get(sessionKey) || null;
-          port = port || 443;
-          socket = tls.connect({
-            highWaterMark: 16384,
-            // TLS in node can't have bigger HWM anyway...
-            ...options,
-            servername,
-            session,
-            localAddress,
-            // TODO(HTTP/2): Add support for h2c
-            ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
-            socket: httpSocket,
-            // upgrade socket connection
-            port,
-            host: hostname
-          });
-          socket.on("session", function(session2) {
-            sessionCache.set(sessionKey, session2);
-          });
-        } else {
-          assert5(!httpSocket, "httpSocket can only be sent on TLS update");
-          port = port || 80;
-          socket = net.connect({
-            highWaterMark: 64 * 1024,
-            // Same as nodejs fs streams.
-            ...options,
-            localAddress,
-            port,
-            host: hostname
-          });
+        for (const p of this[PIPES]) {
+          p.end();
         }
-        if (options.keepAlive == null || options.keepAlive) {
-          const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay;
-          socket.setKeepAlive(true, keepAliveInitialDelay);
-        }
-        const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port });
-        socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
-          queueMicrotask(clearConnectTimeout);
-          if (callback) {
-            const cb = callback;
-            callback = null;
-            cb(null, this);
-          }
-        }).on("error", function(err) {
-          queueMicrotask(clearConnectTimeout);
-          if (callback) {
-            const cb = callback;
-            callback = null;
-            cb(err);
-          }
-        });
-        return socket;
-      };
-    }
-    var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop3;
-      }
-      let s1 = null;
-      let s2 = null;
-      const fastTimer = timers.setFastTimeout(() => {
-        s1 = setImmediate(() => {
-          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts));
+        const ret = super.emit("end");
+        this.removeAllListeners("end");
+        return ret;
+      }
+      /**
+       * Return a Promise that resolves to an array of all emitted data once
+       * the stream ends.
+       */
+      async collect() {
+        const buf = Object.assign([], {
+          dataLength: 0
         });
-      }, opts.timeout);
-      return () => {
-        timers.clearFastTimeout(fastTimer);
-        clearImmediate(s1);
-        clearImmediate(s2);
-      };
-    } : (socketWeakRef, opts) => {
-      if (!opts.timeout) {
-        return noop3;
-      }
-      let s1 = null;
-      const fastTimer = timers.setFastTimeout(() => {
-        s1 = setImmediate(() => {
-          onConnectTimeout(socketWeakRef.deref(), opts);
+        if (!this[OBJECTMODE])
+          buf.dataLength = 0;
+        const p = this.promise();
+        this.on("data", (c) => {
+          buf.push(c);
+          if (!this[OBJECTMODE])
+            buf.dataLength += c.length;
         });
-      }, opts.timeout);
-      return () => {
-        timers.clearFastTimeout(fastTimer);
-        clearImmediate(s1);
-      };
-    };
-    function onConnectTimeout(socket, opts) {
-      if (socket == null) {
-        return;
-      }
-      let message = "Connect Timeout Error";
-      if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-        message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(", ")},`;
-      } else {
-        message += ` (attempted address: ${opts.hostname}:${opts.port},`;
+        await p;
+        return buf;
       }
-      message += ` timeout: ${opts.timeout}ms)`;
-      util.destroy(socket, new ConnectTimeoutError(message));
-    }
-    module2.exports = buildConnector;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/utils.js
-var require_utils = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/utils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.enumToMap = void 0;
-    function enumToMap(obj) {
-      const res = {};
-      Object.keys(obj).forEach((key) => {
-        const value = obj[key];
-        if (typeof value === "number") {
-          res[key] = value;
+      /**
+       * Return a Promise that resolves to the concatenation of all emitted data
+       * once the stream ends.
+       *
+       * Not allowed on objectMode streams.
+       */
+      async concat() {
+        if (this[OBJECTMODE]) {
+          throw new Error("cannot concat in objectMode");
         }
-      });
-      return res;
-    }
-    exports2.enumToMap = enumToMap;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/constants.js
-var require_constants3 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/constants.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
-    var utils_1 = require_utils();
-    var ERROR2;
-    (function(ERROR3) {
-      ERROR3[ERROR3["OK"] = 0] = "OK";
-      ERROR3[ERROR3["INTERNAL"] = 1] = "INTERNAL";
-      ERROR3[ERROR3["STRICT"] = 2] = "STRICT";
-      ERROR3[ERROR3["LF_EXPECTED"] = 3] = "LF_EXPECTED";
-      ERROR3[ERROR3["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
-      ERROR3[ERROR3["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
-      ERROR3[ERROR3["INVALID_METHOD"] = 6] = "INVALID_METHOD";
-      ERROR3[ERROR3["INVALID_URL"] = 7] = "INVALID_URL";
-      ERROR3[ERROR3["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
-      ERROR3[ERROR3["INVALID_VERSION"] = 9] = "INVALID_VERSION";
-      ERROR3[ERROR3["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
-      ERROR3[ERROR3["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
-      ERROR3[ERROR3["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
-      ERROR3[ERROR3["INVALID_STATUS"] = 13] = "INVALID_STATUS";
-      ERROR3[ERROR3["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
-      ERROR3[ERROR3["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
-      ERROR3[ERROR3["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
-      ERROR3[ERROR3["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
-      ERROR3[ERROR3["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
-      ERROR3[ERROR3["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
-      ERROR3[ERROR3["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
-      ERROR3[ERROR3["PAUSED"] = 21] = "PAUSED";
-      ERROR3[ERROR3["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
-      ERROR3[ERROR3["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
-      ERROR3[ERROR3["USER"] = 24] = "USER";
-    })(ERROR2 = exports2.ERROR || (exports2.ERROR = {}));
-    var TYPE;
-    (function(TYPE2) {
-      TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
-      TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
-      TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
-    })(TYPE = exports2.TYPE || (exports2.TYPE = {}));
-    var FLAGS;
-    (function(FLAGS2) {
-      FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
-      FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
-      FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
-      FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
-      FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
-      FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
-      FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
-      FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
-      FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
-    })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
-    var LENIENT_FLAGS;
-    (function(LENIENT_FLAGS2) {
-      LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
-      LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
-      LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
-    })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
-    var METHODS;
-    (function(METHODS2) {
-      METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
-      METHODS2[METHODS2["GET"] = 1] = "GET";
-      METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
-      METHODS2[METHODS2["POST"] = 3] = "POST";
-      METHODS2[METHODS2["PUT"] = 4] = "PUT";
-      METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
-      METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
-      METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
-      METHODS2[METHODS2["COPY"] = 8] = "COPY";
-      METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
-      METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
-      METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
-      METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
-      METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
-      METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
-      METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
-      METHODS2[METHODS2["BIND"] = 16] = "BIND";
-      METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
-      METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
-      METHODS2[METHODS2["ACL"] = 19] = "ACL";
-      METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
-      METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
-      METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
-      METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
-      METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
-      METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
-      METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
-      METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
-      METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
-      METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
-      METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
-      METHODS2[METHODS2["LINK"] = 31] = "LINK";
-      METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
-      METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
-      METHODS2[METHODS2["PRI"] = 34] = "PRI";
-      METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
-      METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
-      METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
-      METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
-      METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
-      METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
-      METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
-      METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
-      METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
-      METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
-      METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
-    })(METHODS = exports2.METHODS || (exports2.METHODS = {}));
-    exports2.METHODS_HTTP = [
-      METHODS.DELETE,
-      METHODS.GET,
-      METHODS.HEAD,
-      METHODS.POST,
-      METHODS.PUT,
-      METHODS.CONNECT,
-      METHODS.OPTIONS,
-      METHODS.TRACE,
-      METHODS.COPY,
-      METHODS.LOCK,
-      METHODS.MKCOL,
-      METHODS.MOVE,
-      METHODS.PROPFIND,
-      METHODS.PROPPATCH,
-      METHODS.SEARCH,
-      METHODS.UNLOCK,
-      METHODS.BIND,
-      METHODS.REBIND,
-      METHODS.UNBIND,
-      METHODS.ACL,
-      METHODS.REPORT,
-      METHODS.MKACTIVITY,
-      METHODS.CHECKOUT,
-      METHODS.MERGE,
-      METHODS["M-SEARCH"],
-      METHODS.NOTIFY,
-      METHODS.SUBSCRIBE,
-      METHODS.UNSUBSCRIBE,
-      METHODS.PATCH,
-      METHODS.PURGE,
-      METHODS.MKCALENDAR,
-      METHODS.LINK,
-      METHODS.UNLINK,
-      METHODS.PRI,
-      // TODO(indutny): should we allow it with HTTP?
-      METHODS.SOURCE
-    ];
-    exports2.METHODS_ICE = [
-      METHODS.SOURCE
-    ];
-    exports2.METHODS_RTSP = [
-      METHODS.OPTIONS,
-      METHODS.DESCRIBE,
-      METHODS.ANNOUNCE,
-      METHODS.SETUP,
-      METHODS.PLAY,
-      METHODS.PAUSE,
-      METHODS.TEARDOWN,
-      METHODS.GET_PARAMETER,
-      METHODS.SET_PARAMETER,
-      METHODS.REDIRECT,
-      METHODS.RECORD,
-      METHODS.FLUSH,
-      // For AirPlay
-      METHODS.GET,
-      METHODS.POST
-    ];
-    exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
-    exports2.H_METHOD_MAP = {};
-    Object.keys(exports2.METHOD_MAP).forEach((key) => {
-      if (/^H/.test(key)) {
-        exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
-      }
-    });
-    var FINISH;
-    (function(FINISH2) {
-      FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
-      FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
-      FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
-    })(FINISH = exports2.FINISH || (exports2.FINISH = {}));
-    exports2.ALPHA = [];
-    for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
-      exports2.ALPHA.push(String.fromCharCode(i));
-      exports2.ALPHA.push(String.fromCharCode(i + 32));
-    }
-    exports2.NUM_MAP = {
-      0: 0,
-      1: 1,
-      2: 2,
-      3: 3,
-      4: 4,
-      5: 5,
-      6: 6,
-      7: 7,
-      8: 8,
-      9: 9
-    };
-    exports2.HEX_MAP = {
-      0: 0,
-      1: 1,
-      2: 2,
-      3: 3,
-      4: 4,
-      5: 5,
-      6: 6,
-      7: 7,
-      8: 8,
-      9: 9,
-      A: 10,
-      B: 11,
-      C: 12,
-      D: 13,
-      E: 14,
-      F: 15,
-      a: 10,
-      b: 11,
-      c: 12,
-      d: 13,
-      e: 14,
-      f: 15
-    };
-    exports2.NUM = [
-      "0",
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-      "6",
-      "7",
-      "8",
-      "9"
-    ];
-    exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
-    exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
-    exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
-    exports2.STRICT_URL_CHAR = [
-      "!",
-      '"',
-      "$",
-      "%",
-      "&",
-      "'",
-      "(",
-      ")",
-      "*",
-      "+",
-      ",",
-      "-",
-      ".",
-      "/",
-      ":",
-      ";",
-      "<",
-      "=",
-      ">",
-      "@",
-      "[",
-      "\\",
-      "]",
-      "^",
-      "_",
-      "`",
-      "{",
-      "|",
-      "}",
-      "~"
-    ].concat(exports2.ALPHANUM);
-    exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat(["	", "\f"]);
-    for (let i = 128; i <= 255; i++) {
-      exports2.URL_CHAR.push(i);
-    }
-    exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
-    exports2.STRICT_TOKEN = [
-      "!",
-      "#",
-      "$",
-      "%",
-      "&",
-      "'",
-      "*",
-      "+",
-      "-",
-      ".",
-      "^",
-      "_",
-      "`",
-      "|",
-      "~"
-    ].concat(exports2.ALPHANUM);
-    exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
-    exports2.HEADER_CHARS = ["	"];
-    for (let i = 32; i <= 255; i++) {
-      if (i !== 127) {
-        exports2.HEADER_CHARS.push(i);
+        const buf = await this.collect();
+        return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
       }
-    }
-    exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
-    exports2.MAJOR = exports2.NUM_MAP;
-    exports2.MINOR = exports2.MAJOR;
-    var HEADER_STATE;
-    (function(HEADER_STATE2) {
-      HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
-      HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
-      HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
-      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
-      HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
-      HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
-      HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
-      HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
-      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
-    })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
-    exports2.SPECIAL_HEADERS = {
-      "connection": HEADER_STATE.CONNECTION,
-      "content-length": HEADER_STATE.CONTENT_LENGTH,
-      "proxy-connection": HEADER_STATE.CONNECTION,
-      "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
-      "upgrade": HEADER_STATE.UPGRADE
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js
-var require_llhttp_wasm = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) {
-    "use strict";
-    var { Buffer: Buffer3 } = require("node:buffer");
-    module2.exports = Buffer3.from("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", "base64");
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
-var require_llhttp_simd_wasm = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) {
-    "use strict";
-    var { Buffer: Buffer3 } = require("node:buffer");
-    module2.exports = Buffer3.from("AGFzbQEAAAABJwdgAX8Bf2ADf39/AX9gAX8AYAJ/fwBgBH9/f38Bf2AAAGADf39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQAEA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAAy0sBQYAAAIAAAAAAAACAQIAAgICAAADAAAAAAMDAwMBAQEBAQEBAQEAAAIAAAAEBQFwARISBQMBAAIGCAF/AUGA1AQLB9EFIgZtZW1vcnkCAAtfaW5pdGlhbGl6ZQAIGV9faW5kaXJlY3RfZnVuY3Rpb25fdGFibGUBAAtsbGh0dHBfaW5pdAAJGGxsaHR0cF9zaG91bGRfa2VlcF9hbGl2ZQAvDGxsaHR0cF9hbGxvYwALBm1hbGxvYwAxC2xsaHR0cF9mcmVlAAwEZnJlZQAMD2xsaHR0cF9nZXRfdHlwZQANFWxsaHR0cF9nZXRfaHR0cF9tYWpvcgAOFWxsaHR0cF9nZXRfaHR0cF9taW5vcgAPEWxsaHR0cF9nZXRfbWV0aG9kABAWbGxodHRwX2dldF9zdGF0dXNfY29kZQAREmxsaHR0cF9nZXRfdXBncmFkZQASDGxsaHR0cF9yZXNldAATDmxsaHR0cF9leGVjdXRlABQUbGxodHRwX3NldHRpbmdzX2luaXQAFQ1sbGh0dHBfZmluaXNoABYMbGxodHRwX3BhdXNlABcNbGxodHRwX3Jlc3VtZQAYG2xsaHR0cF9yZXN1bWVfYWZ0ZXJfdXBncmFkZQAZEGxsaHR0cF9nZXRfZXJybm8AGhdsbGh0dHBfZ2V0X2Vycm9yX3JlYXNvbgAbF2xsaHR0cF9zZXRfZXJyb3JfcmVhc29uABwUbGxodHRwX2dldF9lcnJvcl9wb3MAHRFsbGh0dHBfZXJybm9fbmFtZQAeEmxsaHR0cF9tZXRob2RfbmFtZQAfEmxsaHR0cF9zdGF0dXNfbmFtZQAgGmxsaHR0cF9zZXRfbGVuaWVudF9oZWFkZXJzACEhbGxodHRwX3NldF9sZW5pZW50X2NodW5rZWRfbGVuZ3RoACIdbGxodHRwX3NldF9sZW5pZW50X2tlZXBfYWxpdmUAIyRsbGh0dHBfc2V0X2xlbmllbnRfdHJhbnNmZXJfZW5jb2RpbmcAJBhsbGh0dHBfbWVzc2FnZV9uZWVkc19lb2YALgkXAQBBAQsRAQIDBAUKBgcrLSwqKSglJyYK77MCLBYAQYjQACgCAARAAAtBiNAAQQE2AgALFAAgABAwIAAgAjYCOCAAIAE6ACgLFAAgACAALwEyIAAtAC4gABAvEAALHgEBf0HAABAyIgEQMCABQYAINgI4IAEgADoAKCABC48MAQd/AkAgAEUNACAAQQhrIgEgAEEEaygCACIAQXhxIgRqIQUCQCAAQQFxDQAgAEEDcUUNASABIAEoAgAiAGsiAUGc0AAoAgBJDQEgACAEaiEEAkACQEGg0AAoAgAgAUcEQCAAQf8BTQRAIABBA3YhAyABKAIIIgAgASgCDCICRgRAQYzQAEGM0AAoAgBBfiADd3E2AgAMBQsgAiAANgIIIAAgAjYCDAwECyABKAIYIQYgASABKAIMIgBHBEAgACABKAIIIgI2AgggAiAANgIMDAMLIAFBFGoiAygCACICRQRAIAEoAhAiAkUNAiABQRBqIQMLA0AgAyEHIAIiAEEUaiIDKAIAIgINACAAQRBqIQMgACgCECICDQALIAdBADYCAAwCCyAFKAIEIgBBA3FBA0cNAiAFIABBfnE2AgRBlNAAIAQ2AgAgBSAENgIAIAEgBEEBcjYCBAwDC0EAIQALIAZFDQACQCABKAIcIgJBAnRBvNIAaiIDKAIAIAFGBEAgAyAANgIAIAANAUGQ0ABBkNAAKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgAUYbaiAANgIAIABFDQELIAAgBjYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABQRRqKAIAIgJFDQAgAEEUaiACNgIAIAIgADYCGAsgASAFTw0AIAUoAgQiAEEBcUUNAAJAAkACQAJAIABBAnFFBEBBpNAAKAIAIAVGBEBBpNAAIAE2AgBBmNAAQZjQACgCACAEaiIANgIAIAEgAEEBcjYCBCABQaDQACgCAEcNBkGU0ABBADYCAEGg0ABBADYCAAwGC0Gg0AAoAgAgBUYEQEGg0AAgATYCAEGU0ABBlNAAKAIAIARqIgA2AgAgASAAQQFyNgIEIAAgAWogADYCAAwGCyAAQXhxIARqIQQgAEH/AU0EQCAAQQN2IQMgBSgCCCIAIAUoAgwiAkYEQEGM0ABBjNAAKAIAQX4gA3dxNgIADAULIAIgADYCCCAAIAI2AgwMBAsgBSgCGCEGIAUgBSgCDCIARwRAQZzQACgCABogACAFKAIIIgI2AgggAiAANgIMDAMLIAVBFGoiAygCACICRQRAIAUoAhAiAkUNAiAFQRBqIQMLA0AgAyEHIAIiAEEUaiIDKAIAIgINACAAQRBqIQMgACgCECICDQALIAdBADYCAAwCCyAFIABBfnE2AgQgASAEaiAENgIAIAEgBEEBcjYCBAwDC0EAIQALIAZFDQACQCAFKAIcIgJBAnRBvNIAaiIDKAIAIAVGBEAgAyAANgIAIAANAUGQ0ABBkNAAKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgBUYbaiAANgIAIABFDQELIAAgBjYCGCAFKAIQIgIEQCAAIAI2AhAgAiAANgIYCyAFQRRqKAIAIgJFDQAgAEEUaiACNgIAIAIgADYCGAsgASAEaiAENgIAIAEgBEEBcjYCBCABQaDQACgCAEcNAEGU0AAgBDYCAAwBCyAEQf8BTQRAIARBeHFBtNAAaiEAAn9BjNAAKAIAIgJBASAEQQN2dCIDcUUEQEGM0AAgAiADcjYCACAADAELIAAoAggLIgIgATYCDCAAIAE2AgggASAANgIMIAEgAjYCCAwBC0EfIQIgBEH///8HTQRAIARBJiAEQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAgsgASACNgIcIAFCADcCECACQQJ0QbzSAGohAAJAQZDQACgCACIDQQEgAnQiB3FFBEAgACABNgIAQZDQACADIAdyNgIAIAEgADYCGCABIAE2AgggASABNgIMDAELIARBGSACQQF2a0EAIAJBH0cbdCECIAAoAgAhAAJAA0AgACIDKAIEQXhxIARGDQEgAkEddiEAIAJBAXQhAiADIABBBHFqQRBqIgcoAgAiAA0ACyAHIAE2AgAgASADNgIYIAEgATYCDCABIAE2AggMAQsgAygCCCIAIAE2AgwgAyABNgIIIAFBADYCGCABIAM2AgwgASAANgIIC0Gs0ABBrNAAKAIAQQFrIgBBfyAAGzYCAAsLBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LQAEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABAwIAAgBDYCOCAAIAM6ACggACACOgAtIAAgATYCGAu74gECB38DfiABIAJqIQQCQCAAIgIoAgwiAA0AIAIoAgQEQCACIAE2AgQLIwBBEGsiCCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAIoAhwiA0EBaw7dAdoBAdkBAgMEBQYHCAkKCwwNDtgBDxDXARES1gETFBUWFxgZGhvgAd8BHB0e1QEfICEiIyQl1AEmJygpKiss0wHSAS0u0QHQAS8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRtsBR0hJSs8BzgFLzQFMzAFNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AAYEBggGDAYQBhQGGAYcBiAGJAYoBiwGMAY0BjgGPAZABkQGSAZMBlAGVAZYBlwGYAZkBmgGbAZwBnQGeAZ8BoAGhAaIBowGkAaUBpgGnAagBqQGqAasBrAGtAa4BrwGwAbEBsgGzAbQBtQG2AbcBywHKAbgByQG5AcgBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgEA3AELQQAMxgELQQ4MxQELQQ0MxAELQQ8MwwELQRAMwgELQRMMwQELQRQMwAELQRUMvwELQRYMvgELQRgMvQELQRkMvAELQRoMuwELQRsMugELQRwMuQELQR0MuAELQQgMtwELQR4MtgELQSAMtQELQR8MtAELQQcMswELQSEMsgELQSIMsQELQSMMsAELQSQMrwELQRIMrgELQREMrQELQSUMrAELQSYMqwELQScMqgELQSgMqQELQcMBDKgBC0EqDKcBC0ErDKYBC0EsDKUBC0EtDKQBC0EuDKMBC0EvDKIBC0HEAQyhAQtBMAygAQtBNAyfAQtBDAyeAQtBMQydAQtBMgycAQtBMwybAQtBOQyaAQtBNQyZAQtBxQEMmAELQQsMlwELQToMlgELQTYMlQELQQoMlAELQTcMkwELQTgMkgELQTwMkQELQTsMkAELQT0MjwELQQkMjgELQSkMjQELQT4MjAELQT8MiwELQcAADIoBC0HBAAyJAQtBwgAMiAELQcMADIcBC0HEAAyGAQtBxQAMhQELQcYADIQBC0EXDIMBC0HHAAyCAQtByAAMgQELQckADIABC0HKAAx/C0HLAAx+C0HNAAx9C0HMAAx8C0HOAAx7C0HPAAx6C0HQAAx5C0HRAAx4C0HSAAx3C0HTAAx2C0HUAAx1C0HWAAx0C0HVAAxzC0EGDHILQdcADHELQQUMcAtB2AAMbwtBBAxuC0HZAAxtC0HaAAxsC0HbAAxrC0HcAAxqC0EDDGkLQd0ADGgLQd4ADGcLQd8ADGYLQeEADGULQeAADGQLQeIADGMLQeMADGILQQIMYQtB5AAMYAtB5QAMXwtB5gAMXgtB5wAMXQtB6AAMXAtB6QAMWwtB6gAMWgtB6wAMWQtB7AAMWAtB7QAMVwtB7gAMVgtB7wAMVQtB8AAMVAtB8QAMUwtB8gAMUgtB8wAMUQtB9AAMUAtB9QAMTwtB9gAMTgtB9wAMTQtB+AAMTAtB+QAMSwtB+gAMSgtB+wAMSQtB/AAMSAtB/QAMRwtB/gAMRgtB/wAMRQtBgAEMRAtBgQEMQwtBggEMQgtBgwEMQQtBhAEMQAtBhQEMPwtBhgEMPgtBhwEMPQtBiAEMPAtBiQEMOwtBigEMOgtBiwEMOQtBjAEMOAtBjQEMNwtBjgEMNgtBjwEMNQtBkAEMNAtBkQEMMwtBkgEMMgtBkwEMMQtBlAEMMAtBlQEMLwtBlgEMLgtBlwEMLQtBmAEMLAtBmQEMKwtBmgEMKgtBmwEMKQtBnAEMKAtBnQEMJwtBngEMJgtBnwEMJQtBoAEMJAtBoQEMIwtBogEMIgtBowEMIQtBpAEMIAtBpQEMHwtBpgEMHgtBpwEMHQtBqAEMHAtBqQEMGwtBqgEMGgtBqwEMGQtBrAEMGAtBrQEMFwtBrgEMFgtBAQwVC0GvAQwUC0GwAQwTC0GxAQwSC0GzAQwRC0GyAQwQC0G0AQwPC0G1AQwOC0G2AQwNC0G3AQwMC0G4AQwLC0G5AQwKC0G6AQwJC0G7AQwIC0HGAQwHC0G8AQwGC0G9AQwFC0G+AQwEC0G/AQwDC0HAAQwCC0HCAQwBC0HBAQshAwNAAkACQAJAAkACQAJAAkACQAJAIAICfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAgJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADDsYBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHyAhIyUmKCorLC8wMTIzNDU2Nzk6Ozw9lANAQkRFRklLTk9QUVJTVFVWWFpbXF1eX2BhYmNkZWZnaGpsb3Bxc3V2eHl6e3x/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AbgBuQG6AbsBvAG9Ab4BvwHAAcEBwgHDAcQBxQHGAccByAHJAcsBzAHNAc4BzwGKA4kDiAOHA4QDgwOAA/sC+gL5AvgC9wL0AvMC8gLLAsECsALZAQsgASAERw3wAkHdASEDDLMDCyABIARHDcgBQcMBIQMMsgMLIAEgBEcNe0H3ACEDDLEDCyABIARHDXBB7wAhAwywAwsgASAERw1pQeoAIQMMrwMLIAEgBEcNZUHoACEDDK4DCyABIARHDWJB5gAhAwytAwsgASAERw0aQRghAwysAwsgASAERw0VQRIhAwyrAwsgASAERw1CQcUAIQMMqgMLIAEgBEcNNEE/IQMMqQMLIAEgBEcNMkE8IQMMqAMLIAEgBEcNK0ExIQMMpwMLIAItAC5BAUYNnwMMwQILQQAhAAJAAkACQCACLQAqRQ0AIAItACtFDQAgAi8BMCIDQQJxRQ0BDAILIAIvATAiA0EBcUUNAQtBASEAIAItAChBAUYNACACLwEyIgVB5ABrQeQASQ0AIAVBzAFGDQAgBUGwAkYNACADQcAAcQ0AQQAhACADQYgEcUGABEYNACADQShxQQBHIQALIAJBADsBMCACQQA6AC8gAEUN3wIgAkIANwMgDOACC0EAIQACQCACKAI4IgNFDQAgAygCLCIDRQ0AIAIgAxEAACEACyAARQ3MASAAQRVHDd0CIAJBBDYCHCACIAE2AhQgAkGwGDYCECACQRU2AgxBACEDDKQDCyABIARGBEBBBiEDDKQDCyABQQFqIQFBACEAAkAgAigCOCIDRQ0AIAMoAlQiA0UNACACIAMRAAAhAAsgAA3ZAgwcCyACQgA3AyBBEiEDDIkDCyABIARHDRZBHSEDDKEDCyABIARHBEAgAUEBaiEBQRAhAwyIAwtBByEDDKADCyACIAIpAyAiCiAEIAFrrSILfSIMQgAgCiAMWhs3AyAgCiALWA3UAkEIIQMMnwMLIAEgBEcEQCACQQk2AgggAiABNgIEQRQhAwyGAwtBCSEDDJ4DCyACKQMgQgBSDccBIAIgAi8BMEGAAXI7ATAMQgsgASAERw0/QdAAIQMMnAMLIAEgBEYEQEELIQMMnAMLIAFBAWohAUEAIQACQCACKAI4IgNFDQAgAygCUCIDRQ0AIAIgAxEAACEACyAADc8CDMYBC0EAIQACQCACKAI4IgNFDQAgAygCSCIDRQ0AIAIgAxEAACEACyAARQ3GASAAQRVHDc0CIAJBCzYCHCACIAE2AhQgAkGCGTYCECACQRU2AgxBACEDDJoDC0EAIQACQCACKAI4IgNFDQAgAygCSCIDRQ0AIAIgAxEAACEACyAARQ0MIABBFUcNygIgAkEaNgIcIAIgATYCFCACQYIZNgIQIAJBFTYCDEEAIQMMmQMLQQAhAAJAIAIoAjgiA0UNACADKAJMIgNFDQAgAiADEQAAIQALIABFDcQBIABBFUcNxwIgAkELNgIcIAIgATYCFCACQZEXNgIQIAJBFTYCDEEAIQMMmAMLIAEgBEYEQEEPIQMMmAMLIAEtAAAiAEE7Rg0HIABBDUcNxAIgAUEBaiEBDMMBC0EAIQACQCACKAI4IgNFDQAgAygCTCIDRQ0AIAIgAxEAACEACyAARQ3DASAAQRVHDcICIAJBDzYCHCACIAE2AhQgAkGRFzYCECACQRU2AgxBACEDDJYDCwNAIAEtAABB8DVqLQAAIgBBAUcEQCAAQQJHDcECIAIoAgQhAEEAIQMgAkEANgIEIAIgACABQQFqIgEQLSIADcICDMUBCyAEIAFBAWoiAUcNAAtBEiEDDJUDC0EAIQACQCACKAI4IgNFDQAgAygCTCIDRQ0AIAIgAxEAACEACyAARQ3FASAAQRVHDb0CIAJBGzYCHCACIAE2AhQgAkGRFzYCECACQRU2AgxBACEDDJQDCyABIARGBEBBFiEDDJQDCyACQQo2AgggAiABNgIEQQAhAAJAIAIoAjgiA0UNACADKAJIIgNFDQAgAiADEQAAIQALIABFDcIBIABBFUcNuQIgAkEVNgIcIAIgATYCFCACQYIZNgIQIAJBFTYCDEEAIQMMkwMLIAEgBEcEQANAIAEtAABB8DdqLQAAIgBBAkcEQAJAIABBAWsOBMQCvQIAvgK9AgsgAUEBaiEBQQghAwz8AgsgBCABQQFqIgFHDQALQRUhAwyTAwtBFSEDDJIDCwNAIAEtAABB8DlqLQAAIgBBAkcEQCAAQQFrDgTFArcCwwK4ArcCCyAEIAFBAWoiAUcNAAtBGCEDDJEDCyABIARHBEAgAkELNgIIIAIgATYCBEEHIQMM+AILQRkhAwyQAwsgAUEBaiEBDAILIAEgBEYEQEEaIQMMjwMLAkAgAS0AAEENaw4UtQG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwG/Ab8BvwEAvwELQQAhAyACQQA2AhwgAkGvCzYCECACQQI2AgwgAiABQQFqNgIUDI4DCyABIARGBEBBGyEDDI4DCyABLQAAIgBBO0cEQCAAQQ1HDbECIAFBAWohAQy6AQsgAUEBaiEBC0EiIQMM8wILIAEgBEYEQEEcIQMMjAMLQgAhCgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEwaw43wQLAAgABAgMEBQYH0AHQAdAB0AHQAdAB0AEICQoLDA3QAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdAB0AHQAdABDg8QERIT0AELQgIhCgzAAgtCAyEKDL8CC0IEIQoMvgILQgUhCgy9AgtCBiEKDLwCC0IHIQoMuwILQgghCgy6AgtCCSEKDLkCC0IKIQoMuAILQgshCgy3AgtCDCEKDLYCC0INIQoMtQILQg4hCgy0AgtCDyEKDLMCC0IKIQoMsgILQgshCgyxAgtCDCEKDLACC0INIQoMrwILQg4hCgyuAgtCDyEKDK0CC0IAIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBMGsON8ACvwIAAQIDBAUGB74CvgK+Ar4CvgK+Ar4CCAkKCwwNvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ar4CvgK+Ag4PEBESE74CC0ICIQoMvwILQgMhCgy+AgtCBCEKDL0CC0IFIQoMvAILQgYhCgy7AgtCByEKDLoCC0IIIQoMuQILQgkhCgy4AgtCCiEKDLcCC0ILIQoMtgILQgwhCgy1AgtCDSEKDLQCC0IOIQoMswILQg8hCgyyAgtCCiEKDLECC0ILIQoMsAILQgwhCgyvAgtCDSEKDK4CC0IOIQoMrQILQg8hCgysAgsgAiACKQMgIgogBCABa60iC30iDEIAIAogDFobNwMgIAogC1gNpwJBHyEDDIkDCyABIARHBEAgAkEJNgIIIAIgATYCBEElIQMM8AILQSAhAwyIAwtBASEFIAIvATAiA0EIcUUEQCACKQMgQgBSIQULAkAgAi0ALgRAQQEhACACLQApQQVGDQEgA0HAAHFFIAVxRQ0BC0EAIQAgA0HAAHENAEECIQAgA0EIcQ0AIANBgARxBEACQCACLQAoQQFHDQAgAi0ALUEKcQ0AQQUhAAwCC0EEIQAMAQsgA0EgcUUEQAJAIAItAChBAUYNACACLwEyIgBB5ABrQeQASQ0AIABBzAFGDQAgAEGwAkYNAEEEIQAgA0EocUUNAiADQYgEcUGABEYNAgtBACEADAELQQBBAyACKQMgUBshAAsgAEEBaw4FvgIAsAEBpAKhAgtBESEDDO0CCyACQQE6AC8MhAMLIAEgBEcNnQJBJCEDDIQDCyABIARHDRxBxgAhAwyDAwtBACEAAkAgAigCOCIDRQ0AIAMoAkQiA0UNACACIAMRAAAhAAsgAEUNJyAAQRVHDZgCIAJB0AA2AhwgAiABNgIUIAJBkRg2AhAgAkEVNgIMQQAhAwyCAwsgASAERgRAQSghAwyCAwtBACEDIAJBADYCBCACQQw2AgggAiABIAEQKiIARQ2UAiACQSc2AhwgAiABNgIUIAIgADYCDAyBAwsgASAERgRAQSkhAwyBAwsgAS0AACIAQSBGDRMgAEEJRw2VAiABQQFqIQEMFAsgASAERwRAIAFBAWohAQwWC0EqIQMM/wILIAEgBEYEQEErIQMM/wILIAEtAAAiAEEJRyAAQSBHcQ2QAiACLQAsQQhHDd0CIAJBADoALAzdAgsgASAERgRAQSwhAwz+AgsgAS0AAEEKRw2OAiABQQFqIQEMsAELIAEgBEcNigJBLyEDDPwCCwNAIAEtAAAiAEEgRwRAIABBCmsOBIQCiAKIAoQChgILIAQgAUEBaiIBRw0AC0ExIQMM+wILQTIhAyABIARGDfoCIAIoAgAiACAEIAFraiEHIAEgAGtBA2ohBgJAA0AgAEHwO2otAAAgAS0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDQEgAEEDRgRAQQYhAQziAgsgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAc2AgAM+wILIAJBADYCAAyGAgtBMyEDIAQgASIARg35AiAEIAFrIAIoAgAiAWohByAAIAFrQQhqIQYCQANAIAFB9DtqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0BIAFBCEYEQEEFIQEM4QILIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADPoCCyACQQA2AgAgACEBDIUCC0E0IQMgBCABIgBGDfgCIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgJAA0AgAUHQwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0BIAFBBUYEQEEHIQEM4AILIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADPkCCyACQQA2AgAgACEBDIQCCyABIARHBEADQCABLQAAQYA+ai0AACIAQQFHBEAgAEECRg0JDIECCyAEIAFBAWoiAUcNAAtBMCEDDPgCC0EwIQMM9wILIAEgBEcEQANAIAEtAAAiAEEgRwRAIABBCmsOBP8B/gH+Af8B/gELIAQgAUEBaiIBRw0AC0E4IQMM9wILQTghAwz2AgsDQCABLQAAIgBBIEcgAEEJR3EN9gEgBCABQQFqIgFHDQALQTwhAwz1AgsDQCABLQAAIgBBIEcEQAJAIABBCmsOBPkBBAT5AQALIABBLEYN9QEMAwsgBCABQQFqIgFHDQALQT8hAwz0AgtBwAAhAyABIARGDfMCIAIoAgAiACAEIAFraiEFIAEgAGtBBmohBgJAA0AgAEGAQGstAAAgAS0AAEEgckcNASAAQQZGDdsCIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPQCCyACQQA2AgALQTYhAwzZAgsgASAERgRAQcEAIQMM8gILIAJBDDYCCCACIAE2AgQgAi0ALEEBaw4E+wHuAewB6wHUAgsgAUEBaiEBDPoBCyABIARHBEADQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxIgBBCUYNACAAQSBGDQACQAJAAkACQCAAQeMAaw4TAAMDAwMDAwMBAwMDAwMDAwMDAgMLIAFBAWohAUExIQMM3AILIAFBAWohAUEyIQMM2wILIAFBAWohAUEzIQMM2gILDP4BCyAEIAFBAWoiAUcNAAtBNSEDDPACC0E1IQMM7wILIAEgBEcEQANAIAEtAABBgDxqLQAAQQFHDfcBIAQgAUEBaiIBRw0AC0E9IQMM7wILQT0hAwzuAgtBACEAAkAgAigCOCIDRQ0AIAMoAkAiA0UNACACIAMRAAAhAAsgAEUNASAAQRVHDeYBIAJBwgA2AhwgAiABNgIUIAJB4xg2AhAgAkEVNgIMQQAhAwztAgsgAUEBaiEBC0E8IQMM0gILIAEgBEYEQEHCACEDDOsCCwJAA0ACQCABLQAAQQlrDhgAAswCzALRAswCzALMAswCzALMAswCzALMAswCzALMAswCzALMAswCzALMAgDMAgsgBCABQQFqIgFHDQALQcIAIQMM6wILIAFBAWohASACLQAtQQFxRQ3+AQtBLCEDDNACCyABIARHDd4BQcQAIQMM6AILA0AgAS0AAEGQwABqLQAAQQFHDZwBIAQgAUEBaiIBRw0AC0HFACEDDOcCCyABLQAAIgBBIEYN/gEgAEE6Rw3AAiACKAIEIQBBACEDIAJBADYCBCACIAAgARApIgAN3gEM3QELQccAIQMgBCABIgBGDeUCIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgNAIAFBkMIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNvwIgAUEFRg3CAiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBzYCAAzlAgtByAAhAyAEIAEiAEYN5AIgBCABayACKAIAIgFqIQcgACABa0EJaiEGA0AgAUGWwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw2+AkECIAFBCUYNwgIaIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADOQCCyABIARGBEBByQAhAwzkAgsCQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxQe4Aaw4HAL8CvwK/Ar8CvwIBvwILIAFBAWohAUE+IQMMywILIAFBAWohAUE/IQMMygILQcoAIQMgBCABIgBGDeICIAQgAWsgAigCACIBaiEGIAAgAWtBAWohBwNAIAFBoMIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNvAIgAUEBRg2+AiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBjYCAAziAgtBywAhAyAEIAEiAEYN4QIgBCABayACKAIAIgFqIQcgACABa0EOaiEGA0AgAUGiwgBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw27AiABQQ5GDb4CIAFBAWohASAEIABBAWoiAEcNAAsgAiAHNgIADOECC0HMACEDIAQgASIARg3gAiAEIAFrIAIoAgAiAWohByAAIAFrQQ9qIQYDQCABQcDCAGotAAAgAC0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDboCQQMgAUEPRg2+AhogAUEBaiEBIAQgAEEBaiIARw0ACyACIAc2AgAM4AILQc0AIQMgBCABIgBGDd8CIAQgAWsgAigCACIBaiEHIAAgAWtBBWohBgNAIAFB0MIAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNuQJBBCABQQVGDb0CGiABQQFqIQEgBCAAQQFqIgBHDQALIAIgBzYCAAzfAgsgASAERgRAQc4AIQMM3wILAkACQAJAAkAgAS0AACIAQSByIAAgAEHBAGtB/wFxQRpJG0H/AXFB4wBrDhMAvAK8ArwCvAK8ArwCvAK8ArwCvAK8ArwCAbwCvAK8AgIDvAILIAFBAWohAUHBACEDDMgCCyABQQFqIQFBwgAhAwzHAgsgAUEBaiEBQcMAIQMMxgILIAFBAWohAUHEACEDDMUCCyABIARHBEAgAkENNgIIIAIgATYCBEHFACEDDMUCC0HPACEDDN0CCwJAAkAgAS0AAEEKaw4EAZABkAEAkAELIAFBAWohAQtBKCEDDMMCCyABIARGBEBB0QAhAwzcAgsgAS0AAEEgRw0AIAFBAWohASACLQAtQQFxRQ3QAQtBFyEDDMECCyABIARHDcsBQdIAIQMM2QILQdMAIQMgASAERg3YAiACKAIAIgAgBCABa2ohBiABIABrQQFqIQUDQCABLQAAIABB1sIAai0AAEcNxwEgAEEBRg3KASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBjYCAAzYAgsgASAERgRAQdUAIQMM2AILIAEtAABBCkcNwgEgAUEBaiEBDMoBCyABIARGBEBB1gAhAwzXAgsCQAJAIAEtAABBCmsOBADDAcMBAcMBCyABQQFqIQEMygELIAFBAWohAUHKACEDDL0CC0EAIQACQCACKAI4IgNFDQAgAygCPCIDRQ0AIAIgAxEAACEACyAADb8BQc0AIQMMvAILIAItAClBIkYNzwIMiQELIAQgASIFRgRAQdsAIQMM1AILQQAhAEEBIQFBASEGQQAhAwJAAn8CQAJAAkACQAJAAkACQCAFLQAAQTBrDgrFAcQBAAECAwQFBgjDAQtBAgwGC0EDDAULQQQMBAtBBQwDC0EGDAILQQcMAQtBCAshA0EAIQFBACEGDL0BC0EJIQNBASEAQQAhAUEAIQYMvAELIAEgBEYEQEHdACEDDNMCCyABLQAAQS5HDbgBIAFBAWohAQyIAQsgASAERw22AUHfACEDDNECCyABIARHBEAgAkEONgIIIAIgATYCBEHQACEDDLgCC0HgACEDDNACC0HhACEDIAEgBEYNzwIgAigCACIAIAQgAWtqIQUgASAAa0EDaiEGA0AgAS0AACAAQeLCAGotAABHDbEBIABBA0YNswEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMzwILQeIAIQMgASAERg3OAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYDQCABLQAAIABB5sIAai0AAEcNsAEgAEECRg2vASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAzOAgtB4wAhAyABIARGDc0CIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgNAIAEtAAAgAEHpwgBqLQAARw2vASAAQQNGDa0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADM0CCyABIARGBEBB5QAhAwzNAgsgAUEBaiEBQQAhAAJAIAIoAjgiA0UNACADKAIwIgNFDQAgAiADEQAAIQALIAANqgFB1gAhAwyzAgsgASAERwRAA0AgAS0AACIAQSBHBEACQAJAAkAgAEHIAGsOCwABswGzAbMBswGzAbMBswGzAQKzAQsgAUEBaiEBQdIAIQMMtwILIAFBAWohAUHTACEDDLYCCyABQQFqIQFB1AAhAwy1AgsgBCABQQFqIgFHDQALQeQAIQMMzAILQeQAIQMMywILA0AgAS0AAEHwwgBqLQAAIgBBAUcEQCAAQQJrDgOnAaYBpQGkAQsgBCABQQFqIgFHDQALQeYAIQMMygILIAFBAWogASAERw0CGkHnACEDDMkCCwNAIAEtAABB8MQAai0AACIAQQFHBEACQCAAQQJrDgSiAaEBoAEAnwELQdcAIQMMsQILIAQgAUEBaiIBRw0AC0HoACEDDMgCCyABIARGBEBB6QAhAwzIAgsCQCABLQAAIgBBCmsOGrcBmwGbAbQBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBmwGbAZsBpAGbAZsBAJkBCyABQQFqCyEBQQYhAwytAgsDQCABLQAAQfDGAGotAABBAUcNfSAEIAFBAWoiAUcNAAtB6gAhAwzFAgsgAUEBaiABIARHDQIaQesAIQMMxAILIAEgBEYEQEHsACEDDMQCCyABQQFqDAELIAEgBEYEQEHtACEDDMMCCyABQQFqCyEBQQQhAwyoAgsgASAERgRAQe4AIQMMwQILAkACQAJAIAEtAABB8MgAai0AAEEBaw4HkAGPAY4BAHwBAo0BCyABQQFqIQEMCwsgAUEBagyTAQtBACEDIAJBADYCHCACQZsSNgIQIAJBBzYCDCACIAFBAWo2AhQMwAILAkADQCABLQAAQfDIAGotAAAiAEEERwRAAkACQCAAQQFrDgeUAZMBkgGNAQAEAY0BC0HaACEDDKoCCyABQQFqIQFB3AAhAwypAgsgBCABQQFqIgFHDQALQe8AIQMMwAILIAFBAWoMkQELIAQgASIARgRAQfAAIQMMvwILIAAtAABBL0cNASAAQQFqIQEMBwsgBCABIgBGBEBB8QAhAwy+AgsgAC0AACIBQS9GBEAgAEEBaiEBQd0AIQMMpQILIAFBCmsiA0EWSw0AIAAhAUEBIAN0QYmAgAJxDfkBC0EAIQMgAkEANgIcIAIgADYCFCACQYwcNgIQIAJBBzYCDAy8AgsgASAERwRAIAFBAWohAUHeACEDDKMCC0HyACEDDLsCCyABIARGBEBB9AAhAwy7AgsCQCABLQAAQfDMAGotAABBAWsOA/cBcwCCAQtB4QAhAwyhAgsgASAERwRAA0AgAS0AAEHwygBqLQAAIgBBA0cEQAJAIABBAWsOAvkBAIUBC0HfACEDDKMCCyAEIAFBAWoiAUcNAAtB8wAhAwy6AgtB8wAhAwy5AgsgASAERwRAIAJBDzYCCCACIAE2AgRB4AAhAwygAgtB9QAhAwy4AgsgASAERgRAQfYAIQMMuAILIAJBDzYCCCACIAE2AgQLQQMhAwydAgsDQCABLQAAQSBHDY4CIAQgAUEBaiIBRw0AC0H3ACEDDLUCCyABIARGBEBB+AAhAwy1AgsgAS0AAEEgRw16IAFBAWohAQxbC0EAIQACQCACKAI4IgNFDQAgAygCOCIDRQ0AIAIgAxEAACEACyAADXgMgAILIAEgBEYEQEH6ACEDDLMCCyABLQAAQcwARw10IAFBAWohAUETDHYLQfsAIQMgASAERg2xAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYDQCABLQAAIABB8M4Aai0AAEcNcyAAQQVGDXUgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMsQILIAEgBEYEQEH8ACEDDLECCwJAAkAgAS0AAEHDAGsODAB0dHR0dHR0dHR0AXQLIAFBAWohAUHmACEDDJgCCyABQQFqIQFB5wAhAwyXAgtB/QAhAyABIARGDa8CIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQe3PAGotAABHDXIgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADLACCyACQQA2AgAgBkEBaiEBQRAMcwtB/gAhAyABIARGDa4CIAIoAgAiACAEIAFraiEFIAEgAGtBBWohBgJAA0AgAS0AACAAQfbOAGotAABHDXEgAEEFRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADK8CCyACQQA2AgAgBkEBaiEBQRYMcgtB/wAhAyABIARGDa0CIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQfzOAGotAABHDXAgAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADK4CCyACQQA2AgAgBkEBaiEBQQUMcQsgASAERgRAQYABIQMMrQILIAEtAABB2QBHDW4gAUEBaiEBQQgMcAsgASAERgRAQYEBIQMMrAILAkACQCABLQAAQc4Aaw4DAG8BbwsgAUEBaiEBQesAIQMMkwILIAFBAWohAUHsACEDDJICCyABIARGBEBBggEhAwyrAgsCQAJAIAEtAABByABrDggAbm5ubm5uAW4LIAFBAWohAUHqACEDDJICCyABQQFqIQFB7QAhAwyRAgtBgwEhAyABIARGDakCIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQYDPAGotAABHDWwgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADKoCCyACQQA2AgAgBkEBaiEBQQAMbQtBhAEhAyABIARGDagCIAIoAgAiACAEIAFraiEFIAEgAGtBBGohBgJAA0AgAS0AACAAQYPPAGotAABHDWsgAEEERg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADKkCCyACQQA2AgAgBkEBaiEBQSMMbAsgASAERgRAQYUBIQMMqAILAkACQCABLQAAQcwAaw4IAGtra2trawFrCyABQQFqIQFB7wAhAwyPAgsgAUEBaiEBQfAAIQMMjgILIAEgBEYEQEGGASEDDKcCCyABLQAAQcUARw1oIAFBAWohAQxgC0GHASEDIAEgBEYNpQIgAigCACIAIAQgAWtqIQUgASAAa0EDaiEGAkADQCABLQAAIABBiM8Aai0AAEcNaCAAQQNGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMpgILIAJBADYCACAGQQFqIQFBLQxpC0GIASEDIAEgBEYNpAIgAigCACIAIAQgAWtqIQUgASAAa0EIaiEGAkADQCABLQAAIABB0M8Aai0AAEcNZyAAQQhGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMpQILIAJBADYCACAGQQFqIQFBKQxoCyABIARGBEBBiQEhAwykAgtBASABLQAAQd8ARw1nGiABQQFqIQEMXgtBigEhAyABIARGDaICIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgNAIAEtAAAgAEGMzwBqLQAARw1kIABBAUYN+gEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMogILQYsBIQMgASAERg2hAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGOzwBqLQAARw1kIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyiAgsgAkEANgIAIAZBAWohAUECDGULQYwBIQMgASAERg2gAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHwzwBqLQAARw1jIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyhAgsgAkEANgIAIAZBAWohAUEfDGQLQY0BIQMgASAERg2fAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHyzwBqLQAARw1iIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAygAgsgAkEANgIAIAZBAWohAUEJDGMLIAEgBEYEQEGOASEDDJ8CCwJAAkAgAS0AAEHJAGsOBwBiYmJiYgFiCyABQQFqIQFB+AAhAwyGAgsgAUEBaiEBQfkAIQMMhQILQY8BIQMgASAERg2dAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEGRzwBqLQAARw1gIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyeAgsgAkEANgIAIAZBAWohAUEYDGELQZABIQMgASAERg2cAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGXzwBqLQAARw1fIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAydAgsgAkEANgIAIAZBAWohAUEXDGALQZEBIQMgASAERg2bAiACKAIAIgAgBCABa2ohBSABIABrQQZqIQYCQANAIAEtAAAgAEGazwBqLQAARw1eIABBBkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAycAgsgAkEANgIAIAZBAWohAUEVDF8LQZIBIQMgASAERg2aAiACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEGhzwBqLQAARw1dIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAybAgsgAkEANgIAIAZBAWohAUEeDF4LIAEgBEYEQEGTASEDDJoCCyABLQAAQcwARw1bIAFBAWohAUEKDF0LIAEgBEYEQEGUASEDDJkCCwJAAkAgAS0AAEHBAGsODwBcXFxcXFxcXFxcXFxcAVwLIAFBAWohAUH+ACEDDIACCyABQQFqIQFB/wAhAwz/AQsgASAERgRAQZUBIQMMmAILAkACQCABLQAAQcEAaw4DAFsBWwsgAUEBaiEBQf0AIQMM/wELIAFBAWohAUGAASEDDP4BC0GWASEDIAEgBEYNlgIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBp88Aai0AAEcNWSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlwILIAJBADYCACAGQQFqIQFBCwxaCyABIARGBEBBlwEhAwyWAgsCQAJAAkACQCABLQAAQS1rDiMAW1tbW1tbW1tbW1tbW1tbW1tbW1tbW1sBW1tbW1sCW1tbA1sLIAFBAWohAUH7ACEDDP8BCyABQQFqIQFB/AAhAwz+AQsgAUEBaiEBQYEBIQMM/QELIAFBAWohAUGCASEDDPwBC0GYASEDIAEgBEYNlAIgAigCACIAIAQgAWtqIQUgASAAa0EEaiEGAkADQCABLQAAIABBqc8Aai0AAEcNVyAAQQRGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlQILIAJBADYCACAGQQFqIQFBGQxYC0GZASEDIAEgBEYNkwIgAigCACIAIAQgAWtqIQUgASAAa0EFaiEGAkADQCABLQAAIABBrs8Aai0AAEcNViAAQQVGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMlAILIAJBADYCACAGQQFqIQFBBgxXC0GaASEDIAEgBEYNkgIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBtM8Aai0AAEcNVSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMkwILIAJBADYCACAGQQFqIQFBHAxWC0GbASEDIAEgBEYNkQIgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBts8Aai0AAEcNVCAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAMkgILIAJBADYCACAGQQFqIQFBJwxVCyABIARGBEBBnAEhAwyRAgsCQAJAIAEtAABB1ABrDgIAAVQLIAFBAWohAUGGASEDDPgBCyABQQFqIQFBhwEhAwz3AQtBnQEhAyABIARGDY8CIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQbjPAGotAABHDVIgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADJACCyACQQA2AgAgBkEBaiEBQSYMUwtBngEhAyABIARGDY4CIAIoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQbrPAGotAABHDVEgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI8CCyACQQA2AgAgBkEBaiEBQQMMUgtBnwEhAyABIARGDY0CIAIoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQe3PAGotAABHDVAgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI4CCyACQQA2AgAgBkEBaiEBQQwMUQtBoAEhAyABIARGDYwCIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQbzPAGotAABHDU8gAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADI0CCyACQQA2AgAgBkEBaiEBQQ0MUAsgASAERgRAQaEBIQMMjAILAkACQCABLQAAQcYAaw4LAE9PT09PT09PTwFPCyABQQFqIQFBiwEhAwzzAQsgAUEBaiEBQYwBIQMM8gELIAEgBEYEQEGiASEDDIsCCyABLQAAQdAARw1MIAFBAWohAQxGCyABIARGBEBBowEhAwyKAgsCQAJAIAEtAABByQBrDgcBTU1NTU0ATQsgAUEBaiEBQY4BIQMM8QELIAFBAWohAUEiDE0LQaQBIQMgASAERg2IAiACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHAzwBqLQAARw1LIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyJAgsgAkEANgIAIAZBAWohAUEdDEwLIAEgBEYEQEGlASEDDIgCCwJAAkAgAS0AAEHSAGsOAwBLAUsLIAFBAWohAUGQASEDDO8BCyABQQFqIQFBBAxLCyABIARGBEBBpgEhAwyHAgsCQAJAAkACQAJAIAEtAABBwQBrDhUATU1NTU1NTU1NTQFNTQJNTQNNTQRNCyABQQFqIQFBiAEhAwzxAQsgAUEBaiEBQYkBIQMM8AELIAFBAWohAUGKASEDDO8BCyABQQFqIQFBjwEhAwzuAQsgAUEBaiEBQZEBIQMM7QELQacBIQMgASAERg2FAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHtzwBqLQAARw1IIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyGAgsgAkEANgIAIAZBAWohAUERDEkLQagBIQMgASAERg2EAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHCzwBqLQAARw1HIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyFAgsgAkEANgIAIAZBAWohAUEsDEgLQakBIQMgASAERg2DAiACKAIAIgAgBCABa2ohBSABIABrQQRqIQYCQANAIAEtAAAgAEHFzwBqLQAARw1GIABBBEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyEAgsgAkEANgIAIAZBAWohAUErDEcLQaoBIQMgASAERg2CAiACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHKzwBqLQAARw1FIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyDAgsgAkEANgIAIAZBAWohAUEUDEYLIAEgBEYEQEGrASEDDIICCwJAAkACQAJAIAEtAABBwgBrDg8AAQJHR0dHR0dHR0dHRwNHCyABQQFqIQFBkwEhAwzrAQsgAUEBaiEBQZQBIQMM6gELIAFBAWohAUGVASEDDOkBCyABQQFqIQFBlgEhAwzoAQsgASAERgRAQawBIQMMgQILIAEtAABBxQBHDUIgAUEBaiEBDD0LQa0BIQMgASAERg3/ASACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHNzwBqLQAARw1CIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAyAAgsgAkEANgIAIAZBAWohAUEODEMLIAEgBEYEQEGuASEDDP8BCyABLQAAQdAARw1AIAFBAWohAUElDEILQa8BIQMgASAERg39ASACKAIAIgAgBCABa2ohBSABIABrQQhqIQYCQANAIAEtAAAgAEHQzwBqLQAARw1AIABBCEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz+AQsgAkEANgIAIAZBAWohAUEqDEELIAEgBEYEQEGwASEDDP0BCwJAAkAgAS0AAEHVAGsOCwBAQEBAQEBAQEABQAsgAUEBaiEBQZoBIQMM5AELIAFBAWohAUGbASEDDOMBCyABIARGBEBBsQEhAwz8AQsCQAJAIAEtAABBwQBrDhQAPz8/Pz8/Pz8/Pz8/Pz8/Pz8/AT8LIAFBAWohAUGZASEDDOMBCyABQQFqIQFBnAEhAwziAQtBsgEhAyABIARGDfoBIAIoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQdnPAGotAABHDT0gAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPsBCyACQQA2AgAgBkEBaiEBQSEMPgtBswEhAyABIARGDfkBIAIoAgAiACAEIAFraiEFIAEgAGtBBmohBgJAA0AgAS0AACAAQd3PAGotAABHDTwgAEEGRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAiAFNgIADPoBCyACQQA2AgAgBkEBaiEBQRoMPQsgASAERgRAQbQBIQMM+QELAkACQAJAIAEtAABBxQBrDhEAPT09PT09PT09AT09PT09Aj0LIAFBAWohAUGdASEDDOEBCyABQQFqIQFBngEhAwzgAQsgAUEBaiEBQZ8BIQMM3wELQbUBIQMgASAERg33ASACKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEHkzwBqLQAARw06IABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz4AQsgAkEANgIAIAZBAWohAUEoDDsLQbYBIQMgASAERg32ASACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEHqzwBqLQAARw05IABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAz3AQsgAkEANgIAIAZBAWohAUEHDDoLIAEgBEYEQEG3ASEDDPYBCwJAAkAgAS0AAEHFAGsODgA5OTk5OTk5OTk5OTkBOQsgAUEBaiEBQaEBIQMM3QELIAFBAWohAUGiASEDDNwBC0G4ASEDIAEgBEYN9AEgAigCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABB7c8Aai0AAEcNNyAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM9QELIAJBADYCACAGQQFqIQFBEgw4C0G5ASEDIAEgBEYN8wEgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABB8M8Aai0AAEcNNiAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM9AELIAJBADYCACAGQQFqIQFBIAw3C0G6ASEDIAEgBEYN8gEgAigCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABB8s8Aai0AAEcNNSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM8wELIAJBADYCACAGQQFqIQFBDww2CyABIARGBEBBuwEhAwzyAQsCQAJAIAEtAABByQBrDgcANTU1NTUBNQsgAUEBaiEBQaUBIQMM2QELIAFBAWohAUGmASEDDNgBC0G8ASEDIAEgBEYN8AEgAigCACIAIAQgAWtqIQUgASAAa0EHaiEGAkADQCABLQAAIABB9M8Aai0AAEcNMyAAQQdGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyACIAU2AgAM8QELIAJBADYCACAGQQFqIQFBGww0CyABIARGBEBBvQEhAwzwAQsCQAJAAkAgAS0AAEHCAGsOEgA0NDQ0NDQ0NDQBNDQ0NDQ0AjQLIAFBAWohAUGkASEDDNgBCyABQQFqIQFBpwEhAwzXAQsgAUEBaiEBQagBIQMM1gELIAEgBEYEQEG+ASEDDO8BCyABLQAAQc4ARw0wIAFBAWohAQwsCyABIARGBEBBvwEhAwzuAQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQAAQcEAaw4VAAECAz8EBQY/Pz8HCAkKCz8MDQ4PPwsgAUEBaiEBQegAIQMM4wELIAFBAWohAUHpACEDDOIBCyABQQFqIQFB7gAhAwzhAQsgAUEBaiEBQfIAIQMM4AELIAFBAWohAUHzACEDDN8BCyABQQFqIQFB9gAhAwzeAQsgAUEBaiEBQfcAIQMM3QELIAFBAWohAUH6ACEDDNwBCyABQQFqIQFBgwEhAwzbAQsgAUEBaiEBQYQBIQMM2gELIAFBAWohAUGFASEDDNkBCyABQQFqIQFBkgEhAwzYAQsgAUEBaiEBQZgBIQMM1wELIAFBAWohAUGgASEDDNYBCyABQQFqIQFBowEhAwzVAQsgAUEBaiEBQaoBIQMM1AELIAEgBEcEQCACQRA2AgggAiABNgIEQasBIQMM1AELQcABIQMM7AELQQAhAAJAIAIoAjgiA0UNACADKAI0IgNFDQAgAiADEQAAIQALIABFDV4gAEEVRw0HIAJB0QA2AhwgAiABNgIUIAJBsBc2AhAgAkEVNgIMQQAhAwzrAQsgAUEBaiABIARHDQgaQcIBIQMM6gELA0ACQCABLQAAQQprDgQIAAALAAsgBCABQQFqIgFHDQALQcMBIQMM6QELIAEgBEcEQCACQRE2AgggAiABNgIEQQEhAwzQAQtBxAEhAwzoAQsgASAERgRAQcUBIQMM6AELAkACQCABLQAAQQprDgQBKCgAKAsgAUEBagwJCyABQQFqDAULIAEgBEYEQEHGASEDDOcBCwJAAkAgAS0AAEEKaw4XAQsLAQsLCwsLCwsLCwsLCwsLCwsLCwALCyABQQFqIQELQbABIQMMzQELIAEgBEYEQEHIASEDDOYBCyABLQAAQSBHDQkgAkEAOwEyIAFBAWohAUGzASEDDMwBCwNAIAEhAAJAIAEgBEcEQCABLQAAQTBrQf8BcSIDQQpJDQEMJwtBxwEhAwzmAQsCQCACLwEyIgFBmTNLDQAgAiABQQpsIgU7ATIgBUH+/wNxIANB//8Dc0sNACAAQQFqIQEgAiADIAVqIgM7ATIgA0H//wNxQegHSQ0BCwtBACEDIAJBADYCHCACQcEJNgIQIAJBDTYCDCACIABBAWo2AhQM5AELIAJBADYCHCACIAE2AhQgAkHwDDYCECACQRs2AgxBACEDDOMBCyACKAIEIQAgAkEANgIEIAIgACABECYiAA0BIAFBAWoLIQFBrQEhAwzIAQsgAkHBATYCHCACIAA2AgwgAiABQQFqNgIUQQAhAwzgAQsgAigCBCEAIAJBADYCBCACIAAgARAmIgANASABQQFqCyEBQa4BIQMMxQELIAJBwgE2AhwgAiAANgIMIAIgAUEBajYCFEEAIQMM3QELIAJBADYCHCACIAE2AhQgAkGXCzYCECACQQ02AgxBACEDDNwBCyACQQA2AhwgAiABNgIUIAJB4xA2AhAgAkEJNgIMQQAhAwzbAQsgAkECOgAoDKwBC0EAIQMgAkEANgIcIAJBrws2AhAgAkECNgIMIAIgAUEBajYCFAzZAQtBAiEDDL8BC0ENIQMMvgELQSYhAwy9AQtBFSEDDLwBC0EWIQMMuwELQRghAwy6AQtBHCEDDLkBC0EdIQMMuAELQSAhAwy3AQtBISEDDLYBC0EjIQMMtQELQcYAIQMMtAELQS4hAwyzAQtBPSEDDLIBC0HLACEDDLEBC0HOACEDDLABC0HYACEDDK8BC0HZACEDDK4BC0HbACEDDK0BC0HxACEDDKwBC0H0ACEDDKsBC0GNASEDDKoBC0GXASEDDKkBC0GpASEDDKgBC0GvASEDDKcBC0GxASEDDKYBCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJB8Rs2AhAgAkEGNgIMDL0BCyACQQA2AgAgBkEBaiEBQSQLOgApIAIoAgQhACACQQA2AgQgAiAAIAEQJyIARQRAQeUAIQMMowELIAJB+QA2AhwgAiABNgIUIAIgADYCDEEAIQMMuwELIABBFUcEQCACQQA2AhwgAiABNgIUIAJBzA42AhAgAkEgNgIMQQAhAwy7AQsgAkH4ADYCHCACIAE2AhQgAkHKGDYCECACQRU2AgxBACEDDLoBCyACQQA2AhwgAiABNgIUIAJBjhs2AhAgAkEGNgIMQQAhAwy5AQsgAkEANgIcIAIgATYCFCACQf4RNgIQIAJBBzYCDEEAIQMMuAELIAJBADYCHCACIAE2AhQgAkGMHDYCECACQQc2AgxBACEDDLcBCyACQQA2AhwgAiABNgIUIAJBww82AhAgAkEHNgIMQQAhAwy2AQsgAkEANgIcIAIgATYCFCACQcMPNgIQIAJBBzYCDEEAIQMMtQELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0RIAJB5QA2AhwgAiABNgIUIAIgADYCDEEAIQMMtAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0gIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMswELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0iIAJB0gA2AhwgAiABNgIUIAIgADYCDEEAIQMMsgELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0OIAJB5QA2AhwgAiABNgIUIAIgADYCDEEAIQMMsQELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0dIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMsAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0fIAJB0gA2AhwgAiABNgIUIAIgADYCDEEAIQMMrwELIABBP0cNASABQQFqCyEBQQUhAwyUAQtBACEDIAJBADYCHCACIAE2AhQgAkH9EjYCECACQQc2AgwMrAELIAJBADYCHCACIAE2AhQgAkHcCDYCECACQQc2AgxBACEDDKsBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNByACQeUANgIcIAIgATYCFCACIAA2AgxBACEDDKoBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNFiACQdMANgIcIAIgATYCFCACIAA2AgxBACEDDKkBCyACKAIEIQAgAkEANgIEIAIgACABECUiAEUNGCACQdIANgIcIAIgATYCFCACIAA2AgxBACEDDKgBCyACQQA2AhwgAiABNgIUIAJBxgo2AhAgAkEHNgIMQQAhAwynAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDQMgAkHlADYCHCACIAE2AhQgAiAANgIMQQAhAwymAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDRIgAkHTADYCHCACIAE2AhQgAiAANgIMQQAhAwylAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDRQgAkHSADYCHCACIAE2AhQgAiAANgIMQQAhAwykAQsgAigCBCEAIAJBADYCBCACIAAgARAlIgBFDQAgAkHlADYCHCACIAE2AhQgAiAANgIMQQAhAwyjAQtB1QAhAwyJAQsgAEEVRwRAIAJBADYCHCACIAE2AhQgAkG5DTYCECACQRo2AgxBACEDDKIBCyACQeQANgIcIAIgATYCFCACQeMXNgIQIAJBFTYCDEEAIQMMoQELIAJBADYCACAGQQFqIQEgAi0AKSIAQSNrQQtJDQQCQCAAQQZLDQBBASAAdEHKAHFFDQAMBQtBACEDIAJBADYCHCACIAE2AhQgAkH3CTYCECACQQg2AgwMoAELIAJBADYCACAGQQFqIQEgAi0AKUEhRg0DIAJBADYCHCACIAE2AhQgAkGbCjYCECACQQg2AgxBACEDDJ8BCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJBkDM2AhAgAkEINgIMDJ0BCyACQQA2AgAgBkEBaiEBIAItAClBI0kNACACQQA2AhwgAiABNgIUIAJB0wk2AhAgAkEINgIMQQAhAwycAQtB0QAhAwyCAQsgAS0AAEEwayIAQf8BcUEKSQRAIAIgADoAKiABQQFqIQFBzwAhAwyCAQsgAigCBCEAIAJBADYCBCACIAAgARAoIgBFDYYBIAJB3gA2AhwgAiABNgIUIAIgADYCDEEAIQMMmgELIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ2GASACQdwANgIcIAIgATYCFCACIAA2AgxBACEDDJkBCyACKAIEIQAgAkEANgIEIAIgACAFECgiAEUEQCAFIQEMhwELIAJB2gA2AhwgAiAFNgIUIAIgADYCDAyYAQtBACEBQQEhAwsgAiADOgArIAVBAWohAwJAAkACQCACLQAtQRBxDQACQAJAAkAgAi0AKg4DAQACBAsgBkUNAwwCCyAADQEMAgsgAUUNAQsgAigCBCEAIAJBADYCBCACIAAgAxAoIgBFBEAgAyEBDAILIAJB2AA2AhwgAiADNgIUIAIgADYCDEEAIQMMmAELIAIoAgQhACACQQA2AgQgAiAAIAMQKCIARQRAIAMhAQyHAQsgAkHZADYCHCACIAM2AhQgAiAANgIMQQAhAwyXAQtBzAAhAwx9CyAAQRVHBEAgAkEANgIcIAIgATYCFCACQZQNNgIQIAJBITYCDEEAIQMMlgELIAJB1wA2AhwgAiABNgIUIAJByRc2AhAgAkEVNgIMQQAhAwyVAQtBACEDIAJBADYCHCACIAE2AhQgAkGAETYCECACQQk2AgwMlAELIAIoAgQhACACQQA2AgQgAiAAIAEQJSIARQ0AIAJB0wA2AhwgAiABNgIUIAIgADYCDEEAIQMMkwELQckAIQMMeQsgAkEANgIcIAIgATYCFCACQcEoNgIQIAJBBzYCDCACQQA2AgBBACEDDJEBCyACKAIEIQBBACEDIAJBADYCBCACIAAgARAlIgBFDQAgAkHSADYCHCACIAE2AhQgAiAANgIMDJABC0HIACEDDHYLIAJBADYCACAFIQELIAJBgBI7ASogAUEBaiEBQQAhAAJAIAIoAjgiA0UNACADKAIwIgNFDQAgAiADEQAAIQALIAANAQtBxwAhAwxzCyAAQRVGBEAgAkHRADYCHCACIAE2AhQgAkHjFzYCECACQRU2AgxBACEDDIwBC0EAIQMgAkEANgIcIAIgATYCFCACQbkNNgIQIAJBGjYCDAyLAQtBACEDIAJBADYCHCACIAE2AhQgAkGgGTYCECACQR42AgwMigELIAEtAABBOkYEQCACKAIEIQBBACEDIAJBADYCBCACIAAgARApIgBFDQEgAkHDADYCHCACIAA2AgwgAiABQQFqNgIUDIoBC0EAIQMgAkEANgIcIAIgATYCFCACQbERNgIQIAJBCjYCDAyJAQsgAUEBaiEBQTshAwxvCyACQcMANgIcIAIgADYCDCACIAFBAWo2AhQMhwELQQAhAyACQQA2AhwgAiABNgIUIAJB8A42AhAgAkEcNgIMDIYBCyACIAIvATBBEHI7ATAMZgsCQCACLwEwIgBBCHFFDQAgAi0AKEEBRw0AIAItAC1BCHFFDQMLIAIgAEH3+wNxQYAEcjsBMAwECyABIARHBEACQANAIAEtAABBMGsiAEH/AXFBCk8EQEE1IQMMbgsgAikDICIKQpmz5syZs+bMGVYNASACIApCCn4iCjcDICAKIACtQv8BgyILQn+FVg0BIAIgCiALfDcDICAEIAFBAWoiAUcNAAtBOSEDDIUBCyACKAIEIQBBACEDIAJBADYCBCACIAAgAUEBaiIBECoiAA0MDHcLQTkhAwyDAQsgAi0AMEEgcQ0GQcUBIQMMaQtBACEDIAJBADYCBCACIAEgARAqIgBFDQQgAkE6NgIcIAIgADYCDCACIAFBAWo2AhQMgQELIAItAChBAUcNACACLQAtQQhxRQ0BC0E3IQMMZgsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIABEAgAkE7NgIcIAIgADYCDCACIAFBAWo2AhQMfwsgAUEBaiEBDG4LIAJBCDoALAwECyABQQFqIQEMbQtBACEDIAJBADYCHCACIAE2AhQgAkHkEjYCECACQQQ2AgwMewsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIARQ1sIAJBNzYCHCACIAE2AhQgAiAANgIMDHoLIAIgAi8BMEEgcjsBMAtBMCEDDF8LIAJBNjYCHCACIAE2AhQgAiAANgIMDHcLIABBLEcNASABQQFqIQBBASEBAkACQAJAAkACQCACLQAsQQVrDgQDAQIEAAsgACEBDAQLQQIhAQwBC0EEIQELIAJBAToALCACIAIvATAgAXI7ATAgACEBDAELIAIgAi8BMEEIcjsBMCAAIQELQTkhAwxcCyACQQA6ACwLQTQhAwxaCyABIARGBEBBLSEDDHMLAkACQANAAkAgAS0AAEEKaw4EAgAAAwALIAQgAUEBaiIBRw0AC0EtIQMMdAsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIARQ0CIAJBLDYCHCACIAE2AhQgAiAANgIMDHMLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABECoiAEUEQCABQQFqIQEMAgsgAkEsNgIcIAIgADYCDCACIAFBAWo2AhQMcgsgAS0AAEENRgRAIAIoAgQhAEEAIQMgAkEANgIEIAIgACABECoiAEUEQCABQQFqIQEMAgsgAkEsNgIcIAIgADYCDCACIAFBAWo2AhQMcgsgAi0ALUEBcQRAQcQBIQMMWQsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKiIADQEMZQtBLyEDDFcLIAJBLjYCHCACIAE2AhQgAiAANgIMDG8LQQAhAyACQQA2AhwgAiABNgIUIAJB8BQ2AhAgAkEDNgIMDG4LQQEhAwJAAkACQAJAIAItACxBBWsOBAMBAgAECyACIAIvATBBCHI7ATAMAwtBAiEDDAELQQQhAwsgAkEBOgAsIAIgAi8BMCADcjsBMAtBKiEDDFMLQQAhAyACQQA2AhwgAiABNgIUIAJB4Q82AhAgAkEKNgIMDGsLQQEhAwJAAkACQAJAAkACQCACLQAsQQJrDgcFBAQDAQIABAsgAiACLwEwQQhyOwEwDAMLQQIhAwwBC0EEIQMLIAJBAToALCACIAIvATAgA3I7ATALQSshAwxSC0EAIQMgAkEANgIcIAIgATYCFCACQasSNgIQIAJBCzYCDAxqC0EAIQMgAkEANgIcIAIgATYCFCACQf0NNgIQIAJBHTYCDAxpCyABIARHBEADQCABLQAAQSBHDUggBCABQQFqIgFHDQALQSUhAwxpC0ElIQMMaAsgAi0ALUEBcQRAQcMBIQMMTwsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQKSIABEAgAkEmNgIcIAIgADYCDCACIAFBAWo2AhQMaAsgAUEBaiEBDFwLIAFBAWohASACLwEwIgBBgAFxBEBBACEAAkAgAigCOCIDRQ0AIAMoAlQiA0UNACACIAMRAAAhAAsgAEUNBiAAQRVHDR8gAkEFNgIcIAIgATYCFCACQfkXNgIQIAJBFTYCDEEAIQMMZwsCQCAAQaAEcUGgBEcNACACLQAtQQJxDQBBACEDIAJBADYCHCACIAE2AhQgAkGWEzYCECACQQQ2AgwMZwsgAgJ/IAIvATBBFHFBFEYEQEEBIAItAChBAUYNARogAi8BMkHlAEYMAQsgAi0AKUEFRgs6AC5BACEAAkAgAigCOCIDRQ0AIAMoAiQiA0UNACACIAMRAAAhAAsCQAJAAkACQAJAIAAOFgIBAAQEBAQEBAQEBAQEBAQEBAQEBAMECyACQQE6AC4LIAIgAi8BMEHAAHI7ATALQSchAwxPCyACQSM2AhwgAiABNgIUIAJBpRY2AhAgAkEVNgIMQQAhAwxnC0EAIQMgAkEANgIcIAIgATYCFCACQdULNgIQIAJBETYCDAxmC0EAIQACQCACKAI4IgNFDQAgAygCLCIDRQ0AIAIgAxEAACEACyAADQELQQ4hAwxLCyAAQRVGBEAgAkECNgIcIAIgATYCFCACQbAYNgIQIAJBFTYCDEEAIQMMZAtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMYwtBACEDIAJBADYCHCACIAE2AhQgAkGqHDYCECACQQ82AgwMYgsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEgCqdqIgEQKyIARQ0AIAJBBTYCHCACIAE2AhQgAiAANgIMDGELQQ8hAwxHC0EAIQMgAkEANgIcIAIgATYCFCACQc0TNgIQIAJBDDYCDAxfC0IBIQoLIAFBAWohAQJAIAIpAyAiC0L//////////w9YBEAgAiALQgSGIAqENwMgDAELQQAhAyACQQA2AhwgAiABNgIUIAJBrQk2AhAgAkEMNgIMDF4LQSQhAwxEC0EAIQMgAkEANgIcIAIgATYCFCACQc0TNgIQIAJBDDYCDAxcCyACKAIEIQBBACEDIAJBADYCBCACIAAgARAsIgBFBEAgAUEBaiEBDFILIAJBFzYCHCACIAA2AgwgAiABQQFqNgIUDFsLIAIoAgQhAEEAIQMgAkEANgIEAkAgAiAAIAEQLCIARQRAIAFBAWohAQwBCyACQRY2AhwgAiAANgIMIAIgAUEBajYCFAxbC0EfIQMMQQtBACEDIAJBADYCHCACIAE2AhQgAkGaDzYCECACQSI2AgwMWQsgAigCBCEAQQAhAyACQQA2AgQgAiAAIAEQLSIARQRAIAFBAWohAQxQCyACQRQ2AhwgAiAANgIMIAIgAUEBajYCFAxYCyACKAIEIQBBACEDIAJBADYCBAJAIAIgACABEC0iAEUEQCABQQFqIQEMAQsgAkETNgIcIAIgADYCDCACIAFBAWo2AhQMWAtBHiEDDD4LQQAhAyACQQA2AhwgAiABNgIUIAJBxgw2AhAgAkEjNgIMDFYLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABEC0iAEUEQCABQQFqIQEMTgsgAkERNgIcIAIgADYCDCACIAFBAWo2AhQMVQsgAkEQNgIcIAIgATYCFCACIAA2AgwMVAtBACEDIAJBADYCHCACIAE2AhQgAkHGDDYCECACQSM2AgwMUwtBACEDIAJBADYCHCACIAE2AhQgAkHAFTYCECACQQI2AgwMUgsgAigCBCEAQQAhAyACQQA2AgQCQCACIAAgARAtIgBFBEAgAUEBaiEBDAELIAJBDjYCHCACIAA2AgwgAiABQQFqNgIUDFILQRshAww4C0EAIQMgAkEANgIcIAIgATYCFCACQcYMNgIQIAJBIzYCDAxQCyACKAIEIQBBACEDIAJBADYCBAJAIAIgACABECwiAEUEQCABQQFqIQEMAQsgAkENNgIcIAIgADYCDCACIAFBAWo2AhQMUAtBGiEDDDYLQQAhAyACQQA2AhwgAiABNgIUIAJBmg82AhAgAkEiNgIMDE4LIAIoAgQhAEEAIQMgAkEANgIEAkAgAiAAIAEQLCIARQRAIAFBAWohAQwBCyACQQw2AhwgAiAANgIMIAIgAUEBajYCFAxOC0EZIQMMNAtBACEDIAJBADYCHCACIAE2AhQgAkGaDzYCECACQSI2AgwMTAsgAEEVRwRAQQAhAyACQQA2AhwgAiABNgIUIAJBgww2AhAgAkETNgIMDEwLIAJBCjYCHCACIAE2AhQgAkHkFjYCECACQRU2AgxBACEDDEsLIAIoAgQhAEEAIQMgAkEANgIEIAIgACABIAqnaiIBECsiAARAIAJBBzYCHCACIAE2AhQgAiAANgIMDEsLQRMhAwwxCyAAQRVHBEBBACEDIAJBADYCHCACIAE2AhQgAkHaDTYCECACQRQ2AgwMSgsgAkEeNgIcIAIgATYCFCACQfkXNgIQIAJBFTYCDEEAIQMMSQtBACEAAkAgAigCOCIDRQ0AIAMoAiwiA0UNACACIAMRAAAhAAsgAEUNQSAAQRVGBEAgAkEDNgIcIAIgATYCFCACQbAYNgIQIAJBFTYCDEEAIQMMSQtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMSAtBACEDIAJBADYCHCACIAE2AhQgAkHaDTYCECACQRQ2AgwMRwtBACEDIAJBADYCHCACIAE2AhQgAkGnDjYCECACQRI2AgwMRgsgAkEAOgAvIAItAC1BBHFFDT8LIAJBADoALyACQQE6ADRBACEDDCsLQQAhAyACQQA2AhwgAkHkETYCECACQQc2AgwgAiABQQFqNgIUDEMLAkADQAJAIAEtAABBCmsOBAACAgACCyAEIAFBAWoiAUcNAAtB3QEhAwxDCwJAAkAgAi0ANEEBRw0AQQAhAAJAIAIoAjgiA0UNACADKAJYIgNFDQAgAiADEQAAIQALIABFDQAgAEEVRw0BIAJB3AE2AhwgAiABNgIUIAJB1RY2AhAgAkEVNgIMQQAhAwxEC0HBASEDDCoLIAJBADYCHCACIAE2AhQgAkHpCzYCECACQR82AgxBACEDDEILAkACQCACLQAoQQFrDgIEAQALQcABIQMMKQtBuQEhAwwoCyACQQI6AC9BACEAAkAgAigCOCIDRQ0AIAMoAgAiA0UNACACIAMRAAAhAAsgAEUEQEHCASEDDCgLIABBFUcEQCACQQA2AhwgAiABNgIUIAJBpAw2AhAgAkEQNgIMQQAhAwxBCyACQdsBNgIcIAIgATYCFCACQfoWNgIQIAJBFTYCDEEAIQMMQAsgASAERgRAQdoBIQMMQAsgAS0AAEHIAEYNASACQQE6ACgLQawBIQMMJQtBvwEhAwwkCyABIARHBEAgAkEQNgIIIAIgATYCBEG+ASEDDCQLQdkBIQMMPAsgASAERgRAQdgBIQMMPAsgAS0AAEHIAEcNBCABQQFqIQFBvQEhAwwiCyABIARGBEBB1wEhAww7CwJAAkAgAS0AAEHFAGsOEAAFBQUFBQUFBQUFBQUFBQEFCyABQQFqIQFBuwEhAwwiCyABQQFqIQFBvAEhAwwhC0HWASEDIAEgBEYNOSACKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGD0ABqLQAARw0DIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAw6CyACKAIEIQAgAkIANwMAIAIgACAGQQFqIgEQJyIARQRAQcYBIQMMIQsgAkHVATYCHCACIAE2AhQgAiAANgIMQQAhAww5C0HUASEDIAEgBEYNOCACKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEGB0ABqLQAARw0CIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAIgBTYCAAw5CyACQYEEOwEoIAIoAgQhACACQgA3AwAgAiAAIAZBAWoiARAnIgANAwwCCyACQQA2AgALQQAhAyACQQA2AhwgAiABNgIUIAJB2Bs2AhAgAkEINgIMDDYLQboBIQMMHAsgAkHTATYCHCACIAE2AhQgAiAANgIMQQAhAww0C0EAIQACQCACKAI4IgNFDQAgAygCOCIDRQ0AIAIgAxEAACEACyAARQ0AIABBFUYNASACQQA2AhwgAiABNgIUIAJBzA42AhAgAkEgNgIMQQAhAwwzC0HkACEDDBkLIAJB+AA2AhwgAiABNgIUIAJByhg2AhAgAkEVNgIMQQAhAwwxC0HSASEDIAQgASIARg0wIAQgAWsgAigCACIBaiEFIAAgAWtBBGohBgJAA0AgAC0AACABQfzPAGotAABHDQEgAUEERg0DIAFBAWohASAEIABBAWoiAEcNAAsgAiAFNgIADDELIAJBADYCHCACIAA2AhQgAkGQMzYCECACQQg2AgwgAkEANgIAQQAhAwwwCyABIARHBEAgAkEONgIIIAIgATYCBEG3ASEDDBcLQdEBIQMMLwsgAkEANgIAIAZBAWohAQtBuAEhAwwUCyABIARGBEBB0AEhAwwtCyABLQAAQTBrIgBB/wFxQQpJBEAgAiAAOgAqIAFBAWohAUG2ASEDDBQLIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ0UIAJBzwE2AhwgAiABNgIUIAIgADYCDEEAIQMMLAsgASAERgRAQc4BIQMMLAsCQCABLQAAQS5GBEAgAUEBaiEBDAELIAIoAgQhACACQQA2AgQgAiAAIAEQKCIARQ0VIAJBzQE2AhwgAiABNgIUIAIgADYCDEEAIQMMLAtBtQEhAwwSCyAEIAEiBUYEQEHMASEDDCsLQQAhAEEBIQFBASEGQQAhAwJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAIAUtAABBMGsOCgoJAAECAwQFBggLC0ECDAYLQQMMBQtBBAwEC0EFDAMLQQYMAgtBBwwBC0EICyEDQQAhAUEAIQYMAgtBCSEDQQEhAEEAIQFBACEGDAELQQAhAUEBIQMLIAIgAzoAKyAFQQFqIQMCQAJAIAItAC1BEHENAAJAAkACQCACLQAqDgMBAAIECyAGRQ0DDAILIAANAQwCCyABRQ0BCyACKAIEIQAgAkEANgIEIAIgACADECgiAEUEQCADIQEMAwsgAkHJATYCHCACIAM2AhQgAiAANgIMQQAhAwwtCyACKAIEIQAgAkEANgIEIAIgACADECgiAEUEQCADIQEMGAsgAkHKATYCHCACIAM2AhQgAiAANgIMQQAhAwwsCyACKAIEIQAgAkEANgIEIAIgACAFECgiAEUEQCAFIQEMFgsgAkHLATYCHCACIAU2AhQgAiAANgIMDCsLQbQBIQMMEQtBACEAAkAgAigCOCIDRQ0AIAMoAjwiA0UNACACIAMRAAAhAAsCQCAABEAgAEEVRg0BIAJBADYCHCACIAE2AhQgAkGUDTYCECACQSE2AgxBACEDDCsLQbIBIQMMEQsgAkHIATYCHCACIAE2AhQgAkHJFzYCECACQRU2AgxBACEDDCkLIAJBADYCACAGQQFqIQFB9QAhAwwPCyACLQApQQVGBEBB4wAhAwwPC0HiACEDDA4LIAAhASACQQA2AgALIAJBADoALEEJIQMMDAsgAkEANgIAIAdBAWohAUHAACEDDAsLQQELOgAsIAJBADYCACAGQQFqIQELQSkhAwwIC0E4IQMMBwsCQCABIARHBEADQCABLQAAQYA+ai0AACIAQQFHBEAgAEECRw0DIAFBAWohAQwFCyAEIAFBAWoiAUcNAAtBPiEDDCELQT4hAwwgCwsgAkEAOgAsDAELQQshAwwEC0E6IQMMAwsgAUEBaiEBQS0hAwwCCyACIAE6ACwgAkEANgIAIAZBAWohAUEMIQMMAQsgAkEANgIAIAZBAWohAUEKIQMMAAsAC0EAIQMgAkEANgIcIAIgATYCFCACQc0QNgIQIAJBCTYCDAwXC0EAIQMgAkEANgIcIAIgATYCFCACQekKNgIQIAJBCTYCDAwWC0EAIQMgAkEANgIcIAIgATYCFCACQbcQNgIQIAJBCTYCDAwVC0EAIQMgAkEANgIcIAIgATYCFCACQZwRNgIQIAJBCTYCDAwUC0EAIQMgAkEANgIcIAIgATYCFCACQc0QNgIQIAJBCTYCDAwTC0EAIQMgAkEANgIcIAIgATYCFCACQekKNgIQIAJBCTYCDAwSC0EAIQMgAkEANgIcIAIgATYCFCACQbcQNgIQIAJBCTYCDAwRC0EAIQMgAkEANgIcIAIgATYCFCACQZwRNgIQIAJBCTYCDAwQC0EAIQMgAkEANgIcIAIgATYCFCACQZcVNgIQIAJBDzYCDAwPC0EAIQMgAkEANgIcIAIgATYCFCACQZcVNgIQIAJBDzYCDAwOC0EAIQMgAkEANgIcIAIgATYCFCACQcASNgIQIAJBCzYCDAwNC0EAIQMgAkEANgIcIAIgATYCFCACQZUJNgIQIAJBCzYCDAwMC0EAIQMgAkEANgIcIAIgATYCFCACQeEPNgIQIAJBCjYCDAwLC0EAIQMgAkEANgIcIAIgATYCFCACQfsPNgIQIAJBCjYCDAwKC0EAIQMgAkEANgIcIAIgATYCFCACQfEZNgIQIAJBAjYCDAwJC0EAIQMgAkEANgIcIAIgATYCFCACQcQUNgIQIAJBAjYCDAwIC0EAIQMgAkEANgIcIAIgATYCFCACQfIVNgIQIAJBAjYCDAwHCyACQQI2AhwgAiABNgIUIAJBnBo2AhAgAkEWNgIMQQAhAwwGC0EBIQMMBQtB1AAhAyABIARGDQQgCEEIaiEJIAIoAgAhBQJAAkAgASAERwRAIAVB2MIAaiEHIAQgBWogAWshACAFQX9zQQpqIgUgAWohBgNAIAEtAAAgBy0AAEcEQEECIQcMAwsgBUUEQEEAIQcgBiEBDAMLIAVBAWshBSAHQQFqIQcgBCABQQFqIgFHDQALIAAhBSAEIQELIAlBATYCACACIAU2AgAMAQsgAkEANgIAIAkgBzYCAAsgCSABNgIEIAgoAgwhACAIKAIIDgMBBAIACwALIAJBADYCHCACQbUaNgIQIAJBFzYCDCACIABBAWo2AhRBACEDDAILIAJBADYCHCACIAA2AhQgAkHKGjYCECACQQk2AgxBACEDDAELIAEgBEYEQEEiIQMMAQsgAkEJNgIIIAIgATYCBEEhIQMLIAhBEGokACADRQRAIAIoAgwhAAwBCyACIAM2AhxBACEAIAIoAgQiAUUNACACIAEgBCACKAIIEQEAIgFFDQAgAiAENgIUIAIgATYCDCABIQALIAALvgIBAn8gAEEAOgAAIABB3ABqIgFBAWtBADoAACAAQQA6AAIgAEEAOgABIAFBA2tBADoAACABQQJrQQA6AAAgAEEAOgADIAFBBGtBADoAAEEAIABrQQNxIgEgAGoiAEEANgIAQdwAIAFrQXxxIgIgAGoiAUEEa0EANgIAAkAgAkEJSQ0AIABBADYCCCAAQQA2AgQgAUEIa0EANgIAIAFBDGtBADYCACACQRlJDQAgAEEANgIYIABBADYCFCAAQQA2AhAgAEEANgIMIAFBEGtBADYCACABQRRrQQA2AgAgAUEYa0EANgIAIAFBHGtBADYCACACIABBBHFBGHIiAmsiAUEgSQ0AIAAgAmohAANAIABCADcDGCAAQgA3AxAgAEIANwMIIABCADcDACAAQSBqIQAgAUEgayIBQR9LDQALCwtWAQF/AkAgACgCDA0AAkACQAJAAkAgAC0ALw4DAQADAgsgACgCOCIBRQ0AIAEoAiwiAUUNACAAIAERAAAiAQ0DC0EADwsACyAAQcMWNgIQQQ4hAQsgAQsaACAAKAIMRQRAIABB0Rs2AhAgAEEVNgIMCwsUACAAKAIMQRVGBEAgAEEANgIMCwsUACAAKAIMQRZGBEAgAEEANgIMCwsHACAAKAIMCwcAIAAoAhALCQAgACABNgIQCwcAIAAoAhQLFwAgAEEkTwRAAAsgAEECdEGgM2ooAgALFwAgAEEuTwRAAAsgAEECdEGwNGooAgALvwkBAX9B6yghAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB5ABrDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0HhJw8LQaQhDwtByywPC0H+MQ8LQcAkDwtBqyQPC0GNKA8LQeImDwtBgDAPC0G5Lw8LQdckDwtB7x8PC0HhHw8LQfofDwtB8iAPC0GoLw8LQa4yDwtBiDAPC0HsJw8LQYIiDwtBjh0PC0HQLg8LQcojDwtBxTIPC0HfHA8LQdIcDwtBxCAPC0HXIA8LQaIfDwtB7S4PC0GrMA8LQdQlDwtBzC4PC0H6Lg8LQfwrDwtB0jAPC0HxHQ8LQbsgDwtB9ysPC0GQMQ8LQdcxDwtBoi0PC0HUJw8LQeArDwtBnywPC0HrMQ8LQdUfDwtByjEPC0HeJQ8LQdQeDwtB9BwPC0GnMg8LQbEdDwtBoB0PC0G5MQ8LQbwwDwtBkiEPC0GzJg8LQeksDwtBrB4PC0HUKw8LQfcmDwtBgCYPC0GwIQ8LQf4eDwtBjSMPC0GJLQ8LQfciDwtBoDEPC0GuHw8LQcYlDwtB6B4PC0GTIg8LQcIvDwtBwx0PC0GLLA8LQeEdDwtBjS8PC0HqIQ8LQbQtDwtB0i8PC0HfMg8LQdIyDwtB8DAPC0GpIg8LQfkjDwtBmR4PC0G1LA8LQZswDwtBkjIPC0G2Kw8LQcIiDwtB+DIPC0GeJQ8LQdAiDwtBuh4PC0GBHg8LAAtB1iEhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCz4BAn8CQCAAKAI4IgNFDQAgAygCBCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBxhE2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCCCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB9go2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCDCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB7Ro2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCECIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBlRA2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCFCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBqhs2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCGCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB7RM2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCKCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABB9gg2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCHCIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBwhk2AhBBGCEECyAECz4BAn8CQCAAKAI4IgNFDQAgAygCICIDRQ0AIAAgASACIAFrIAMRAQAiBEF/Rw0AIABBlBQ2AhBBGCEECyAEC1kBAn8CQCAALQAoQQFGDQAgAC8BMiIBQeQAa0HkAEkNACABQcwBRg0AIAFBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhAiAAQYgEcUGABEYNACAAQShxRSECCyACC4wBAQJ/AkACQAJAIAAtACpFDQAgAC0AK0UNACAALwEwIgFBAnFFDQEMAgsgAC8BMCIBQQFxRQ0BC0EBIQIgAC0AKEEBRg0AIAAvATIiAEHkAGtB5ABJDQAgAEHMAUYNACAAQbACRg0AIAFBwABxDQBBACECIAFBiARxQYAERg0AIAFBKHFBAEchAgsgAgtzACAAQRBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAA/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAAQTBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAAQSBq/QwAAAAAAAAAAAAAAAAAAAAA/QsDACAAQd0BNgIcCwYAIAAQMguaLQELfyMAQRBrIgokAEGk0AAoAgAiCUUEQEHk0wAoAgAiBUUEQEHw0wBCfzcCAEHo0wBCgICEgICAwAA3AgBB5NMAIApBCGpBcHFB2KrVqgVzIgU2AgBB+NMAQQA2AgBByNMAQQA2AgALQczTAEGA1AQ2AgBBnNAAQYDUBDYCAEGw0AAgBTYCAEGs0ABBfzYCAEHQ0wBBgKwDNgIAA0AgAUHI0ABqIAFBvNAAaiICNgIAIAIgAUG00ABqIgM2AgAgAUHA0ABqIAM2AgAgAUHQ0ABqIAFBxNAAaiIDNgIAIAMgAjYCACABQdjQAGogAUHM0ABqIgI2AgAgAiADNgIAIAFB1NAAaiACNgIAIAFBIGoiAUGAAkcNAAtBjNQEQcGrAzYCAEGo0ABB9NMAKAIANgIAQZjQAEHAqwM2AgBBpNAAQYjUBDYCAEHM/wdBODYCAEGI1AQhCQsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAQewBTQRAQYzQACgCACIGQRAgAEETakFwcSAAQQtJGyIEQQN2IgB2IgFBA3EEQAJAIAFBAXEgAHJBAXMiAkEDdCIAQbTQAGoiASAAQbzQAGooAgAiACgCCCIDRgRAQYzQACAGQX4gAndxNgIADAELIAEgAzYCCCADIAE2AgwLIABBCGohASAAIAJBA3QiAkEDcjYCBCAAIAJqIgAgACgCBEEBcjYCBAwRC0GU0AAoAgAiCCAETw0BIAEEQAJAQQIgAHQiAkEAIAJrciABIAB0cWgiAEEDdCICQbTQAGoiASACQbzQAGooAgAiAigCCCIDRgRAQYzQACAGQX4gAHdxIgY2AgAMAQsgASADNgIIIAMgATYCDAsgAiAEQQNyNgIEIABBA3QiACAEayEFIAAgAmogBTYCACACIARqIgQgBUEBcjYCBCAIBEAgCEF4cUG00ABqIQBBoNAAKAIAIQMCf0EBIAhBA3Z0IgEgBnFFBEBBjNAAIAEgBnI2AgAgAAwBCyAAKAIICyIBIAM2AgwgACADNgIIIAMgADYCDCADIAE2AggLIAJBCGohAUGg0AAgBDYCAEGU0AAgBTYCAAwRC0GQ0AAoAgAiC0UNASALaEECdEG80gBqKAIAIgAoAgRBeHEgBGshBSAAIQIDQAJAIAIoAhAiAUUEQCACQRRqKAIAIgFFDQELIAEoAgRBeHEgBGsiAyAFSSECIAMgBSACGyEFIAEgACACGyEAIAEhAgwBCwsgACgCGCEJIAAoAgwiAyAARwRAQZzQACgCABogAyAAKAIIIgE2AgggASADNgIMDBALIABBFGoiAigCACIBRQRAIAAoAhAiAUUNAyAAQRBqIQILA0AgAiEHIAEiA0EUaiICKAIAIgENACADQRBqIQIgAygCECIBDQALIAdBADYCAAwPC0F/IQQgAEG/f0sNACAAQRNqIgFBcHEhBEGQ0AAoAgAiCEUNAEEAIARrIQUCQAJAAkACf0EAIARBgAJJDQAaQR8gBEH///8HSw0AGiAEQSYgAUEIdmciAGt2QQFxIABBAXRrQT5qCyIGQQJ0QbzSAGooAgAiAkUEQEEAIQFBACEDDAELQQAhASAEQRkgBkEBdmtBACAGQR9HG3QhAEEAIQMDQAJAIAIoAgRBeHEgBGsiByAFTw0AIAIhAyAHIgUNAEEAIQUgAiEBDAMLIAEgAkEUaigCACIHIAcgAiAAQR12QQRxakEQaigCACICRhsgASAHGyEBIABBAXQhACACDQALCyABIANyRQRAQQAhA0ECIAZ0IgBBACAAa3IgCHEiAEUNAyAAaEECdEG80gBqKAIAIQELIAFFDQELA0AgASgCBEF4cSAEayICIAVJIQAgAiAFIAAbIQUgASADIAAbIQMgASgCECIABH8gAAUgAUEUaigCAAsiAQ0ACwsgA0UNACAFQZTQACgCACAEa08NACADKAIYIQcgAyADKAIMIgBHBEBBnNAAKAIAGiAAIAMoAggiATYCCCABIAA2AgwMDgsgA0EUaiICKAIAIgFFBEAgAygCECIBRQ0DIANBEGohAgsDQCACIQYgASIAQRRqIgIoAgAiAQ0AIABBEGohAiAAKAIQIgENAAsgBkEANgIADA0LQZTQACgCACIDIARPBEBBoNAAKAIAIQECQCADIARrIgJBEE8EQCABIARqIgAgAkEBcjYCBCABIANqIAI2AgAgASAEQQNyNgIEDAELIAEgA0EDcjYCBCABIANqIgAgACgCBEEBcjYCBEEAIQBBACECC0GU0AAgAjYCAEGg0AAgADYCACABQQhqIQEMDwtBmNAAKAIAIgMgBEsEQCAEIAlqIgAgAyAEayIBQQFyNgIEQaTQACAANgIAQZjQACABNgIAIAkgBEEDcjYCBCAJQQhqIQEMDwtBACEBIAQCf0Hk0wAoAgAEQEHs0wAoAgAMAQtB8NMAQn83AgBB6NMAQoCAhICAgMAANwIAQeTTACAKQQxqQXBxQdiq1aoFczYCAEH40wBBADYCAEHI0wBBADYCAEGAgAQLIgAgBEHHAGoiBWoiBkEAIABrIgdxIgJPBEBB/NMAQTA2AgAMDwsCQEHE0wAoAgAiAUUNAEG80wAoAgAiCCACaiEAIAAgAU0gACAIS3ENAEEAIQFB/NMAQTA2AgAMDwtByNMALQAAQQRxDQQCQAJAIAkEQEHM0wAhAQNAIAEoAgAiACAJTQRAIAAgASgCBGogCUsNAwsgASgCCCIBDQALC0EAEDMiAEF/Rg0FIAIhBkHo0wAoAgAiAUEBayIDIABxBEAgAiAAayAAIANqQQAgAWtxaiEGCyAEIAZPDQUgBkH+////B0sNBUHE0wAoAgAiAwRAQbzTACgCACIHIAZqIQEgASAHTQ0GIAEgA0sNBgsgBhAzIgEgAEcNAQwHCyAGIANrIAdxIgZB/v///wdLDQQgBhAzIQAgACABKAIAIAEoAgRqRg0DIAAhAQsCQCAGIARByABqTw0AIAFBf0YNAEHs0wAoAgAiACAFIAZrakEAIABrcSIAQf7///8HSwRAIAEhAAwHCyAAEDNBf0cEQCAAIAZqIQYgASEADAcLQQAgBmsQMxoMBAsgASIAQX9HDQUMAwtBACEDDAwLQQAhAAwKCyAAQX9HDQILQcjTAEHI0wAoAgBBBHI2AgALIAJB/v///wdLDQEgAhAzIQBBABAzIQEgAEF/Rg0BIAFBf0YNASAAIAFPDQEgASAAayIGIARBOGpNDQELQbzTAEG80wAoAgAgBmoiATYCAEHA0wAoAgAgAUkEQEHA0wAgATYCAAsCQAJAAkBBpNAAKAIAIgIEQEHM0wAhAQNAIAAgASgCACIDIAEoAgQiBWpGDQIgASgCCCIBDQALDAILQZzQACgCACIBQQBHIAAgAU9xRQRAQZzQACAANgIAC0EAIQFB0NMAIAY2AgBBzNMAIAA2AgBBrNAAQX82AgBBsNAAQeTTACgCADYCAEHY0wBBADYCAANAIAFByNAAaiABQbzQAGoiAjYCACACIAFBtNAAaiIDNgIAIAFBwNAAaiADNgIAIAFB0NAAaiABQcTQAGoiAzYCACADIAI2AgAgAUHY0ABqIAFBzNAAaiICNgIAIAIgAzYCACABQdTQAGogAjYCACABQSBqIgFBgAJHDQALQXggAGtBD3EiASAAaiICIAZBOGsiAyABayIBQQFyNgIEQajQAEH00wAoAgA2AgBBmNAAIAE2AgBBpNAAIAI2AgAgACADakE4NgIEDAILIAAgAk0NACACIANJDQAgASgCDEEIcQ0AQXggAmtBD3EiACACaiIDQZjQACgCACAGaiIHIABrIgBBAXI2AgQgASAFIAZqNgIEQajQAEH00wAoAgA2AgBBmNAAIAA2AgBBpNAAIAM2AgAgAiAHakE4NgIEDAELIABBnNAAKAIASQRAQZzQACAANgIACyAAIAZqIQNBzNMAIQECQAJAAkADQCADIAEoAgBHBEAgASgCCCIBDQEMAgsLIAEtAAxBCHFFDQELQczTACEBA0AgASgCACIDIAJNBEAgAyABKAIEaiIFIAJLDQMLIAEoAgghAQwACwALIAEgADYCACABIAEoAgQgBmo2AgQgAEF4IABrQQ9xaiIJIARBA3I2AgQgA0F4IANrQQ9xaiIGIAQgCWoiBGshASACIAZGBEBBpNAAIAQ2AgBBmNAAQZjQACgCACABaiIANgIAIAQgAEEBcjYCBAwIC0Gg0AAoAgAgBkYEQEGg0AAgBDYCAEGU0ABBlNAAKAIAIAFqIgA2AgAgBCAAQQFyNgIEIAAgBGogADYCAAwICyAGKAIEIgVBA3FBAUcNBiAFQXhxIQggBUH/AU0EQCAFQQN2IQMgBigCCCIAIAYoAgwiAkYEQEGM0ABBjNAAKAIAQX4gA3dxNgIADAcLIAIgADYCCCAAIAI2AgwMBgsgBigCGCEHIAYgBigCDCIARwRAIAAgBigCCCICNgIIIAIgADYCDAwFCyAGQRRqIgIoAgAiBUUEQCAGKAIQIgVFDQQgBkEQaiECCwNAIAIhAyAFIgBBFGoiAigCACIFDQAgAEEQaiECIAAoAhAiBQ0ACyADQQA2AgAMBAtBeCAAa0EPcSIBIABqIgcgBkE4ayIDIAFrIgFBAXI2AgQgACADakE4NgIEIAIgBUE3IAVrQQ9xakE/ayIDIAMgAkEQakkbIgNBIzYCBEGo0ABB9NMAKAIANgIAQZjQACABNgIAQaTQACAHNgIAIANBEGpB1NMAKQIANwIAIANBzNMAKQIANwIIQdTTACADQQhqNgIAQdDTACAGNgIAQczTACAANgIAQdjTAEEANgIAIANBJGohAQNAIAFBBzYCACAFIAFBBGoiAUsNAAsgAiADRg0AIAMgAygCBEF+cTYCBCADIAMgAmsiBTYCACACIAVBAXI2AgQgBUH/AU0EQCAFQXhxQbTQAGohAAJ/QYzQACgCACIBQQEgBUEDdnQiA3FFBEBBjNAAIAEgA3I2AgAgAAwBCyAAKAIICyIBIAI2AgwgACACNgIIIAIgADYCDCACIAE2AggMAQtBHyEBIAVB////B00EQCAFQSYgBUEIdmciAGt2QQFxIABBAXRrQT5qIQELIAIgATYCHCACQgA3AhAgAUECdEG80gBqIQBBkNAAKAIAIgNBASABdCIGcUUEQCAAIAI2AgBBkNAAIAMgBnI2AgAgAiAANgIYIAIgAjYCCCACIAI2AgwMAQsgBUEZIAFBAXZrQQAgAUEfRxt0IQEgACgCACEDAkADQCADIgAoAgRBeHEgBUYNASABQR12IQMgAUEBdCEBIAAgA0EEcWpBEGoiBigCACIDDQALIAYgAjYCACACIAA2AhggAiACNgIMIAIgAjYCCAwBCyAAKAIIIgEgAjYCDCAAIAI2AgggAkEANgIYIAIgADYCDCACIAE2AggLQZjQACgCACIBIARNDQBBpNAAKAIAIgAgBGoiAiABIARrIgFBAXI2AgRBmNAAIAE2AgBBpNAAIAI2AgAgACAEQQNyNgIEIABBCGohAQwIC0EAIQFB/NMAQTA2AgAMBwtBACEACyAHRQ0AAkAgBigCHCICQQJ0QbzSAGoiAygCACAGRgRAIAMgADYCACAADQFBkNAAQZDQACgCAEF+IAJ3cTYCAAwCCyAHQRBBFCAHKAIQIAZGG2ogADYCACAARQ0BCyAAIAc2AhggBigCECICBEAgACACNgIQIAIgADYCGAsgBkEUaigCACICRQ0AIABBFGogAjYCACACIAA2AhgLIAEgCGohASAGIAhqIgYoAgQhBQsgBiAFQX5xNgIEIAEgBGogATYCACAEIAFBAXI2AgQgAUH/AU0EQCABQXhxQbTQAGohAAJ/QYzQACgCACICQQEgAUEDdnQiAXFFBEBBjNAAIAEgAnI2AgAgAAwBCyAAKAIICyIBIAQ2AgwgACAENgIIIAQgADYCDCAEIAE2AggMAQtBHyEFIAFB////B00EQCABQSYgAUEIdmciAGt2QQFxIABBAXRrQT5qIQULIAQgBTYCHCAEQgA3AhAgBUECdEG80gBqIQBBkNAAKAIAIgJBASAFdCIDcUUEQCAAIAQ2AgBBkNAAIAIgA3I2AgAgBCAANgIYIAQgBDYCCCAEIAQ2AgwMAQsgAUEZIAVBAXZrQQAgBUEfRxt0IQUgACgCACEAAkADQCAAIgIoAgRBeHEgAUYNASAFQR12IQAgBUEBdCEFIAIgAEEEcWpBEGoiAygCACIADQALIAMgBDYCACAEIAI2AhggBCAENgIMIAQgBDYCCAwBCyACKAIIIgAgBDYCDCACIAQ2AgggBEEANgIYIAQgAjYCDCAEIAA2AggLIAlBCGohAQwCCwJAIAdFDQACQCADKAIcIgFBAnRBvNIAaiICKAIAIANGBEAgAiAANgIAIAANAUGQ0AAgCEF+IAF3cSIINgIADAILIAdBEEEUIAcoAhAgA0YbaiAANgIAIABFDQELIAAgBzYCGCADKAIQIgEEQCAAIAE2AhAgASAANgIYCyADQRRqKAIAIgFFDQAgAEEUaiABNgIAIAEgADYCGAsCQCAFQQ9NBEAgAyAEIAVqIgBBA3I2AgQgACADaiIAIAAoAgRBAXI2AgQMAQsgAyAEaiICIAVBAXI2AgQgAyAEQQNyNgIEIAIgBWogBTYCACAFQf8BTQRAIAVBeHFBtNAAaiEAAn9BjNAAKAIAIgFBASAFQQN2dCIFcUUEQEGM0AAgASAFcjYCACAADAELIAAoAggLIgEgAjYCDCAAIAI2AgggAiAANgIMIAIgATYCCAwBC0EfIQEgBUH///8HTQRAIAVBJiAFQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAQsgAiABNgIcIAJCADcCECABQQJ0QbzSAGohAEEBIAF0IgQgCHFFBEAgACACNgIAQZDQACAEIAhyNgIAIAIgADYCGCACIAI2AgggAiACNgIMDAELIAVBGSABQQF2a0EAIAFBH0cbdCEBIAAoAgAhBAJAA0AgBCIAKAIEQXhxIAVGDQEgAUEddiEEIAFBAXQhASAAIARBBHFqQRBqIgYoAgAiBA0ACyAGIAI2AgAgAiAANgIYIAIgAjYCDCACIAI2AggMAQsgACgCCCIBIAI2AgwgACACNgIIIAJBADYCGCACIAA2AgwgAiABNgIICyADQQhqIQEMAQsCQCAJRQ0AAkAgACgCHCIBQQJ0QbzSAGoiAigCACAARgRAIAIgAzYCACADDQFBkNAAIAtBfiABd3E2AgAMAgsgCUEQQRQgCSgCECAARhtqIAM2AgAgA0UNAQsgAyAJNgIYIAAoAhAiAQRAIAMgATYCECABIAM2AhgLIABBFGooAgAiAUUNACADQRRqIAE2AgAgASADNgIYCwJAIAVBD00EQCAAIAQgBWoiAUEDcjYCBCAAIAFqIgEgASgCBEEBcjYCBAwBCyAAIARqIgcgBUEBcjYCBCAAIARBA3I2AgQgBSAHaiAFNgIAIAgEQCAIQXhxQbTQAGohAUGg0AAoAgAhAwJ/QQEgCEEDdnQiAiAGcUUEQEGM0AAgAiAGcjYCACABDAELIAEoAggLIgIgAzYCDCABIAM2AgggAyABNgIMIAMgAjYCCAtBoNAAIAc2AgBBlNAAIAU2AgALIABBCGohAQsgCkEQaiQAIAELQwAgAEUEQD8AQRB0DwsCQCAAQf//A3ENACAAQQBIDQAgAEEQdkAAIgBBf0YEQEH80wBBMDYCAEF/DwsgAEEQdA8LAAsL3D8iAEGACAsJAQAAAAIAAAADAEGUCAsFBAAAAAUAQaQICwkGAAAABwAAAAgAQdwIC4otSW52YWxpZCBjaGFyIGluIHVybCBxdWVyeQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2JvZHkAQ29udGVudC1MZW5ndGggb3ZlcmZsb3cAQ2h1bmsgc2l6ZSBvdmVyZmxvdwBSZXNwb25zZSBvdmVyZmxvdwBJbnZhbGlkIG1ldGhvZCBmb3IgSFRUUC94LnggcmVxdWVzdABJbnZhbGlkIG1ldGhvZCBmb3IgUlRTUC94LnggcmVxdWVzdABFeHBlY3RlZCBTT1VSQ0UgbWV0aG9kIGZvciBJQ0UveC54IHJlcXVlc3QASW52YWxpZCBjaGFyIGluIHVybCBmcmFnbWVudCBzdGFydABFeHBlY3RlZCBkb3QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9zdGF0dXMASW52YWxpZCByZXNwb25zZSBzdGF0dXMASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucwBVc2VyIGNhbGxiYWNrIGVycm9yAGBvbl9yZXNldGAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2hlYWRlcmAgY2FsbGJhY2sgZXJyb3IAYG9uX21lc3NhZ2VfYmVnaW5gIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19leHRlbnNpb25fdmFsdWVgIGNhbGxiYWNrIGVycm9yAGBvbl9zdGF0dXNfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl92ZXJzaW9uX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdXJsX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWV0aG9kX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX25hbWVgIGNhbGxiYWNrIGVycm9yAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2VydmVyAEludmFsaWQgaGVhZGVyIHZhbHVlIGNoYXIASW52YWxpZCBoZWFkZXIgZmllbGQgY2hhcgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3ZlcnNpb24ASW52YWxpZCBtaW5vciB2ZXJzaW9uAEludmFsaWQgbWFqb3IgdmVyc2lvbgBFeHBlY3RlZCBzcGFjZSBhZnRlciB2ZXJzaW9uAEV4cGVjdGVkIENSTEYgYWZ0ZXIgdmVyc2lvbgBJbnZhbGlkIEhUVFAgdmVyc2lvbgBJbnZhbGlkIGhlYWRlciB0b2tlbgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3VybABJbnZhbGlkIGNoYXJhY3RlcnMgaW4gdXJsAFVuZXhwZWN0ZWQgc3RhcnQgY2hhciBpbiB1cmwARG91YmxlIEAgaW4gdXJsAEVtcHR5IENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhcmFjdGVyIGluIENvbnRlbnQtTGVuZ3RoAER1cGxpY2F0ZSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXIgaW4gdXJsIHBhdGgAQ29udGVudC1MZW5ndGggY2FuJ3QgYmUgcHJlc2VudCB3aXRoIFRyYW5zZmVyLUVuY29kaW5nAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIHNpemUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfdmFsdWUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyB2YWx1ZQBNaXNzaW5nIGV4cGVjdGVkIExGIGFmdGVyIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AgaGVhZGVyIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGUgdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZWQgdmFsdWUAUGF1c2VkIGJ5IG9uX2hlYWRlcnNfY29tcGxldGUASW52YWxpZCBFT0Ygc3RhdGUAb25fcmVzZXQgcGF1c2UAb25fY2h1bmtfaGVhZGVyIHBhdXNlAG9uX21lc3NhZ2VfYmVnaW4gcGF1c2UAb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlIHBhdXNlAG9uX3N0YXR1c19jb21wbGV0ZSBwYXVzZQBvbl92ZXJzaW9uX2NvbXBsZXRlIHBhdXNlAG9uX3VybF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGUgcGF1c2UAb25fbWVzc2FnZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXRob2RfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lIHBhdXNlAFVuZXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgc3RhcnQgbGluZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgbmFtZQBQYXVzZSBvbiBDT05ORUNUL1VwZ3JhZGUAUGF1c2Ugb24gUFJJL1VwZ3JhZGUARXhwZWN0ZWQgSFRUUC8yIENvbm5lY3Rpb24gUHJlZmFjZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX21ldGhvZABFeHBlY3RlZCBzcGFjZSBhZnRlciBtZXRob2QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfZmllbGQAUGF1c2VkAEludmFsaWQgd29yZCBlbmNvdW50ZXJlZABJbnZhbGlkIG1ldGhvZCBlbmNvdW50ZXJlZABVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNjaGVtYQBSZXF1ZXN0IGhhcyBpbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AAU1dJVENIX1BST1hZAFVTRV9QUk9YWQBNS0FDVElWSVRZAFVOUFJPQ0VTU0FCTEVfRU5USVRZAENPUFkATU9WRURfUEVSTUFORU5UTFkAVE9PX0VBUkxZAE5PVElGWQBGQUlMRURfREVQRU5ERU5DWQBCQURfR0FURVdBWQBQTEFZAFBVVABDSEVDS09VVABHQVRFV0FZX1RJTUVPVVQAUkVRVUVTVF9USU1FT1VUAE5FVFdPUktfQ09OTkVDVF9USU1FT1VUAENPTk5FQ1RJT05fVElNRU9VVABMT0dJTl9USU1FT1VUAE5FVFdPUktfUkVBRF9USU1FT1VUAFBPU1QATUlTRElSRUNURURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9MT0FEX0JBTEFOQ0VEX1JFUVVFU1QAQkFEX1JFUVVFU1QASFRUUF9SRVFVRVNUX1NFTlRfVE9fSFRUUFNfUE9SVABSRVBPUlQASU1fQV9URUFQT1QAUkVTRVRfQ09OVEVOVABOT19DT05URU5UAFBBUlRJQUxfQ09OVEVOVABIUEVfSU5WQUxJRF9DT05TVEFOVABIUEVfQ0JfUkVTRVQAR0VUAEhQRV9TVFJJQ1QAQ09ORkxJQ1QAVEVNUE9SQVJZX1JFRElSRUNUAFBFUk1BTkVOVF9SRURJUkVDVABDT05ORUNUAE1VTFRJX1NUQVRVUwBIUEVfSU5WQUxJRF9TVEFUVVMAVE9PX01BTllfUkVRVUVTVFMARUFSTFlfSElOVFMAVU5BVkFJTEFCTEVfRk9SX0xFR0FMX1JFQVNPTlMAT1BUSU9OUwBTV0lUQ0hJTkdfUFJPVE9DT0xTAFZBUklBTlRfQUxTT19ORUdPVElBVEVTAE1VTFRJUExFX0NIT0lDRVMASU5URVJOQUxfU0VSVkVSX0VSUk9SAFdFQl9TRVJWRVJfVU5LTk9XTl9FUlJPUgBSQUlMR1VOX0VSUk9SAElERU5USVRZX1BST1ZJREVSX0FVVEhFTlRJQ0FUSU9OX0VSUk9SAFNTTF9DRVJUSUZJQ0FURV9FUlJPUgBJTlZBTElEX1hfRk9SV0FSREVEX0ZPUgBTRVRfUEFSQU1FVEVSAEdFVF9QQVJBTUVURVIASFBFX1VTRVIAU0VFX09USEVSAEhQRV9DQl9DSFVOS19IRUFERVIATUtDQUxFTkRBUgBTRVRVUABXRUJfU0VSVkVSX0lTX0RPV04AVEVBUkRPV04ASFBFX0NMT1NFRF9DT05ORUNUSU9OAEhFVVJJU1RJQ19FWFBJUkFUSU9OAERJU0NPTk5FQ1RFRF9PUEVSQVRJT04ATk9OX0FVVEhPUklUQVRJVkVfSU5GT1JNQVRJT04ASFBFX0lOVkFMSURfVkVSU0lPTgBIUEVfQ0JfTUVTU0FHRV9CRUdJTgBTSVRFX0lTX0ZST1pFTgBIUEVfSU5WQUxJRF9IRUFERVJfVE9LRU4ASU5WQUxJRF9UT0tFTgBGT1JCSURERU4ARU5IQU5DRV9ZT1VSX0NBTE0ASFBFX0lOVkFMSURfVVJMAEJMT0NLRURfQllfUEFSRU5UQUxfQ09OVFJPTABNS0NPTABBQ0wASFBFX0lOVEVSTkFMAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0VfVU5PRkZJQ0lBTABIUEVfT0sAVU5MSU5LAFVOTE9DSwBQUkkAUkVUUllfV0lUSABIUEVfSU5WQUxJRF9DT05URU5UX0xFTkdUSABIUEVfVU5FWFBFQ1RFRF9DT05URU5UX0xFTkdUSABGTFVTSABQUk9QUEFUQ0gATS1TRUFSQ0gAVVJJX1RPT19MT05HAFBST0NFU1NJTkcATUlTQ0VMTEFORU9VU19QRVJTSVNURU5UX1dBUk5JTkcATUlTQ0VMTEFORU9VU19XQVJOSU5HAEhQRV9JTlZBTElEX1RSQU5TRkVSX0VOQ09ESU5HAEV4cGVjdGVkIENSTEYASFBFX0lOVkFMSURfQ0hVTktfU0laRQBNT1ZFAENPTlRJTlVFAEhQRV9DQl9TVEFUVVNfQ09NUExFVEUASFBFX0NCX0hFQURFUlNfQ09NUExFVEUASFBFX0NCX1ZFUlNJT05fQ09NUExFVEUASFBFX0NCX1VSTF9DT01QTEVURQBIUEVfQ0JfQ0hVTktfQ09NUExFVEUASFBFX0NCX0hFQURFUl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fTkFNRV9DT01QTEVURQBIUEVfQ0JfTUVTU0FHRV9DT01QTEVURQBIUEVfQ0JfTUVUSE9EX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfRklFTERfQ09NUExFVEUAREVMRVRFAEhQRV9JTlZBTElEX0VPRl9TVEFURQBJTlZBTElEX1NTTF9DRVJUSUZJQ0FURQBQQVVTRQBOT19SRVNQT05TRQBVTlNVUFBPUlRFRF9NRURJQV9UWVBFAEdPTkUATk9UX0FDQ0VQVEFCTEUAU0VSVklDRV9VTkFWQUlMQUJMRQBSQU5HRV9OT1RfU0FUSVNGSUFCTEUAT1JJR0lOX0lTX1VOUkVBQ0hBQkxFAFJFU1BPTlNFX0lTX1NUQUxFAFBVUkdFAE1FUkdFAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0UAUkVRVUVTVF9IRUFERVJfVE9PX0xBUkdFAFBBWUxPQURfVE9PX0xBUkdFAElOU1VGRklDSUVOVF9TVE9SQUdFAEhQRV9QQVVTRURfVVBHUkFERQBIUEVfUEFVU0VEX0gyX1VQR1JBREUAU09VUkNFAEFOTk9VTkNFAFRSQUNFAEhQRV9VTkVYUEVDVEVEX1NQQUNFAERFU0NSSUJFAFVOU1VCU0NSSUJFAFJFQ09SRABIUEVfSU5WQUxJRF9NRVRIT0QATk9UX0ZPVU5EAFBST1BGSU5EAFVOQklORABSRUJJTkQAVU5BVVRIT1JJWkVEAE1FVEhPRF9OT1RfQUxMT1dFRABIVFRQX1ZFUlNJT05fTk9UX1NVUFBPUlRFRABBTFJFQURZX1JFUE9SVEVEAEFDQ0VQVEVEAE5PVF9JTVBMRU1FTlRFRABMT09QX0RFVEVDVEVEAEhQRV9DUl9FWFBFQ1RFRABIUEVfTEZfRVhQRUNURUQAQ1JFQVRFRABJTV9VU0VEAEhQRV9QQVVTRUQAVElNRU9VVF9PQ0NVUkVEAFBBWU1FTlRfUkVRVUlSRUQAUFJFQ09ORElUSU9OX1JFUVVJUkVEAFBST1hZX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAE5FVFdPUktfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATEVOR1RIX1JFUVVJUkVEAFNTTF9DRVJUSUZJQ0FURV9SRVFVSVJFRABVUEdSQURFX1JFUVVJUkVEAFBBR0VfRVhQSVJFRABQUkVDT05ESVRJT05fRkFJTEVEAEVYUEVDVEFUSU9OX0ZBSUxFRABSRVZBTElEQVRJT05fRkFJTEVEAFNTTF9IQU5EU0hBS0VfRkFJTEVEAExPQ0tFRABUUkFOU0ZPUk1BVElPTl9BUFBMSUVEAE5PVF9NT0RJRklFRABOT1RfRVhURU5ERUQAQkFORFdJRFRIX0xJTUlUX0VYQ0VFREVEAFNJVEVfSVNfT1ZFUkxPQURFRABIRUFEAEV4cGVjdGVkIEhUVFAvAABeEwAAJhMAADAQAADwFwAAnRMAABUSAAA5FwAA8BIAAAoQAAB1EgAArRIAAIITAABPFAAAfxAAAKAVAAAjFAAAiRIAAIsUAABNFQAA1BEAAM8UAAAQGAAAyRYAANwWAADBEQAA4BcAALsUAAB0FAAAfBUAAOUUAAAIFwAAHxAAAGUVAACjFAAAKBUAAAIVAACZFQAALBAAAIsZAABPDwAA1A4AAGoQAADOEAAAAhcAAIkOAABuEwAAHBMAAGYUAABWFwAAwRMAAM0TAABsEwAAaBcAAGYXAABfFwAAIhMAAM4PAABpDgAA2A4AAGMWAADLEwAAqg4AACgXAAAmFwAAxRMAAF0WAADoEQAAZxMAAGUTAADyFgAAcxMAAB0XAAD5FgAA8xEAAM8OAADOFQAADBIAALMRAAClEQAAYRAAADIXAAC7EwBB+TULAQEAQZA2C+ABAQECAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAQf03CwEBAEGROAteAgMCAgICAgAAAgIAAgIAAgICAgICAgICAgAEAAAAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAIAAgBB/TkLAQEAQZE6C14CAAICAgICAAACAgACAgACAgICAgICAgICAAMABAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAgACAEHwOwsNbG9zZWVlcC1hbGl2ZQBBiTwLAQEAQaA8C+ABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAQYk+CwEBAEGgPgvnAQEBAQEBAQEBAQEBAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBY2h1bmtlZABBsMAAC18BAQABAQEBAQAAAQEAAQEAAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQBBkMIACyFlY3Rpb25lbnQtbGVuZ3Rob25yb3h5LWNvbm5lY3Rpb24AQcDCAAstcmFuc2Zlci1lbmNvZGluZ3BncmFkZQ0KDQoNClNNDQoNClRUUC9DRS9UU1AvAEH5wgALBQECAAEDAEGQwwAL4AEEAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB+cQACwUBAgABAwBBkMUAC+ABBAEBBQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAQfnGAAsEAQAAAQBBkccAC98BAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBB+sgACwQBAAACAEGQyQALXwMEAAAEBAQEBAQEBAQEBAUEBAQEBAQEBAQEBAQABAAGBwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEAEH6ygALBAEAAAEAQZDLAAsBAQBBqssAC0ECAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBB+swACwQBAAABAEGQzQALAQEAQZrNAAsGAgAAAAACAEGxzQALOgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAQfDOAAuWAU5PVU5DRUVDS09VVE5FQ1RFVEVDUklCRUxVU0hFVEVBRFNFQVJDSFJHRUNUSVZJVFlMRU5EQVJWRU9USUZZUFRJT05TQ0hTRUFZU1RBVENIR0VPUkRJUkVDVE9SVFJDSFBBUkFNRVRFUlVSQ0VCU0NSSUJFQVJET1dOQUNFSU5ETktDS1VCU0NSSUJFSFRUUC9BRFRQLw==", "base64");
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/constants.js
-var require_constants4 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/constants.js"(exports2, module2) {
-    "use strict";
-    var corsSafeListedMethods = (
-      /** @type {const} */
-      ["GET", "HEAD", "POST"]
-    );
-    var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
-    var nullBodyStatus = (
-      /** @type {const} */
-      [101, 204, 205, 304]
-    );
-    var redirectStatus = (
-      /** @type {const} */
-      [301, 302, 303, 307, 308]
-    );
-    var redirectStatusSet = new Set(redirectStatus);
-    var badPorts = (
-      /** @type {const} */
-      [
-        "1",
-        "7",
-        "9",
-        "11",
-        "13",
-        "15",
-        "17",
-        "19",
-        "20",
-        "21",
-        "22",
-        "23",
-        "25",
-        "37",
-        "42",
-        "43",
-        "53",
-        "69",
-        "77",
-        "79",
-        "87",
-        "95",
-        "101",
-        "102",
-        "103",
-        "104",
-        "109",
-        "110",
-        "111",
-        "113",
-        "115",
-        "117",
-        "119",
-        "123",
-        "135",
-        "137",
-        "139",
-        "143",
-        "161",
-        "179",
-        "389",
-        "427",
-        "465",
-        "512",
-        "513",
-        "514",
-        "515",
-        "526",
-        "530",
-        "531",
-        "532",
-        "540",
-        "548",
-        "554",
-        "556",
-        "563",
-        "587",
-        "601",
-        "636",
-        "989",
-        "990",
-        "993",
-        "995",
-        "1719",
-        "1720",
-        "1723",
-        "2049",
-        "3659",
-        "4045",
-        "4190",
-        "5060",
-        "5061",
-        "6000",
-        "6566",
-        "6665",
-        "6666",
-        "6667",
-        "6668",
-        "6669",
-        "6679",
-        "6697",
-        "10080"
-      ]
-    );
-    var badPortsSet = new Set(badPorts);
-    var referrerPolicy = (
-      /** @type {const} */
-      [
-        "",
-        "no-referrer",
-        "no-referrer-when-downgrade",
-        "same-origin",
-        "origin",
-        "strict-origin",
-        "origin-when-cross-origin",
-        "strict-origin-when-cross-origin",
-        "unsafe-url"
-      ]
-    );
-    var referrerPolicySet = new Set(referrerPolicy);
-    var requestRedirect = (
-      /** @type {const} */
-      ["follow", "manual", "error"]
-    );
-    var safeMethods = (
-      /** @type {const} */
-      ["GET", "HEAD", "OPTIONS", "TRACE"]
-    );
-    var safeMethodsSet = new Set(safeMethods);
-    var requestMode = (
-      /** @type {const} */
-      ["navigate", "same-origin", "no-cors", "cors"]
-    );
-    var requestCredentials = (
-      /** @type {const} */
-      ["omit", "same-origin", "include"]
-    );
-    var requestCache = (
-      /** @type {const} */
-      [
-        "default",
-        "no-store",
-        "reload",
-        "no-cache",
-        "force-cache",
-        "only-if-cached"
-      ]
-    );
-    var requestBodyHeader = (
-      /** @type {const} */
-      [
-        "content-encoding",
-        "content-language",
-        "content-location",
-        "content-type",
-        // See https://github.com/nodejs/undici/issues/2021
-        // 'Content-Length' is a forbidden header name, which is typically
-        // removed in the Headers implementation. However, undici doesn't
-        // filter out headers, so we add it here.
-        "content-length"
-      ]
-    );
-    var requestDuplex = (
-      /** @type {const} */
-      [
-        "half"
-      ]
-    );
-    var forbiddenMethods = (
-      /** @type {const} */
-      ["CONNECT", "TRACE", "TRACK"]
-    );
-    var forbiddenMethodsSet = new Set(forbiddenMethods);
-    var subresource = (
-      /** @type {const} */
-      [
-        "audio",
-        "audioworklet",
-        "font",
-        "image",
-        "manifest",
-        "paintworklet",
-        "script",
-        "style",
-        "track",
-        "video",
-        "xslt",
-        ""
-      ]
-    );
-    var subresourceSet = new Set(subresource);
-    module2.exports = {
-      subresource,
-      forbiddenMethods,
-      requestBodyHeader,
-      referrerPolicy,
-      requestRedirect,
-      requestMode,
-      requestCredentials,
-      requestCache,
-      redirectStatus,
-      corsSafeListedMethods,
-      nullBodyStatus,
-      safeMethods,
-      badPorts,
-      requestDuplex,
-      subresourceSet,
-      badPortsSet,
-      redirectStatusSet,
-      corsSafeListedMethodsSet,
-      safeMethodsSet,
-      forbiddenMethodsSet,
-      referrerPolicySet
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/global.js
-var require_global = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/global.js"(exports2, module2) {
-    "use strict";
-    var globalOrigin = /* @__PURE__ */ Symbol.for("undici.globalOrigin.1");
-    function getGlobalOrigin() {
-      return globalThis[globalOrigin];
-    }
-    function setGlobalOrigin(newOrigin) {
-      if (newOrigin === void 0) {
-        Object.defineProperty(globalThis, globalOrigin, {
-          value: void 0,
-          writable: true,
-          enumerable: false,
-          configurable: false
+      /**
+       * Return a void Promise that resolves once the stream ends.
+       */
+      async promise() {
+        return new Promise((resolve, reject) => {
+          this.on(DESTROYED, () => reject(new Error("stream destroyed")));
+          this.on("error", (er) => reject(er));
+          this.on("end", () => resolve());
         });
-        return;
-      }
-      const parsedURL = new URL(newOrigin);
-      if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
-        throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
       }
-      Object.defineProperty(globalThis, globalOrigin, {
-        value: parsedURL,
-        writable: true,
-        enumerable: false,
-        configurable: false
-      });
-    }
-    module2.exports = {
-      getGlobalOrigin,
-      setGlobalOrigin
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/data-url.js
-var require_data_url = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/data-url.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var encoder = new TextEncoder();
-    var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/;
-    var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/;
-    var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g;
-    var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
-    function dataURLProcessor(dataURL) {
-      assert5(dataURL.protocol === "data:");
-      let input = URLSerializer(dataURL, true);
-      input = input.slice(5);
-      const position = { position: 0 };
-      let mimeType = collectASequenceOfCodePointsFast(
-        ",",
-        input,
-        position
-      );
-      const mimeTypeLength = mimeType.length;
-      mimeType = removeASCIIWhitespace(mimeType, true, true);
-      if (position.position >= input.length) {
-        return "failure";
-      }
-      position.position++;
-      const encodedBody = input.slice(mimeTypeLength + 1);
-      let body = stringPercentDecode(encodedBody);
-      if (/;(\u0020){0,}base64$/i.test(mimeType)) {
-        const stringBody = isomorphicDecode(body);
-        body = forgivingBase64(stringBody);
-        if (body === "failure") {
-          return "failure";
-        }
-        mimeType = mimeType.slice(0, -6);
-        mimeType = mimeType.replace(/(\u0020)+$/, "");
-        mimeType = mimeType.slice(0, -1);
-      }
-      if (mimeType.startsWith(";")) {
-        mimeType = "text/plain" + mimeType;
-      }
-      let mimeTypeRecord = parseMIMEType(mimeType);
-      if (mimeTypeRecord === "failure") {
-        mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
-      }
-      return { mimeType: mimeTypeRecord, body };
-    }
-    function URLSerializer(url, excludeFragment = false) {
-      if (!excludeFragment) {
-        return url.href;
-      }
-      const href = url.href;
-      const hashLength = url.hash.length;
-      const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength);
-      if (!hashLength && href.endsWith("#")) {
-        return serialized.slice(0, -1);
+      /**
+       * Asynchronous `for await of` iteration.
+       *
+       * This will continue emitting all chunks until the stream terminates.
+       */
+      [Symbol.asyncIterator]() {
+        this[DISCARDED] = false;
+        let stopped = false;
+        const stop = async () => {
+          this.pause();
+          stopped = true;
+          return { value: void 0, done: true };
+        };
+        const next = () => {
+          if (stopped)
+            return stop();
+          const res = this.read();
+          if (res !== null)
+            return Promise.resolve({ done: false, value: res });
+          if (this[EOF])
+            return stop();
+          let resolve;
+          let reject;
+          const onerr = (er) => {
+            this.off("data", ondata);
+            this.off("end", onend);
+            this.off(DESTROYED, ondestroy);
+            stop();
+            reject(er);
+          };
+          const ondata = (value) => {
+            this.off("error", onerr);
+            this.off("end", onend);
+            this.off(DESTROYED, ondestroy);
+            this.pause();
+            resolve({ value, done: !!this[EOF] });
+          };
+          const onend = () => {
+            this.off("error", onerr);
+            this.off("data", ondata);
+            this.off(DESTROYED, ondestroy);
+            stop();
+            resolve({ done: true, value: void 0 });
+          };
+          const ondestroy = () => onerr(new Error("stream destroyed"));
+          return new Promise((res2, rej) => {
+            reject = rej;
+            resolve = res2;
+            this.once(DESTROYED, ondestroy);
+            this.once("error", onerr);
+            this.once("end", onend);
+            this.once("data", ondata);
+          });
+        };
+        return {
+          next,
+          throw: stop,
+          return: stop,
+          [Symbol.asyncIterator]() {
+            return this;
+          },
+          [Symbol.asyncDispose]: async () => {
+          }
+        };
       }
-      return serialized;
-    }
-    function collectASequenceOfCodePoints(condition, input, position) {
-      let result = "";
-      while (position.position < input.length && condition(input[position.position])) {
-        result += input[position.position];
-        position.position++;
+      /**
+       * Synchronous `for of` iteration.
+       *
+       * The iteration will terminate when the internal buffer runs out, even
+       * if the stream has not yet terminated.
+       */
+      [Symbol.iterator]() {
+        this[DISCARDED] = false;
+        let stopped = false;
+        const stop = () => {
+          this.pause();
+          this.off(ERROR, stop);
+          this.off(DESTROYED, stop);
+          this.off("end", stop);
+          stopped = true;
+          return { done: true, value: void 0 };
+        };
+        const next = () => {
+          if (stopped)
+            return stop();
+          const value = this.read();
+          return value === null ? stop() : { done: false, value };
+        };
+        this.once("end", stop);
+        this.once(ERROR, stop);
+        this.once(DESTROYED, stop);
+        return {
+          next,
+          throw: stop,
+          return: stop,
+          [Symbol.iterator]() {
+            return this;
+          },
+          [Symbol.dispose]: () => {
+          }
+        };
       }
-      return result;
-    }
-    function collectASequenceOfCodePointsFast(char, input, position) {
-      const idx = input.indexOf(char, position.position);
-      const start = position.position;
-      if (idx === -1) {
-        position.position = input.length;
-        return input.slice(start);
-      }
-      position.position = idx;
-      return input.slice(start, position.position);
-    }
-    function stringPercentDecode(input) {
-      const bytes = encoder.encode(input);
-      return percentDecode(bytes);
-    }
-    function isHexCharByte(byte) {
-      return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
-    }
-    function hexByteToNumber(byte) {
-      return (
-        // 0-9
-        byte >= 48 && byte <= 57 ? byte - 48 : (byte & 223) - 55
-      );
-    }
-    function percentDecode(input) {
-      const length = input.length;
-      const output = new Uint8Array(length);
-      let j = 0;
-      for (let i = 0; i < length; ++i) {
-        const byte = input[i];
-        if (byte !== 37) {
-          output[j++] = byte;
-        } else if (byte === 37 && !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))) {
-          output[j++] = 37;
-        } else {
-          output[j++] = hexByteToNumber(input[i + 1]) << 4 | hexByteToNumber(input[i + 2]);
-          i += 2;
+      /**
+       * Destroy a stream, preventing it from being used for any further purpose.
+       *
+       * If the stream has a `close()` method, then it will be called on
+       * destruction.
+       *
+       * After destruction, any attempt to write data, read data, or emit most
+       * events will be ignored.
+       *
+       * If an error argument is provided, then it will be emitted in an
+       * 'error' event.
+       */
+      destroy(er) {
+        if (this[DESTROYED]) {
+          if (er)
+            this.emit("error", er);
+          else
+            this.emit(DESTROYED);
+          return this;
         }
+        this[DESTROYED] = true;
+        this[DISCARDED] = true;
+        this[BUFFER].length = 0;
+        this[BUFFERLENGTH] = 0;
+        const wc = this;
+        if (typeof wc.close === "function" && !this[CLOSED])
+          wc.close();
+        if (er)
+          this.emit("error", er);
+        else
+          this.emit(DESTROYED);
+        return this;
       }
-      return length === j ? output : output.subarray(0, j);
-    }
-    function parseMIMEType(input) {
-      input = removeHTTPWhitespace(input, true, true);
-      const position = { position: 0 };
-      const type = collectASequenceOfCodePointsFast(
-        "/",
-        input,
-        position
-      );
-      if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
-        return "failure";
-      }
-      if (position.position > input.length) {
-        return "failure";
+      /**
+       * Alias for {@link isStream}
+       *
+       * Former export location, maintained for backwards compatibility.
+       *
+       * @deprecated
+       */
+      static get isStream() {
+        return isStream;
       }
-      position.position++;
-      let subtype = collectASequenceOfCodePointsFast(
-        ";",
-        input,
-        position
-      );
-      subtype = removeHTTPWhitespace(subtype, false, true);
-      if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
-        return "failure";
-      }
-      const typeLowercase = type.toLowerCase();
-      const subtypeLowercase = subtype.toLowerCase();
-      const mimeType = {
-        type: typeLowercase,
-        subtype: subtypeLowercase,
-        /** @type {Map<string, string>} */
-        parameters: /* @__PURE__ */ new Map(),
-        // https://mimesniff.spec.whatwg.org/#mime-type-essence
-        essence: `${typeLowercase}/${subtypeLowercase}`
-      };
-      while (position.position < input.length) {
-        position.position++;
-        collectASequenceOfCodePoints(
-          // https://fetch.spec.whatwg.org/#http-whitespace
-          (char) => HTTP_WHITESPACE_REGEX.test(char),
-          input,
-          position
-        );
-        let parameterName = collectASequenceOfCodePoints(
-          (char) => char !== ";" && char !== "=",
-          input,
-          position
-        );
-        parameterName = parameterName.toLowerCase();
-        if (position.position < input.length) {
-          if (input[position.position] === ";") {
-            continue;
-          }
-          position.position++;
-        }
-        if (position.position > input.length) {
-          break;
+    };
+  }
+});
+
+// node_modules/@isaacs/fs-minipass/dist/esm/index.js
+var import_events2, import_fs2, writev, _autoClose, _close, _ended, _fd, _finished, _flags, _flush, _handleChunk, _makeBuf, _mode, _needDrain, _onerror, _onopen, _onread, _onwrite, _open, _path, _pos, _queue, _read, _readSize, _reading, _remain, _size, _write, _writing, _defaultFlag, _errored, ReadStream, ReadStreamSync, WriteStream, WriteStreamSync;
+var init_esm2 = __esm({
+  "node_modules/@isaacs/fs-minipass/dist/esm/index.js"() {
+    import_events2 = __toESM(require("events"), 1);
+    import_fs2 = __toESM(require("fs"), 1);
+    init_esm();
+    writev = import_fs2.default.writev;
+    _autoClose = /* @__PURE__ */ Symbol("_autoClose");
+    _close = /* @__PURE__ */ Symbol("_close");
+    _ended = /* @__PURE__ */ Symbol("_ended");
+    _fd = /* @__PURE__ */ Symbol("_fd");
+    _finished = /* @__PURE__ */ Symbol("_finished");
+    _flags = /* @__PURE__ */ Symbol("_flags");
+    _flush = /* @__PURE__ */ Symbol("_flush");
+    _handleChunk = /* @__PURE__ */ Symbol("_handleChunk");
+    _makeBuf = /* @__PURE__ */ Symbol("_makeBuf");
+    _mode = /* @__PURE__ */ Symbol("_mode");
+    _needDrain = /* @__PURE__ */ Symbol("_needDrain");
+    _onerror = /* @__PURE__ */ Symbol("_onerror");
+    _onopen = /* @__PURE__ */ Symbol("_onopen");
+    _onread = /* @__PURE__ */ Symbol("_onread");
+    _onwrite = /* @__PURE__ */ Symbol("_onwrite");
+    _open = /* @__PURE__ */ Symbol("_open");
+    _path = /* @__PURE__ */ Symbol("_path");
+    _pos = /* @__PURE__ */ Symbol("_pos");
+    _queue = /* @__PURE__ */ Symbol("_queue");
+    _read = /* @__PURE__ */ Symbol("_read");
+    _readSize = /* @__PURE__ */ Symbol("_readSize");
+    _reading = /* @__PURE__ */ Symbol("_reading");
+    _remain = /* @__PURE__ */ Symbol("_remain");
+    _size = /* @__PURE__ */ Symbol("_size");
+    _write = /* @__PURE__ */ Symbol("_write");
+    _writing = /* @__PURE__ */ Symbol("_writing");
+    _defaultFlag = /* @__PURE__ */ Symbol("_defaultFlag");
+    _errored = /* @__PURE__ */ Symbol("_errored");
+    ReadStream = class extends Minipass {
+      [_errored] = false;
+      [_fd];
+      [_path];
+      [_readSize];
+      [_reading] = false;
+      [_size];
+      [_remain];
+      [_autoClose];
+      constructor(path16, opt) {
+        opt = opt || {};
+        super(opt);
+        this.readable = true;
+        this.writable = false;
+        if (typeof path16 !== "string") {
+          throw new TypeError("path must be a string");
         }
-        let parameterValue = null;
-        if (input[position.position] === '"') {
-          parameterValue = collectAnHTTPQuotedString(input, position, true);
-          collectASequenceOfCodePointsFast(
-            ";",
-            input,
-            position
-          );
+        this[_errored] = false;
+        this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
+        this[_path] = path16;
+        this[_readSize] = opt.readSize || 16 * 1024 * 1024;
+        this[_reading] = false;
+        this[_size] = typeof opt.size === "number" ? opt.size : Infinity;
+        this[_remain] = this[_size];
+        this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
+        if (typeof this[_fd] === "number") {
+          this[_read]();
         } else {
-          parameterValue = collectASequenceOfCodePointsFast(
-            ";",
-            input,
-            position
-          );
-          parameterValue = removeHTTPWhitespace(parameterValue, false, true);
-          if (parameterValue.length === 0) {
-            continue;
-          }
-        }
-        if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
-          mimeType.parameters.set(parameterName, parameterValue);
+          this[_open]();
         }
       }
-      return mimeType;
-    }
-    function forgivingBase64(data) {
-      data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, "");
-      let dataLength = data.length;
-      if (dataLength % 4 === 0) {
-        if (data.charCodeAt(dataLength - 1) === 61) {
-          --dataLength;
-          if (data.charCodeAt(dataLength - 1) === 61) {
-            --dataLength;
-          }
-        }
+      get fd() {
+        return this[_fd];
       }
-      if (dataLength % 4 === 1) {
-        return "failure";
+      get path() {
+        return this[_path];
       }
-      if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
-        return "failure";
+      //@ts-ignore
+      write() {
+        throw new TypeError("this is a readable stream");
       }
-      const buffer = Buffer.from(data, "base64");
-      return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    }
-    function collectAnHTTPQuotedString(input, position, extractValue) {
-      const positionStart = position.position;
-      let value = "";
-      assert5(input[position.position] === '"');
-      position.position++;
-      while (true) {
-        value += collectASequenceOfCodePoints(
-          (char) => char !== '"' && char !== "\\",
-          input,
-          position
-        );
-        if (position.position >= input.length) {
-          break;
-        }
-        const quoteOrBackslash = input[position.position];
-        position.position++;
-        if (quoteOrBackslash === "\\") {
-          if (position.position >= input.length) {
-            value += "\\";
-            break;
-          }
-          value += input[position.position];
-          position.position++;
-        } else {
-          assert5(quoteOrBackslash === '"');
-          break;
-        }
+      //@ts-ignore
+      end() {
+        throw new TypeError("this is a readable stream");
       }
-      if (extractValue) {
-        return value;
-      }
-      return input.slice(positionStart, position.position);
-    }
-    function serializeAMimeType(mimeType) {
-      assert5(mimeType !== "failure");
-      const { parameters, essence } = mimeType;
-      let serialization = essence;
-      for (let [name2, value] of parameters.entries()) {
-        serialization += ";";
-        serialization += name2;
-        serialization += "=";
-        if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
-          value = value.replace(/(\\|")/g, "\\$1");
-          value = '"' + value;
-          value += '"';
-        }
-        serialization += value;
-      }
-      return serialization;
-    }
-    function isHTTPWhiteSpace(char) {
-      return char === 13 || char === 10 || char === 9 || char === 32;
-    }
-    function removeHTTPWhitespace(str, leading = true, trailing = true) {
-      return removeChars(str, leading, trailing, isHTTPWhiteSpace);
-    }
-    function isASCIIWhitespace(char) {
-      return char === 13 || char === 10 || char === 9 || char === 12 || char === 32;
-    }
-    function removeASCIIWhitespace(str, leading = true, trailing = true) {
-      return removeChars(str, leading, trailing, isASCIIWhitespace);
-    }
-    function removeChars(str, leading, trailing, predicate) {
-      let lead = 0;
-      let trail = str.length - 1;
-      if (leading) {
-        while (lead < str.length && predicate(str.charCodeAt(lead))) lead++;
-      }
-      if (trailing) {
-        while (trail > 0 && predicate(str.charCodeAt(trail))) trail--;
-      }
-      return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
-    }
-    function isomorphicDecode(input) {
-      const length = input.length;
-      if ((2 << 15) - 1 > length) {
-        return String.fromCharCode.apply(null, input);
-      }
-      let result = "";
-      let i = 0;
-      let addition = (2 << 15) - 1;
-      while (i < length) {
-        if (i + addition > length) {
-          addition = length - i;
-        }
-        result += String.fromCharCode.apply(null, input.subarray(i, i += addition));
+      [_open]() {
+        import_fs2.default.open(this[_path], "r", (er, fd) => this[_onopen](er, fd));
       }
-      return result;
-    }
-    function minimizeSupportedMimeType(mimeType) {
-      switch (mimeType.essence) {
-        case "application/ecmascript":
-        case "application/javascript":
-        case "application/x-ecmascript":
-        case "application/x-javascript":
-        case "text/ecmascript":
-        case "text/javascript":
-        case "text/javascript1.0":
-        case "text/javascript1.1":
-        case "text/javascript1.2":
-        case "text/javascript1.3":
-        case "text/javascript1.4":
-        case "text/javascript1.5":
-        case "text/jscript":
-        case "text/livescript":
-        case "text/x-ecmascript":
-        case "text/x-javascript":
-          return "text/javascript";
-        case "application/json":
-        case "text/json":
-          return "application/json";
-        case "image/svg+xml":
-          return "image/svg+xml";
-        case "text/xml":
-        case "application/xml":
-          return "application/xml";
-      }
-      if (mimeType.subtype.endsWith("+json")) {
-        return "application/json";
-      }
-      if (mimeType.subtype.endsWith("+xml")) {
-        return "application/xml";
-      }
-      return "";
-    }
-    module2.exports = {
-      dataURLProcessor,
-      URLSerializer,
-      collectASequenceOfCodePoints,
-      collectASequenceOfCodePointsFast,
-      stringPercentDecode,
-      parseMIMEType,
-      collectAnHTTPQuotedString,
-      serializeAMimeType,
-      removeChars,
-      removeHTTPWhitespace,
-      minimizeSupportedMimeType,
-      HTTP_TOKEN_CODEPOINTS,
-      isomorphicDecode
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/webidl.js
-var require_webidl = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) {
-    "use strict";
-    var { types, inspect } = require("node:util");
-    var { markAsUncloneable } = require("node:worker_threads");
-    var { toUSVString } = require_util();
-    var webidl = {};
-    webidl.converters = {};
-    webidl.util = {};
-    webidl.errors = {};
-    webidl.errors.exception = function(message) {
-      return new TypeError(`${message.header}: ${message.message}`);
-    };
-    webidl.errors.conversionFailed = function(context) {
-      const plural2 = context.types.length === 1 ? "" : " one of";
-      const message = `${context.argument} could not be converted to${plural2}: ${context.types.join(", ")}.`;
-      return webidl.errors.exception({
-        header: context.prefix,
-        message
-      });
-    };
-    webidl.errors.invalidArgument = function(context) {
-      return webidl.errors.exception({
-        header: context.prefix,
-        message: `"${context.value}" is an invalid ${context.type}.`
-      });
-    };
-    webidl.brandCheck = function(V, I, opts) {
-      if (opts?.strict !== false) {
-        if (!(V instanceof I)) {
-          const err = new TypeError("Illegal invocation");
-          err.code = "ERR_INVALID_THIS";
-          throw err;
-        }
-      } else {
-        if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
-          const err = new TypeError("Illegal invocation");
-          err.code = "ERR_INVALID_THIS";
-          throw err;
+      [_onopen](er, fd) {
+        if (er) {
+          this[_onerror](er);
+        } else {
+          this[_fd] = fd;
+          this.emit("open", fd);
+          this[_read]();
         }
       }
-    };
-    webidl.argumentLengthCheck = function({ length }, min, ctx) {
-      if (length < min) {
-        throw webidl.errors.exception({
-          message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
-          header: ctx
-        });
+      [_makeBuf]() {
+        return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
       }
-    };
-    webidl.illegalConstructor = function() {
-      throw webidl.errors.exception({
-        header: "TypeError",
-        message: "Illegal constructor"
-      });
-    };
-    webidl.util.Type = function(V) {
-      switch (typeof V) {
-        case "undefined":
-          return "Undefined";
-        case "boolean":
-          return "Boolean";
-        case "string":
-          return "String";
-        case "symbol":
-          return "Symbol";
-        case "number":
-          return "Number";
-        case "bigint":
-          return "BigInt";
-        case "function":
-        case "object": {
-          if (V === null) {
-            return "Null";
+      [_read]() {
+        if (!this[_reading]) {
+          this[_reading] = true;
+          const buf = this[_makeBuf]();
+          if (buf.length === 0) {
+            return process.nextTick(() => this[_onread](null, 0, buf));
           }
-          return "Object";
+          import_fs2.default.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b));
         }
       }
-    };
-    webidl.util.markAsUncloneable = markAsUncloneable || (() => {
-    });
-    webidl.util.ConvertToInt = function(V, bitLength, signedness, opts) {
-      let upperBound;
-      let lowerBound;
-      if (bitLength === 64) {
-        upperBound = Math.pow(2, 53) - 1;
-        if (signedness === "unsigned") {
-          lowerBound = 0;
-        } else {
-          lowerBound = Math.pow(-2, 53) + 1;
-        }
-      } else if (signedness === "unsigned") {
-        lowerBound = 0;
-        upperBound = Math.pow(2, bitLength) - 1;
-      } else {
-        lowerBound = Math.pow(-2, bitLength) - 1;
-        upperBound = Math.pow(2, bitLength - 1) - 1;
-      }
-      let x = Number(V);
-      if (x === 0) {
-        x = 0;
-      }
-      if (opts?.enforceRange === true) {
-        if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
-          throw webidl.errors.exception({
-            header: "Integer conversion",
-            message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
-          });
-        }
-        x = webidl.util.IntegerPart(x);
-        if (x < lowerBound || x > upperBound) {
-          throw webidl.errors.exception({
-            header: "Integer conversion",
-            message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
-          });
+      [_onread](er, br, buf) {
+        this[_reading] = false;
+        if (er) {
+          this[_onerror](er);
+        } else if (this[_handleChunk](br, buf)) {
+          this[_read]();
         }
-        return x;
       }
-      if (!Number.isNaN(x) && opts?.clamp === true) {
-        x = Math.min(Math.max(x, lowerBound), upperBound);
-        if (Math.floor(x) % 2 === 0) {
-          x = Math.floor(x);
-        } else {
-          x = Math.ceil(x);
+      [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === "number") {
+          const fd = this[_fd];
+          this[_fd] = void 0;
+          import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
         }
-        return x;
-      }
-      if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
-        return 0;
-      }
-      x = webidl.util.IntegerPart(x);
-      x = x % Math.pow(2, bitLength);
-      if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) {
-        return x - Math.pow(2, bitLength);
       }
-      return x;
-    };
-    webidl.util.IntegerPart = function(n) {
-      const r = Math.floor(Math.abs(n));
-      if (n < 0) {
-        return -1 * r;
-      }
-      return r;
-    };
-    webidl.util.Stringify = function(V) {
-      const type = webidl.util.Type(V);
-      switch (type) {
-        case "Symbol":
-          return `Symbol(${V.description})`;
-        case "Object":
-          return inspect(V);
-        case "String":
-          return `"${V}"`;
-        default:
-          return `${V}`;
+      [_onerror](er) {
+        this[_reading] = true;
+        this[_close]();
+        this.emit("error", er);
       }
-    };
-    webidl.sequenceConverter = function(converter) {
-      return (V, prefix, argument, Iterable) => {
-        if (webidl.util.Type(V) !== "Object") {
-          throw webidl.errors.exception({
-            header: prefix,
-            message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
-          });
+      [_handleChunk](br, buf) {
+        let ret = false;
+        this[_remain] -= br;
+        if (br > 0) {
+          ret = super.write(br < buf.length ? buf.subarray(0, br) : buf);
         }
-        const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.();
-        const seq = [];
-        let index = 0;
-        if (method === void 0 || typeof method.next !== "function") {
-          throw webidl.errors.exception({
-            header: prefix,
-            message: `${argument} is not iterable.`
-          });
+        if (br === 0 || this[_remain] <= 0) {
+          ret = false;
+          this[_close]();
+          super.end();
         }
-        while (true) {
-          const { done, value } = method.next();
-          if (done) {
-            break;
-          }
-          seq.push(converter(value, prefix, `${argument}[${index++}]`));
+        return ret;
+      }
+      emit(ev, ...args) {
+        switch (ev) {
+          case "prefinish":
+          case "finish":
+            return false;
+          case "drain":
+            if (typeof this[_fd] === "number") {
+              this[_read]();
+            }
+            return false;
+          case "error":
+            if (this[_errored]) {
+              return false;
+            }
+            this[_errored] = true;
+            return super.emit(ev, ...args);
+          default:
+            return super.emit(ev, ...args);
         }
-        return seq;
-      };
+      }
     };
-    webidl.recordConverter = function(keyConverter, valueConverter) {
-      return (O, prefix, argument) => {
-        if (webidl.util.Type(O) !== "Object") {
-          throw webidl.errors.exception({
-            header: prefix,
-            message: `${argument} ("${webidl.util.Type(O)}") is not an Object.`
-          });
-        }
-        const result = {};
-        if (!types.isProxy(O)) {
-          const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
-          for (const key of keys2) {
-            const typedKey = keyConverter(key, prefix, argument);
-            const typedValue = valueConverter(O[key], prefix, argument);
-            result[typedKey] = typedValue;
-          }
-          return result;
-        }
-        const keys = Reflect.ownKeys(O);
-        for (const key of keys) {
-          const desc2 = Reflect.getOwnPropertyDescriptor(O, key);
-          if (desc2?.enumerable) {
-            const typedKey = keyConverter(key, prefix, argument);
-            const typedValue = valueConverter(O[key], prefix, argument);
-            result[typedKey] = typedValue;
+    ReadStreamSync = class extends ReadStream {
+      [_open]() {
+        let threw = true;
+        try {
+          this[_onopen](null, import_fs2.default.openSync(this[_path], "r"));
+          threw = false;
+        } finally {
+          if (threw) {
+            this[_close]();
           }
         }
-        return result;
-      };
-    };
-    webidl.interfaceConverter = function(i) {
-      return (V, prefix, argument, opts) => {
-        if (opts?.strict !== false && !(V instanceof i)) {
-          throw webidl.errors.exception({
-            header: prefix,
-            message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.`
-          });
-        }
-        return V;
-      };
-    };
-    webidl.dictionaryConverter = function(converters) {
-      return (dictionary, prefix, argument) => {
-        const type = webidl.util.Type(dictionary);
-        const dict = {};
-        if (type === "Null" || type === "Undefined") {
-          return dict;
-        } else if (type !== "Object") {
-          throw webidl.errors.exception({
-            header: prefix,
-            message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
-          });
-        }
-        for (const options of converters) {
-          const { key, defaultValue, required, converter } = options;
-          if (required === true) {
-            if (!Object.hasOwn(dictionary, key)) {
-              throw webidl.errors.exception({
-                header: prefix,
-                message: `Missing required key "${key}".`
-              });
-            }
-          }
-          let value = dictionary[key];
-          const hasDefault = Object.hasOwn(options, "defaultValue");
-          if (hasDefault && value !== null) {
-            value ??= defaultValue();
+      }
+      [_read]() {
+        let threw = true;
+        try {
+          if (!this[_reading]) {
+            this[_reading] = true;
+            do {
+              const buf = this[_makeBuf]();
+              const br = buf.length === 0 ? 0 : import_fs2.default.readSync(this[_fd], buf, 0, buf.length, null);
+              if (!this[_handleChunk](br, buf)) {
+                break;
+              }
+            } while (true);
+            this[_reading] = false;
           }
-          if (required || hasDefault || value !== void 0) {
-            value = converter(value, prefix, `${argument}.${key}`);
-            if (options.allowedValues && !options.allowedValues.includes(value)) {
-              throw webidl.errors.exception({
-                header: prefix,
-                message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.`
-              });
-            }
-            dict[key] = value;
+          threw = false;
+        } finally {
+          if (threw) {
+            this[_close]();
           }
         }
-        return dict;
-      };
-    };
-    webidl.nullableConverter = function(converter) {
-      return (V, prefix, argument) => {
-        if (V === null) {
-          return V;
-        }
-        return converter(V, prefix, argument);
-      };
-    };
-    webidl.converters.DOMString = function(V, prefix, argument, opts) {
-      if (V === null && opts?.legacyNullToEmptyString) {
-        return "";
       }
-      if (typeof V === "symbol") {
-        throw webidl.errors.exception({
-          header: prefix,
-          message: `${argument} is a symbol, which cannot be converted to a DOMString.`
-        });
+      [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === "number") {
+          const fd = this[_fd];
+          this[_fd] = void 0;
+          import_fs2.default.closeSync(fd);
+          this.emit("close");
+        }
       }
-      return String(V);
     };
-    webidl.converters.ByteString = function(V, prefix, argument) {
-      const x = webidl.converters.DOMString(V, prefix, argument);
-      for (let index = 0; index < x.length; index++) {
-        if (x.charCodeAt(index) > 255) {
-          throw new TypeError(
-            `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
-          );
+    WriteStream = class extends import_events2.default {
+      readable = false;
+      writable = true;
+      [_errored] = false;
+      [_writing] = false;
+      [_ended] = false;
+      [_queue] = [];
+      [_needDrain] = false;
+      [_path];
+      [_mode];
+      [_autoClose];
+      [_fd];
+      [_defaultFlag];
+      [_flags];
+      [_finished] = false;
+      [_pos];
+      constructor(path16, opt) {
+        opt = opt || {};
+        super(opt);
+        this[_path] = path16;
+        this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
+        this[_mode] = opt.mode === void 0 ? 438 : opt.mode;
+        this[_pos] = typeof opt.start === "number" ? opt.start : void 0;
+        this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
+        const defaultFlag = this[_pos] !== void 0 ? "r+" : "w";
+        this[_defaultFlag] = opt.flags === void 0;
+        this[_flags] = opt.flags === void 0 ? defaultFlag : opt.flags;
+        if (this[_fd] === void 0) {
+          this[_open]();
         }
       }
-      return x;
-    };
-    webidl.converters.USVString = toUSVString;
-    webidl.converters.boolean = function(V) {
-      const x = Boolean(V);
-      return x;
-    };
-    webidl.converters.any = function(V) {
-      return V;
-    };
-    webidl.converters["long long"] = function(V, prefix, argument) {
-      const x = webidl.util.ConvertToInt(V, 64, "signed", void 0, prefix, argument);
-      return x;
-    };
-    webidl.converters["unsigned long long"] = function(V, prefix, argument) {
-      const x = webidl.util.ConvertToInt(V, 64, "unsigned", void 0, prefix, argument);
-      return x;
-    };
-    webidl.converters["unsigned long"] = function(V, prefix, argument) {
-      const x = webidl.util.ConvertToInt(V, 32, "unsigned", void 0, prefix, argument);
-      return x;
-    };
-    webidl.converters["unsigned short"] = function(V, prefix, argument, opts) {
-      const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts, prefix, argument);
-      return x;
-    };
-    webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
-        throw webidl.errors.conversionFailed({
-          prefix,
-          argument: `${argument} ("${webidl.util.Stringify(V)}")`,
-          types: ["ArrayBuffer"]
-        });
+      emit(ev, ...args) {
+        if (ev === "error") {
+          if (this[_errored]) {
+            return false;
+          }
+          this[_errored] = true;
+        }
+        return super.emit(ev, ...args);
       }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "SharedArrayBuffer is not allowed."
-        });
+      get fd() {
+        return this[_fd];
       }
-      if (V.resizable || V.growable) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "Received a resizable ArrayBuffer."
-        });
+      get path() {
+        return this[_path];
       }
-      return V;
-    };
-    webidl.converters.TypedArray = function(V, T, prefix, name2, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
-        throw webidl.errors.conversionFailed({
-          prefix,
-          argument: `${name2} ("${webidl.util.Stringify(V)}")`,
-          types: [T.name]
-        });
+      [_onerror](er) {
+        this[_close]();
+        this[_writing] = true;
+        this.emit("error", er);
       }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "SharedArrayBuffer is not allowed."
-        });
+      [_open]() {
+        import_fs2.default.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd));
       }
-      if (V.buffer.resizable || V.buffer.growable) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "Received a resizable ArrayBuffer."
-        });
+      [_onopen](er, fd) {
+        if (this[_defaultFlag] && this[_flags] === "r+" && er && er.code === "ENOENT") {
+          this[_flags] = "w";
+          this[_open]();
+        } else if (er) {
+          this[_onerror](er);
+        } else {
+          this[_fd] = fd;
+          this.emit("open", fd);
+          if (!this[_writing]) {
+            this[_flush]();
+          }
+        }
       }
-      return V;
-    };
-    webidl.converters.DataView = function(V, prefix, name2, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
-        throw webidl.errors.exception({
-          header: prefix,
-          message: `${name2} is not a DataView.`
-        });
-      }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "SharedArrayBuffer is not allowed."
-        });
-      }
-      if (V.buffer.resizable || V.buffer.growable) {
-        throw webidl.errors.exception({
-          header: "ArrayBuffer",
-          message: "Received a resizable ArrayBuffer."
-        });
-      }
-      return V;
-    };
-    webidl.converters.BufferSource = function(V, prefix, name2, opts) {
-      if (types.isAnyArrayBuffer(V)) {
-        return webidl.converters.ArrayBuffer(V, prefix, name2, { ...opts, allowShared: false });
-      }
-      if (types.isTypedArray(V)) {
-        return webidl.converters.TypedArray(V, V.constructor, prefix, name2, { ...opts, allowShared: false });
-      }
-      if (types.isDataView(V)) {
-        return webidl.converters.DataView(V, prefix, name2, { ...opts, allowShared: false });
-      }
-      throw webidl.errors.conversionFailed({
-        prefix,
-        argument: `${name2} ("${webidl.util.Stringify(V)}")`,
-        types: ["BufferSource"]
-      });
-    };
-    webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
-      webidl.converters.ByteString
-    );
-    webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
-      webidl.converters["sequence<ByteString>"]
-    );
-    webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
-      webidl.converters.ByteString,
-      webidl.converters.ByteString
-    );
-    module2.exports = {
-      webidl
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/util.js
-var require_util3 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/util.js"(exports2, module2) {
-    "use strict";
-    var { Transform } = require("node:stream");
-    var zlib = require("node:zlib");
-    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants4();
-    var { getGlobalOrigin } = require_global();
-    var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url();
-    var { performance } = require("node:perf_hooks");
-    var { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util();
-    var assert5 = require("node:assert");
-    var { isUint8Array } = require("node:util/types");
-    var { webidl } = require_webidl();
-    var supportedHashes = [];
-    var crypto;
-    try {
-      crypto = require("node:crypto");
-      const possibleRelevantHashes = ["sha256", "sha384", "sha512"];
-      supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash));
-    } catch {
-    }
-    function responseURL(response) {
-      const urlList = response.urlList;
-      const length = urlList.length;
-      return length === 0 ? null : urlList[length - 1].toString();
-    }
-    function responseLocationURL(response, requestFragment) {
-      if (!redirectStatusSet.has(response.status)) {
-        return null;
-      }
-      let location = response.headersList.get("location", true);
-      if (location !== null && isValidHeaderValue(location)) {
-        if (!isValidEncodedURL(location)) {
-          location = normalizeBinaryStringToUtf8(location);
-        }
-        location = new URL(location, responseURL(response));
-      }
-      if (location && !location.hash) {
-        location.hash = requestFragment;
-      }
-      return location;
-    }
-    function isValidEncodedURL(url) {
-      for (let i = 0; i < url.length; ++i) {
-        const code2 = url.charCodeAt(i);
-        if (code2 > 126 || // Non-US-ASCII + DEL
-        code2 < 32) {
-          return false;
-        }
-      }
-      return true;
-    }
-    function normalizeBinaryStringToUtf8(value) {
-      return Buffer.from(value, "binary").toString("utf8");
-    }
-    function requestCurrentURL(request) {
-      return request.urlList[request.urlList.length - 1];
-    }
-    function requestBadPort(request) {
-      const url = requestCurrentURL(request);
-      if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
-        return "blocked";
-      }
-      return "allowed";
-    }
-    function isErrorLike(object) {
-      return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
-    }
-    function isValidReasonPhrase(statusText) {
-      for (let i = 0; i < statusText.length; ++i) {
-        const c = statusText.charCodeAt(i);
-        if (!(c === 9 || // HTAB
-        c >= 32 && c <= 126 || // SP / VCHAR
-        c >= 128 && c <= 255)) {
-          return false;
+      end(buf, enc) {
+        if (buf) {
+          this.write(buf, enc);
         }
-      }
-      return true;
-    }
-    var isValidHeaderName = isValidHTTPToken;
-    function isValidHeaderValue(potentialValue) {
-      return (potentialValue[0] === "	" || potentialValue[0] === " " || potentialValue[potentialValue.length - 1] === "	" || potentialValue[potentialValue.length - 1] === " " || potentialValue.includes("\n") || potentialValue.includes("\r") || potentialValue.includes("\0")) === false;
-    }
-    function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
-      const { headersList } = actualResponse;
-      const policyHeader = (headersList.get("referrer-policy", true) ?? "").split(",");
-      let policy = "";
-      if (policyHeader.length > 0) {
-        for (let i = policyHeader.length; i !== 0; i--) {
-          const token = policyHeader[i - 1].trim();
-          if (referrerPolicyTokens.has(token)) {
-            policy = token;
-            break;
-          }
+        this[_ended] = true;
+        if (!this[_writing] && !this[_queue].length && typeof this[_fd] === "number") {
+          this[_onwrite](null, 0);
         }
+        return this;
       }
-      if (policy !== "") {
-        request.referrerPolicy = policy;
-      }
-    }
-    function crossOriginResourcePolicyCheck() {
-      return "allowed";
-    }
-    function corsCheck() {
-      return "success";
-    }
-    function TAOCheck() {
-      return "success";
-    }
-    function appendFetchMetadata(httpRequest) {
-      let header = null;
-      header = httpRequest.mode;
-      httpRequest.headersList.set("sec-fetch-mode", header, true);
-    }
-    function appendRequestOriginHeader(request) {
-      let serializedOrigin = request.origin;
-      if (serializedOrigin === "client" || serializedOrigin === void 0) {
-        return;
-      }
-      if (request.responseTainting === "cors" || request.mode === "websocket") {
-        request.headersList.append("origin", serializedOrigin, true);
-      } else if (request.method !== "GET" && request.method !== "HEAD") {
-        switch (request.referrerPolicy) {
-          case "no-referrer":
-            serializedOrigin = null;
-            break;
-          case "no-referrer-when-downgrade":
-          case "strict-origin":
-          case "strict-origin-when-cross-origin":
-            if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
-              serializedOrigin = null;
-            }
-            break;
-          case "same-origin":
-            if (!sameOrigin(request, requestCurrentURL(request))) {
-              serializedOrigin = null;
-            }
-            break;
-          default:
+      write(buf, enc) {
+        if (typeof buf === "string") {
+          buf = Buffer.from(buf, enc);
         }
-        request.headersList.append("origin", serializedOrigin, true);
-      }
-    }
-    function coarsenTime(timestamp, crossOriginIsolatedCapability) {
-      return timestamp;
-    }
-    function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
-      if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
-        return {
-          domainLookupStartTime: defaultStartTime,
-          domainLookupEndTime: defaultStartTime,
-          connectionStartTime: defaultStartTime,
-          connectionEndTime: defaultStartTime,
-          secureConnectionStartTime: defaultStartTime,
-          ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
-        };
-      }
-      return {
-        domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
-        domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
-        connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
-        connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
-        secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
-        ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
-      };
-    }
-    function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return coarsenTime(performance.now(), crossOriginIsolatedCapability);
-    }
-    function createOpaqueTimingInfo(timingInfo) {
-      return {
-        startTime: timingInfo.startTime ?? 0,
-        redirectStartTime: 0,
-        redirectEndTime: 0,
-        postRedirectStartTime: timingInfo.startTime ?? 0,
-        finalServiceWorkerStartTime: 0,
-        finalNetworkResponseStartTime: 0,
-        finalNetworkRequestStartTime: 0,
-        endTime: 0,
-        encodedBodySize: 0,
-        decodedBodySize: 0,
-        finalConnectionTimingInfo: null
-      };
-    }
-    function makePolicyContainer() {
-      return {
-        referrerPolicy: "strict-origin-when-cross-origin"
-      };
-    }
-    function clonePolicyContainer(policyContainer) {
-      return {
-        referrerPolicy: policyContainer.referrerPolicy
-      };
-    }
-    function determineRequestsReferrer(request) {
-      const policy = request.referrerPolicy;
-      assert5(policy);
-      let referrerSource = null;
-      if (request.referrer === "client") {
-        const globalOrigin = getGlobalOrigin();
-        if (!globalOrigin || globalOrigin.origin === "null") {
-          return "no-referrer";
-        }
-        referrerSource = new URL(globalOrigin);
-      } else if (request.referrer instanceof URL) {
-        referrerSource = request.referrer;
-      }
-      let referrerURL = stripURLForReferrer(referrerSource);
-      const referrerOrigin = stripURLForReferrer(referrerSource, true);
-      if (referrerURL.toString().length > 4096) {
-        referrerURL = referrerOrigin;
-      }
-      const areSameOrigin = sameOrigin(request, referrerURL);
-      const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url);
-      switch (policy) {
-        case "origin":
-          return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
-        case "unsafe-url":
-          return referrerURL;
-        case "same-origin":
-          return areSameOrigin ? referrerOrigin : "no-referrer";
-        case "origin-when-cross-origin":
-          return areSameOrigin ? referrerURL : referrerOrigin;
-        case "strict-origin-when-cross-origin": {
-          const currentURL = requestCurrentURL(request);
-          if (sameOrigin(referrerURL, currentURL)) {
-            return referrerURL;
-          }
-          if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
-            return "no-referrer";
-          }
-          return referrerOrigin;
-        }
-        case "strict-origin":
-        // eslint-disable-line
-        /**
-           * 1. If referrerURL is a potentially trustworthy URL and
-           * request’s current URL is not a potentially trustworthy URL,
-           * then return no referrer.
-           * 2. Return referrerOrigin
-          */
-        case "no-referrer-when-downgrade":
-        // eslint-disable-line
-        /**
-         * 1. If referrerURL is a potentially trustworthy URL and
-         * request’s current URL is not a potentially trustworthy URL,
-         * then return no referrer.
-         * 2. Return referrerOrigin
-        */
-        default:
-          return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
-      }
-    }
-    function stripURLForReferrer(url, originOnly) {
-      assert5(url instanceof URL);
-      url = new URL(url);
-      if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") {
-        return "no-referrer";
-      }
-      url.username = "";
-      url.password = "";
-      url.hash = "";
-      if (originOnly) {
-        url.pathname = "";
-        url.search = "";
-      }
-      return url;
-    }
-    function isURLPotentiallyTrustworthy(url) {
-      if (!(url instanceof URL)) {
-        return false;
-      }
-      if (url.href === "about:blank" || url.href === "about:srcdoc") {
-        return true;
-      }
-      if (url.protocol === "data:") return true;
-      if (url.protocol === "file:") return true;
-      return isOriginPotentiallyTrustworthy(url.origin);
-      function isOriginPotentiallyTrustworthy(origin) {
-        if (origin == null || origin === "null") return false;
-        const originAsURL = new URL(origin);
-        if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
-          return true;
+        if (this[_ended]) {
+          this.emit("error", new Error("write() after end()"));
+          return false;
         }
-        if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
-          return true;
+        if (this[_fd] === void 0 || this[_writing] || this[_queue].length) {
+          this[_queue].push(buf);
+          this[_needDrain] = true;
+          return false;
         }
-        return false;
-      }
-    }
-    function bytesMatch(bytes, metadataList) {
-      if (crypto === void 0) {
-        return true;
-      }
-      const parsedMetadata = parseMetadata(metadataList);
-      if (parsedMetadata === "no metadata") {
+        this[_writing] = true;
+        this[_write](buf);
         return true;
       }
-      if (parsedMetadata.length === 0) {
-        return true;
+      [_write](buf) {
+        import_fs2.default.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw));
       }
-      const strongest = getStrongestMetadata(parsedMetadata);
-      const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest);
-      for (const item of metadata) {
-        const algorithm = item.algo;
-        const expectedValue = item.hash;
-        let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64");
-        if (actualValue[actualValue.length - 1] === "=") {
-          if (actualValue[actualValue.length - 2] === "=") {
-            actualValue = actualValue.slice(0, -2);
+      [_onwrite](er, bw) {
+        if (er) {
+          this[_onerror](er);
+        } else {
+          if (this[_pos] !== void 0 && typeof bw === "number") {
+            this[_pos] += bw;
+          }
+          if (this[_queue].length) {
+            this[_flush]();
           } else {
-            actualValue = actualValue.slice(0, -1);
+            this[_writing] = false;
+            if (this[_ended] && !this[_finished]) {
+              this[_finished] = true;
+              this[_close]();
+              this.emit("finish");
+            } else if (this[_needDrain]) {
+              this[_needDrain] = false;
+              this.emit("drain");
+            }
           }
         }
-        if (compareBase64Mixed(actualValue, expectedValue)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;
-    function parseMetadata(metadata) {
-      const result = [];
-      let empty = true;
-      for (const token of metadata.split(" ")) {
-        empty = false;
-        const parsedToken = parseHashWithOptions.exec(token);
-        if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) {
-          continue;
-        }
-        const algorithm = parsedToken.groups.algo.toLowerCase();
-        if (supportedHashes.includes(algorithm)) {
-          result.push(parsedToken.groups);
-        }
-      }
-      if (empty === true) {
-        return "no metadata";
       }
-      return result;
-    }
-    function getStrongestMetadata(metadataList) {
-      let algorithm = metadataList[0].algo;
-      if (algorithm[3] === "5") {
-        return algorithm;
-      }
-      for (let i = 1; i < metadataList.length; ++i) {
-        const metadata = metadataList[i];
-        if (metadata.algo[3] === "5") {
-          algorithm = "sha512";
-          break;
-        } else if (algorithm[3] === "3") {
-          continue;
-        } else if (metadata.algo[3] === "3") {
-          algorithm = "sha384";
+      [_flush]() {
+        if (this[_queue].length === 0) {
+          if (this[_ended]) {
+            this[_onwrite](null, 0);
+          }
+        } else if (this[_queue].length === 1) {
+          this[_write](this[_queue].pop());
+        } else {
+          const iovec = this[_queue];
+          this[_queue] = [];
+          writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw));
         }
       }
-      return algorithm;
-    }
-    function filterMetadataListByAlgorithm(metadataList, algorithm) {
-      if (metadataList.length === 1) {
-        return metadataList;
-      }
-      let pos2 = 0;
-      for (let i = 0; i < metadataList.length; ++i) {
-        if (metadataList[i].algo === algorithm) {
-          metadataList[pos2++] = metadataList[i];
+      [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === "number") {
+          const fd = this[_fd];
+          this[_fd] = void 0;
+          import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
         }
       }
-      metadataList.length = pos2;
-      return metadataList;
-    }
-    function compareBase64Mixed(actualValue, expectedValue) {
-      if (actualValue.length !== expectedValue.length) {
-        return false;
-      }
-      for (let i = 0; i < actualValue.length; ++i) {
-        if (actualValue[i] !== expectedValue[i]) {
-          if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") {
-            continue;
+    };
+    WriteStreamSync = class extends WriteStream {
+      [_open]() {
+        let fd;
+        if (this[_defaultFlag] && this[_flags] === "r+") {
+          try {
+            fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
+          } catch (er) {
+            if (er?.code === "ENOENT") {
+              this[_flags] = "w";
+              return this[_open]();
+            } else {
+              throw er;
+            }
           }
-          return false;
+        } else {
+          fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
         }
+        this[_onopen](null, fd);
       }
-      return true;
-    }
-    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
-    }
-    function sameOrigin(A, B) {
-      if (A.origin === B.origin && A.origin === "null") {
-        return true;
-      }
-      if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
-        return true;
-      }
-      return false;
-    }
-    function createDeferredPromise() {
-      let res;
-      let rej;
-      const promise = new Promise((resolve, reject) => {
-        res = resolve;
-        rej = reject;
-      });
-      return { promise, resolve: res, reject: rej };
-    }
-    function isAborted(fetchParams) {
-      return fetchParams.controller.state === "aborted";
-    }
-    function isCancelled(fetchParams) {
-      return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
-    }
-    function normalizeMethod(method) {
-      return normalizedMethodRecordsBase[method.toLowerCase()] ?? method;
-    }
-    function serializeJavascriptValueToJSONString(value) {
-      const result = JSON.stringify(value);
-      if (result === void 0) {
-        throw new TypeError("Value is not JSON serializable");
-      }
-      assert5(typeof result === "string");
-      return result;
-    }
-    var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
-    function createIterator(name2, kInternalIterator, keyIndex = 0, valueIndex = 1) {
-      class FastIterableIterator {
-        /** @type {any} */
-        #target;
-        /** @type {'key' | 'value' | 'key+value'} */
-        #kind;
-        /** @type {number} */
-        #index;
-        /**
-         * @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object
-         * @param {unknown} target
-         * @param {'key' | 'value' | 'key+value'} kind
-         */
-        constructor(target, kind) {
-          this.#target = target;
-          this.#kind = kind;
-          this.#index = 0;
-        }
-        next() {
-          if (typeof this !== "object" || this === null || !(#target in this)) {
-            throw new TypeError(
-              `'next' called on an object that does not implement interface ${name2} Iterator.`
-            );
-          }
-          const index = this.#index;
-          const values = this.#target[kInternalIterator];
-          const len = values.length;
-          if (index >= len) {
-            return {
-              value: void 0,
-              done: true
-            };
-          }
-          const { [keyIndex]: key, [valueIndex]: value } = values[index];
-          this.#index = index + 1;
-          let result;
-          switch (this.#kind) {
-            case "key":
-              result = key;
-              break;
-            case "value":
-              result = value;
-              break;
-            case "key+value":
-              result = [key, value];
-              break;
-          }
-          return {
-            value: result,
-            done: false
-          };
+      [_close]() {
+        if (this[_autoClose] && typeof this[_fd] === "number") {
+          const fd = this[_fd];
+          this[_fd] = void 0;
+          import_fs2.default.closeSync(fd);
+          this.emit("close");
         }
       }
-      delete FastIterableIterator.prototype.constructor;
-      Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype);
-      Object.defineProperties(FastIterableIterator.prototype, {
-        [Symbol.toStringTag]: {
-          writable: false,
-          enumerable: false,
-          configurable: true,
-          value: `${name2} Iterator`
-        },
-        next: { writable: true, enumerable: true, configurable: true }
-      });
-      return function(target, kind) {
-        return new FastIterableIterator(target, kind);
-      };
-    }
-    function iteratorMixin(name2, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
-      const makeIterator = createIterator(name2, kInternalIterator, keyIndex, valueIndex);
-      const properties = {
-        keys: {
-          writable: true,
-          enumerable: true,
-          configurable: true,
-          value: function keys() {
-            webidl.brandCheck(this, object);
-            return makeIterator(this, "key");
-          }
-        },
-        values: {
-          writable: true,
-          enumerable: true,
-          configurable: true,
-          value: function values() {
-            webidl.brandCheck(this, object);
-            return makeIterator(this, "value");
-          }
-        },
-        entries: {
-          writable: true,
-          enumerable: true,
-          configurable: true,
-          value: function entries() {
-            webidl.brandCheck(this, object);
-            return makeIterator(this, "key+value");
-          }
-        },
-        forEach: {
-          writable: true,
-          enumerable: true,
-          configurable: true,
-          value: function forEach(callbackfn, thisArg = globalThis) {
-            webidl.brandCheck(this, object);
-            webidl.argumentLengthCheck(arguments, 1, `${name2}.forEach`);
-            if (typeof callbackfn !== "function") {
-              throw new TypeError(
-                `Failed to execute 'forEach' on '${name2}': parameter 1 is not of type 'Function'.`
-              );
-            }
-            for (const { 0: key, 1: value } of makeIterator(this, "key+value")) {
-              callbackfn.call(thisArg, value, key, this);
+      [_write](buf) {
+        let threw = true;
+        try {
+          this[_onwrite](null, import_fs2.default.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
+          threw = false;
+        } finally {
+          if (threw) {
+            try {
+              this[_close]();
+            } catch {
             }
           }
         }
-      };
-      return Object.defineProperties(object.prototype, {
-        ...properties,
-        [Symbol.iterator]: {
-          writable: true,
-          enumerable: false,
-          configurable: true,
-          value: properties.entries.value
-        }
-      });
-    }
-    async function fullyReadBody(body, processBody, processBodyError) {
-      const successSteps = processBody;
-      const errorSteps = processBodyError;
-      let reader;
-      try {
-        reader = body.stream.getReader();
-      } catch (e) {
-        errorSteps(e);
-        return;
       }
-      try {
-        successSteps(await readAllBytes(reader));
-      } catch (e) {
-        errorSteps(e);
-      }
-    }
-    function isReadableStreamLike(stream) {
-      return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function";
-    }
-    function readableStreamClose(controller) {
-      try {
-        controller.close();
-        controller.byobRequest?.respond(0);
-      } catch (err) {
-        if (!err.message.includes("Controller is already closed") && !err.message.includes("ReadableStream is already closed")) {
-          throw err;
-        }
-      }
-    }
-    var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/;
-    function isomorphicEncode(input) {
-      assert5(!invalidIsomorphicEncodeValueRegex.test(input));
-      return input;
-    }
-    async function readAllBytes(reader) {
-      const bytes = [];
-      let byteLength = 0;
-      while (true) {
-        const { done, value: chunk } = await reader.read();
-        if (done) {
-          return Buffer.concat(bytes, byteLength);
-        }
-        if (!isUint8Array(chunk)) {
-          throw new TypeError("Received non-Uint8Array chunk");
-        }
-        bytes.push(chunk);
-        byteLength += chunk.length;
-      }
-    }
-    function urlIsLocal(url) {
-      assert5("protocol" in url);
-      const protocol = url.protocol;
-      return protocol === "about:" || protocol === "blob:" || protocol === "data:";
-    }
-    function urlHasHttpsScheme(url) {
-      return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:";
-    }
-    function urlIsHttpHttpsScheme(url) {
-      assert5("protocol" in url);
-      const protocol = url.protocol;
-      return protocol === "http:" || protocol === "https:";
-    }
-    function simpleRangeHeaderValue(value, allowWhitespace) {
-      const data = value;
-      if (!data.startsWith("bytes")) {
-        return "failure";
-      }
-      const position = { position: 5 };
-      if (allowWhitespace) {
-        collectASequenceOfCodePoints(
-          (char) => char === "	" || char === " ",
-          data,
-          position
-        );
-      }
-      if (data.charCodeAt(position.position) !== 61) {
-        return "failure";
-      }
-      position.position++;
-      if (allowWhitespace) {
-        collectASequenceOfCodePoints(
-          (char) => char === "	" || char === " ",
-          data,
-          position
-        );
-      }
-      const rangeStart = collectASequenceOfCodePoints(
-        (char) => {
-          const code2 = char.charCodeAt(0);
-          return code2 >= 48 && code2 <= 57;
-        },
-        data,
-        position
-      );
-      const rangeStartValue = rangeStart.length ? Number(rangeStart) : null;
-      if (allowWhitespace) {
-        collectASequenceOfCodePoints(
-          (char) => char === "	" || char === " ",
-          data,
-          position
-        );
-      }
-      if (data.charCodeAt(position.position) !== 45) {
-        return "failure";
-      }
-      position.position++;
-      if (allowWhitespace) {
-        collectASequenceOfCodePoints(
-          (char) => char === "	" || char === " ",
-          data,
-          position
-        );
-      }
-      const rangeEnd = collectASequenceOfCodePoints(
-        (char) => {
-          const code2 = char.charCodeAt(0);
-          return code2 >= 48 && code2 <= 57;
-        },
-        data,
-        position
-      );
-      const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null;
-      if (position.position < data.length) {
-        return "failure";
-      }
-      if (rangeEndValue === null && rangeStartValue === null) {
-        return "failure";
-      }
-      if (rangeStartValue > rangeEndValue) {
-        return "failure";
-      }
-      return { rangeStartValue, rangeEndValue };
-    }
-    function buildContentRange(rangeStart, rangeEnd, fullLength) {
-      let contentRange = "bytes ";
-      contentRange += isomorphicEncode(`${rangeStart}`);
-      contentRange += "-";
-      contentRange += isomorphicEncode(`${rangeEnd}`);
-      contentRange += "/";
-      contentRange += isomorphicEncode(`${fullLength}`);
-      return contentRange;
-    }
-    var InflateStream = class extends Transform {
-      #zlibOptions;
-      /** @param {zlib.ZlibOptions} [zlibOptions] */
-      constructor(zlibOptions) {
-        super();
-        this.#zlibOptions = zlibOptions;
-      }
-      _transform(chunk, encoding, callback) {
-        if (!this._inflateStream) {
-          if (chunk.length === 0) {
-            callback();
-            return;
-          }
-          this._inflateStream = (chunk[0] & 15) === 8 ? zlib.createInflate(this.#zlibOptions) : zlib.createInflateRaw(this.#zlibOptions);
-          this._inflateStream.on("data", this.push.bind(this));
-          this._inflateStream.on("end", () => this.push(null));
-          this._inflateStream.on("error", (err) => this.destroy(err));
-        }
-        this._inflateStream.write(chunk, encoding, callback);
-      }
-      _final(callback) {
-        if (this._inflateStream) {
-          this._inflateStream.end();
-          this._inflateStream = null;
-        }
-        callback();
-      }
-    };
-    function createInflate(zlibOptions) {
-      return new InflateStream(zlibOptions);
-    }
-    function extractMimeType(headers) {
-      let charset = null;
-      let essence = null;
-      let mimeType = null;
-      const values = getDecodeSplit("content-type", headers);
-      if (values === null) {
-        return "failure";
-      }
-      for (const value of values) {
-        const temporaryMimeType = parseMIMEType(value);
-        if (temporaryMimeType === "failure" || temporaryMimeType.essence === "*/*") {
-          continue;
-        }
-        mimeType = temporaryMimeType;
-        if (mimeType.essence !== essence) {
-          charset = null;
-          if (mimeType.parameters.has("charset")) {
-            charset = mimeType.parameters.get("charset");
-          }
-          essence = mimeType.essence;
-        } else if (!mimeType.parameters.has("charset") && charset !== null) {
-          mimeType.parameters.set("charset", charset);
-        }
-      }
-      if (mimeType == null) {
-        return "failure";
-      }
-      return mimeType;
-    }
-    function gettingDecodingSplitting(value) {
-      const input = value;
-      const position = { position: 0 };
-      const values = [];
-      let temporaryValue = "";
-      while (position.position < input.length) {
-        temporaryValue += collectASequenceOfCodePoints(
-          (char) => char !== '"' && char !== ",",
-          input,
-          position
-        );
-        if (position.position < input.length) {
-          if (input.charCodeAt(position.position) === 34) {
-            temporaryValue += collectAnHTTPQuotedString(
-              input,
-              position
-            );
-            if (position.position < input.length) {
-              continue;
-            }
-          } else {
-            assert5(input.charCodeAt(position.position) === 44);
-            position.position++;
-          }
-        }
-        temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 9 || char === 32);
-        values.push(temporaryValue);
-        temporaryValue = "";
-      }
-      return values;
-    }
-    function getDecodeSplit(name2, list2) {
-      const value = list2.get(name2, true);
-      if (value === null) {
-        return null;
-      }
-      return gettingDecodingSplitting(value);
-    }
-    var textDecoder = new TextDecoder();
-    function utf8DecodeBytes(buffer) {
-      if (buffer.length === 0) {
-        return "";
-      }
-      if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
-        buffer = buffer.subarray(3);
-      }
-      const output = textDecoder.decode(buffer);
-      return output;
-    }
-    var EnvironmentSettingsObjectBase = class {
-      get baseUrl() {
-        return getGlobalOrigin();
-      }
-      get origin() {
-        return this.baseUrl?.origin;
-      }
-      policyContainer = makePolicyContainer();
-    };
-    var EnvironmentSettingsObject = class {
-      settingsObject = new EnvironmentSettingsObjectBase();
-    };
-    var environmentSettingsObject = new EnvironmentSettingsObject();
-    module2.exports = {
-      isAborted,
-      isCancelled,
-      isValidEncodedURL,
-      createDeferredPromise,
-      ReadableStreamFrom,
-      tryUpgradeRequestToAPotentiallyTrustworthyURL,
-      clampAndCoarsenConnectionTimingInfo,
-      coarsenedSharedCurrentTime,
-      determineRequestsReferrer,
-      makePolicyContainer,
-      clonePolicyContainer,
-      appendFetchMetadata,
-      appendRequestOriginHeader,
-      TAOCheck,
-      corsCheck,
-      crossOriginResourcePolicyCheck,
-      createOpaqueTimingInfo,
-      setRequestReferrerPolicyOnRedirect,
-      isValidHTTPToken,
-      requestBadPort,
-      requestCurrentURL,
-      responseURL,
-      responseLocationURL,
-      isBlobLike,
-      isURLPotentiallyTrustworthy,
-      isValidReasonPhrase,
-      sameOrigin,
-      normalizeMethod,
-      serializeJavascriptValueToJSONString,
-      iteratorMixin,
-      createIterator,
-      isValidHeaderName,
-      isValidHeaderValue,
-      isErrorLike,
-      fullyReadBody,
-      bytesMatch,
-      isReadableStreamLike,
-      readableStreamClose,
-      isomorphicEncode,
-      urlIsLocal,
-      urlHasHttpsScheme,
-      urlIsHttpHttpsScheme,
-      readAllBytes,
-      simpleRangeHeaderValue,
-      buildContentRange,
-      parseMetadata,
-      createInflate,
-      extractMimeType,
-      getDecodeSplit,
-      utf8DecodeBytes,
-      environmentSettingsObject
     };
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/symbols.js
-var require_symbols2 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/symbols.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      kUrl: /* @__PURE__ */ Symbol("url"),
-      kHeaders: /* @__PURE__ */ Symbol("headers"),
-      kSignal: /* @__PURE__ */ Symbol("signal"),
-      kState: /* @__PURE__ */ Symbol("state"),
-      kDispatcher: /* @__PURE__ */ Symbol("dispatcher")
+// node_modules/tar/dist/esm/options.js
+var argmap, isSyncFile, isAsyncFile, isSyncNoFile, isAsyncNoFile, dealiasKey, dealias;
+var init_options = __esm({
+  "node_modules/tar/dist/esm/options.js"() {
+    argmap = /* @__PURE__ */ new Map([
+      ["C", "cwd"],
+      ["f", "file"],
+      ["z", "gzip"],
+      ["P", "preservePaths"],
+      ["U", "unlink"],
+      ["strip-components", "strip"],
+      ["stripComponents", "strip"],
+      ["keep-newer", "newer"],
+      ["keepNewer", "newer"],
+      ["keep-newer-files", "newer"],
+      ["keepNewerFiles", "newer"],
+      ["k", "keep"],
+      ["keep-existing", "keep"],
+      ["keepExisting", "keep"],
+      ["m", "noMtime"],
+      ["no-mtime", "noMtime"],
+      ["p", "preserveOwner"],
+      ["L", "follow"],
+      ["h", "follow"],
+      ["onentry", "onReadEntry"]
+    ]);
+    isSyncFile = (o) => !!o.sync && !!o.file;
+    isAsyncFile = (o) => !o.sync && !!o.file;
+    isSyncNoFile = (o) => !!o.sync && !o.file;
+    isAsyncNoFile = (o) => !o.sync && !o.file;
+    dealiasKey = (k) => {
+      const d = argmap.get(k);
+      if (d)
+        return d;
+      return k;
     };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/file.js
-var require_file = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/file.js"(exports2, module2) {
-    "use strict";
-    var { Blob: Blob2, File } = require("node:buffer");
-    var { kState } = require_symbols2();
-    var { webidl } = require_webidl();
-    var FileLike = class _FileLike {
-      constructor(blobLike, fileName, options = {}) {
-        const n = fileName;
-        const t = options.type;
-        const d = options.lastModified ?? Date.now();
-        this[kState] = {
-          blobLike,
-          name: n,
-          type: t,
-          lastModified: d
-        };
-      }
-      stream(...args) {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.stream(...args);
-      }
-      arrayBuffer(...args) {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.arrayBuffer(...args);
-      }
-      slice(...args) {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.slice(...args);
-      }
-      text(...args) {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.text(...args);
-      }
-      get size() {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.size;
-      }
-      get type() {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].blobLike.type;
-      }
-      get name() {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].name;
-      }
-      get lastModified() {
-        webidl.brandCheck(this, _FileLike);
-        return this[kState].lastModified;
+    dealias = (opt = {}) => {
+      if (!opt)
+        return {};
+      const result = {};
+      for (const [key, v] of Object.entries(opt)) {
+        const k = dealiasKey(key);
+        result[k] = v;
       }
-      get [Symbol.toStringTag]() {
-        return "File";
+      if (result.chmod === void 0 && result.noChmod === false) {
+        result.chmod = true;
       }
+      delete result.noChmod;
+      return result;
     };
-    webidl.converters.Blob = webidl.interfaceConverter(Blob2);
-    function isFileLike(object) {
-      return object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
-    }
-    module2.exports = { FileLike, isFileLike };
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata.js
-var require_formdata = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata.js"(exports2, module2) {
-    "use strict";
-    var { isBlobLike, iteratorMixin } = require_util3();
-    var { kState } = require_symbols2();
-    var { kEnumerableProperty } = require_util();
-    var { FileLike, isFileLike } = require_file();
-    var { webidl } = require_webidl();
-    var { File: NativeFile } = require("node:buffer");
-    var nodeUtil = require("node:util");
-    var File = globalThis.File ?? NativeFile;
-    var FormData = class _FormData {
-      constructor(form) {
-        webidl.util.markAsUncloneable(this);
-        if (form !== void 0) {
-          throw webidl.errors.conversionFailed({
-            prefix: "FormData constructor",
-            argument: "Argument 1",
-            types: ["undefined"]
-          });
-        }
-        this[kState] = [];
-      }
-      append(name2, value, filename = void 0) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.append";
-        webidl.argumentLengthCheck(arguments, 2, prefix);
-        if (arguments.length === 3 && !isBlobLike(value)) {
-          throw new TypeError(
-            "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
-          );
-        }
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "value", { strict: false }) : webidl.converters.USVString(value, prefix, "value");
-        filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "filename") : void 0;
-        const entry = makeEntry(name2, value, filename);
-        this[kState].push(entry);
-      }
-      delete(name2) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.delete";
-        webidl.argumentLengthCheck(arguments, 1, prefix);
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        this[kState] = this[kState].filter((entry) => entry.name !== name2);
-      }
-      get(name2) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.get";
-        webidl.argumentLengthCheck(arguments, 1, prefix);
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        const idx = this[kState].findIndex((entry) => entry.name === name2);
-        if (idx === -1) {
-          return null;
-        }
-        return this[kState][idx].value;
-      }
-      getAll(name2) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.getAll";
-        webidl.argumentLengthCheck(arguments, 1, prefix);
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        return this[kState].filter((entry) => entry.name === name2).map((entry) => entry.value);
-      }
-      has(name2) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.has";
-        webidl.argumentLengthCheck(arguments, 1, prefix);
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        return this[kState].findIndex((entry) => entry.name === name2) !== -1;
-      }
-      set(name2, value, filename = void 0) {
-        webidl.brandCheck(this, _FormData);
-        const prefix = "FormData.set";
-        webidl.argumentLengthCheck(arguments, 2, prefix);
-        if (arguments.length === 3 && !isBlobLike(value)) {
-          throw new TypeError(
-            "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
-          );
+// node_modules/tar/dist/esm/make-command.js
+var makeCommand;
+var init_make_command = __esm({
+  "node_modules/tar/dist/esm/make-command.js"() {
+    init_options();
+    makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => {
+      return Object.assign((opt_ = [], entries, cb) => {
+        if (Array.isArray(opt_)) {
+          entries = opt_;
+          opt_ = {};
         }
-        name2 = webidl.converters.USVString(name2, prefix, "name");
-        value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "name", { strict: false }) : webidl.converters.USVString(value, prefix, "name");
-        filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "name") : void 0;
-        const entry = makeEntry(name2, value, filename);
-        const idx = this[kState].findIndex((entry2) => entry2.name === name2);
-        if (idx !== -1) {
-          this[kState] = [
-            ...this[kState].slice(0, idx),
-            entry,
-            ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name2)
-          ];
-        } else {
-          this[kState].push(entry);
+        if (typeof entries === "function") {
+          cb = entries;
+          entries = void 0;
         }
-      }
-      [nodeUtil.inspect.custom](depth, options) {
-        const state = this[kState].reduce((a, b) => {
-          if (a[b.name]) {
-            if (Array.isArray(a[b.name])) {
-              a[b.name].push(b.value);
-            } else {
-              a[b.name] = [a[b.name], b.value];
-            }
-          } else {
-            a[b.name] = b.value;
+        entries = !entries ? [] : Array.from(entries);
+        const opt = dealias(opt_);
+        validate?.(opt, entries);
+        if (isSyncFile(opt)) {
+          if (typeof cb === "function") {
+            throw new TypeError("callback not supported for sync tar functions");
           }
-          return a;
-        }, { __proto__: null });
-        options.depth ??= depth;
-        options.colors ??= true;
-        const output = nodeUtil.formatWithOptions(options, state);
-        return `FormData ${output.slice(output.indexOf("]") + 2)}`;
-      }
-    };
-    iteratorMixin("FormData", FormData, kState, "name", "value");
-    Object.defineProperties(FormData.prototype, {
-      append: kEnumerableProperty,
-      delete: kEnumerableProperty,
-      get: kEnumerableProperty,
-      getAll: kEnumerableProperty,
-      has: kEnumerableProperty,
-      set: kEnumerableProperty,
-      [Symbol.toStringTag]: {
-        value: "FormData",
-        configurable: true
-      }
-    });
-    function makeEntry(name2, value, filename) {
-      if (typeof value === "string") {
-      } else {
-        if (!isFileLike(value)) {
-          value = value instanceof Blob ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
-        }
-        if (filename !== void 0) {
-          const options = {
-            type: value.type,
-            lastModified: value.lastModified
-          };
-          value = value instanceof NativeFile ? new File([value], filename, options) : new FileLike(value, filename, options);
+          return syncFile(opt, entries);
+        } else if (isAsyncFile(opt)) {
+          const p = asyncFile(opt, entries);
+          return cb ? p.then(() => cb(), cb) : p;
+        } else if (isSyncNoFile(opt)) {
+          if (typeof cb === "function") {
+            throw new TypeError("callback not supported for sync tar functions");
+          }
+          return syncNoFile(opt, entries);
+        } else if (isAsyncNoFile(opt)) {
+          if (typeof cb === "function") {
+            throw new TypeError("callback only supported with file option");
+          }
+          return asyncNoFile(opt, entries);
         }
-      }
-      return { name: name2, value };
-    }
-    module2.exports = { FormData, makeEntry };
+        throw new Error("impossible options??");
+      }, {
+        syncFile,
+        asyncFile,
+        syncNoFile,
+        asyncNoFile,
+        validate
+      });
+    };
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata-parser.js
-var require_formdata_parser = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata-parser.js"(exports2, module2) {
-    "use strict";
-    var { isUSVString, bufferToLowerCasedHeaderName } = require_util();
-    var { utf8DecodeBytes } = require_util3();
-    var { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url();
-    var { isFileLike } = require_file();
-    var { makeEntry } = require_formdata();
-    var assert5 = require("node:assert");
-    var { File: NodeFile } = require("node:buffer");
-    var File = globalThis.File ?? NodeFile;
-    var formDataNameBuffer = Buffer.from('form-data; name="');
-    var filenameBuffer = Buffer.from("; filename");
-    var dd = Buffer.from("--");
-    var ddcrlf = Buffer.from("--\r\n");
-    function isAsciiString(chars) {
-      for (let i = 0; i < chars.length; ++i) {
-        if ((chars.charCodeAt(i) & ~127) !== 0) {
-          return false;
-        }
-      }
-      return true;
-    }
-    function validateBoundary(boundary) {
-      const length = boundary.length;
-      if (length < 27 || length > 70) {
-        return false;
-      }
-      for (let i = 0; i < length; ++i) {
-        const cp = boundary.charCodeAt(i);
-        if (!(cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 39 || cp === 45 || cp === 95)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    function multipartFormDataParser(input, mimeType) {
-      assert5(mimeType !== "failure" && mimeType.essence === "multipart/form-data");
-      const boundaryString = mimeType.parameters.get("boundary");
-      if (boundaryString === void 0) {
-        return "failure";
-      }
-      const boundary = Buffer.from(`--${boundaryString}`, "utf8");
-      const entryList = [];
-      const position = { position: 0 };
-      while (input[position.position] === 13 && input[position.position + 1] === 10) {
-        position.position += 2;
-      }
-      let trailing = input.length;
-      while (input[trailing - 1] === 10 && input[trailing - 2] === 13) {
-        trailing -= 2;
-      }
-      if (trailing !== input.length) {
-        input = input.subarray(0, trailing);
-      }
-      while (true) {
-        if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) {
-          position.position += boundary.length;
-        } else {
-          return "failure";
-        }
-        if (position.position === input.length - 2 && bufferStartsWith(input, dd, position) || position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position)) {
-          return entryList;
-        }
-        if (input[position.position] !== 13 || input[position.position + 1] !== 10) {
-          return "failure";
-        }
-        position.position += 2;
-        const result = parseMultipartFormDataHeaders(input, position);
-        if (result === "failure") {
-          return "failure";
-        }
-        let { name: name2, filename, contentType, encoding } = result;
-        position.position += 2;
-        let body;
-        {
-          const boundaryIndex = input.indexOf(boundary.subarray(2), position.position);
-          if (boundaryIndex === -1) {
-            return "failure";
-          }
-          body = input.subarray(position.position, boundaryIndex - 4);
-          position.position += body.length;
-          if (encoding === "base64") {
-            body = Buffer.from(body.toString(), "base64");
-          }
-        }
-        if (input[position.position] !== 13 || input[position.position + 1] !== 10) {
-          return "failure";
-        } else {
-          position.position += 2;
-        }
-        let value;
-        if (filename !== null) {
-          contentType ??= "text/plain";
-          if (!isAsciiString(contentType)) {
-            contentType = "";
-          }
-          value = new File([body], filename, { type: contentType });
-        } else {
-          value = utf8DecodeBytes(Buffer.from(body));
-        }
-        assert5(isUSVString(name2));
-        assert5(typeof value === "string" && isUSVString(value) || isFileLike(value));
-        entryList.push(makeEntry(name2, value, filename));
-      }
-    }
-    function parseMultipartFormDataHeaders(input, position) {
-      let name2 = null;
-      let filename = null;
-      let contentType = null;
-      let encoding = null;
-      while (true) {
-        if (input[position.position] === 13 && input[position.position + 1] === 10) {
-          if (name2 === null) {
-            return "failure";
-          }
-          return { name: name2, filename, contentType, encoding };
-        }
-        let headerName = collectASequenceOfBytes(
-          (char) => char !== 10 && char !== 13 && char !== 58,
-          input,
-          position
-        );
-        headerName = removeChars(headerName, true, true, (char) => char === 9 || char === 32);
-        if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) {
-          return "failure";
-        }
-        if (input[position.position] !== 58) {
-          return "failure";
-        }
-        position.position++;
-        collectASequenceOfBytes(
-          (char) => char === 32 || char === 9,
-          input,
-          position
-        );
-        switch (bufferToLowerCasedHeaderName(headerName)) {
-          case "content-disposition": {
-            name2 = filename = null;
-            if (!bufferStartsWith(input, formDataNameBuffer, position)) {
-              return "failure";
-            }
-            position.position += 17;
-            name2 = parseMultipartFormDataName(input, position);
-            if (name2 === null) {
-              return "failure";
-            }
-            if (bufferStartsWith(input, filenameBuffer, position)) {
-              let check = position.position + filenameBuffer.length;
-              if (input[check] === 42) {
-                position.position += 1;
-                check += 1;
-              }
-              if (input[check] !== 61 || input[check + 1] !== 34) {
-                return "failure";
-              }
-              position.position += 12;
-              filename = parseMultipartFormDataName(input, position);
-              if (filename === null) {
-                return "failure";
-              }
-            }
-            break;
-          }
-          case "content-type": {
-            let headerValue = collectASequenceOfBytes(
-              (char) => char !== 10 && char !== 13,
-              input,
-              position
-            );
-            headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
-            contentType = isomorphicDecode(headerValue);
-            break;
-          }
-          case "content-transfer-encoding": {
-            let headerValue = collectASequenceOfBytes(
-              (char) => char !== 10 && char !== 13,
-              input,
-              position
-            );
-            headerValue = removeChars(headerValue, false, true, (char) => char === 9 || char === 32);
-            encoding = isomorphicDecode(headerValue);
-            break;
-          }
-          default: {
-            collectASequenceOfBytes(
-              (char) => char !== 10 && char !== 13,
-              input,
-              position
-            );
-          }
-        }
-        if (input[position.position] !== 13 && input[position.position + 1] !== 10) {
-          return "failure";
-        } else {
-          position.position += 2;
-        }
-      }
-    }
-    function parseMultipartFormDataName(input, position) {
-      assert5(input[position.position - 1] === 34);
-      let name2 = collectASequenceOfBytes(
-        (char) => char !== 10 && char !== 13 && char !== 34,
-        input,
-        position
-      );
-      if (input[position.position] !== 34) {
-        return null;
-      } else {
-        position.position++;
-      }
-      name2 = new TextDecoder().decode(name2).replace(/%0A/ig, "\n").replace(/%0D/ig, "\r").replace(/%22/g, '"');
-      return name2;
-    }
-    function collectASequenceOfBytes(condition, input, position) {
-      let start = position.position;
-      while (start < input.length && condition(input[start])) {
-        ++start;
+// node_modules/minizlib/dist/esm/constants.js
+var import_zlib, realZlibConstants, constants;
+var init_constants = __esm({
+  "node_modules/minizlib/dist/esm/constants.js"() {
+    import_zlib = __toESM(require("zlib"), 1);
+    realZlibConstants = import_zlib.default.constants || { ZLIB_VERNUM: 4736 };
+    constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
+      Z_NO_FLUSH: 0,
+      Z_PARTIAL_FLUSH: 1,
+      Z_SYNC_FLUSH: 2,
+      Z_FULL_FLUSH: 3,
+      Z_FINISH: 4,
+      Z_BLOCK: 5,
+      Z_OK: 0,
+      Z_STREAM_END: 1,
+      Z_NEED_DICT: 2,
+      Z_ERRNO: -1,
+      Z_STREAM_ERROR: -2,
+      Z_DATA_ERROR: -3,
+      Z_MEM_ERROR: -4,
+      Z_BUF_ERROR: -5,
+      Z_VERSION_ERROR: -6,
+      Z_NO_COMPRESSION: 0,
+      Z_BEST_SPEED: 1,
+      Z_BEST_COMPRESSION: 9,
+      Z_DEFAULT_COMPRESSION: -1,
+      Z_FILTERED: 1,
+      Z_HUFFMAN_ONLY: 2,
+      Z_RLE: 3,
+      Z_FIXED: 4,
+      Z_DEFAULT_STRATEGY: 0,
+      DEFLATE: 1,
+      INFLATE: 2,
+      GZIP: 3,
+      GUNZIP: 4,
+      DEFLATERAW: 5,
+      INFLATERAW: 6,
+      UNZIP: 7,
+      BROTLI_DECODE: 8,
+      BROTLI_ENCODE: 9,
+      Z_MIN_WINDOWBITS: 8,
+      Z_MAX_WINDOWBITS: 15,
+      Z_DEFAULT_WINDOWBITS: 15,
+      Z_MIN_CHUNK: 64,
+      Z_MAX_CHUNK: Infinity,
+      Z_DEFAULT_CHUNK: 16384,
+      Z_MIN_MEMLEVEL: 1,
+      Z_MAX_MEMLEVEL: 9,
+      Z_DEFAULT_MEMLEVEL: 8,
+      Z_MIN_LEVEL: -1,
+      Z_MAX_LEVEL: 9,
+      Z_DEFAULT_LEVEL: -1,
+      BROTLI_OPERATION_PROCESS: 0,
+      BROTLI_OPERATION_FLUSH: 1,
+      BROTLI_OPERATION_FINISH: 2,
+      BROTLI_OPERATION_EMIT_METADATA: 3,
+      BROTLI_MODE_GENERIC: 0,
+      BROTLI_MODE_TEXT: 1,
+      BROTLI_MODE_FONT: 2,
+      BROTLI_DEFAULT_MODE: 0,
+      BROTLI_MIN_QUALITY: 0,
+      BROTLI_MAX_QUALITY: 11,
+      BROTLI_DEFAULT_QUALITY: 11,
+      BROTLI_MIN_WINDOW_BITS: 10,
+      BROTLI_MAX_WINDOW_BITS: 24,
+      BROTLI_LARGE_MAX_WINDOW_BITS: 30,
+      BROTLI_DEFAULT_WINDOW: 22,
+      BROTLI_MIN_INPUT_BLOCK_BITS: 16,
+      BROTLI_MAX_INPUT_BLOCK_BITS: 24,
+      BROTLI_PARAM_MODE: 0,
+      BROTLI_PARAM_QUALITY: 1,
+      BROTLI_PARAM_LGWIN: 2,
+      BROTLI_PARAM_LGBLOCK: 3,
+      BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
+      BROTLI_PARAM_SIZE_HINT: 5,
+      BROTLI_PARAM_LARGE_WINDOW: 6,
+      BROTLI_PARAM_NPOSTFIX: 7,
+      BROTLI_PARAM_NDIRECT: 8,
+      BROTLI_DECODER_RESULT_ERROR: 0,
+      BROTLI_DECODER_RESULT_SUCCESS: 1,
+      BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
+      BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
+      BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
+      BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
+      BROTLI_DECODER_NO_ERROR: 0,
+      BROTLI_DECODER_SUCCESS: 1,
+      BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
+      BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
+      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
+      BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
+      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
+      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
+      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
+      BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
+      BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
+      BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
+      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
+      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
+      BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
+      BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
+      BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
+      BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
+      BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
+      BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
+      BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
+      BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
+      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
+      BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
+      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
+      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
+      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
+      BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
+      BROTLI_DECODER_ERROR_UNREACHABLE: -31
+    }, realZlibConstants));
+  }
+});
+
+// node_modules/minizlib/dist/esm/index.js
+var import_assert2, import_buffer, realZlib2, OriginalBufferConcat, desc, noop, passthroughBufferConcat, _superWrite, ZlibError, _flushFlag, ZlibBase, Zlib, Gzip, Unzip, Brotli, BrotliCompress, BrotliDecompress, Zstd, ZstdCompress, ZstdDecompress;
+var init_esm3 = __esm({
+  "node_modules/minizlib/dist/esm/index.js"() {
+    import_assert2 = __toESM(require("assert"), 1);
+    import_buffer = require("buffer");
+    init_esm();
+    realZlib2 = __toESM(require("zlib"), 1);
+    init_constants();
+    init_constants();
+    OriginalBufferConcat = import_buffer.Buffer.concat;
+    desc = Object.getOwnPropertyDescriptor(import_buffer.Buffer, "concat");
+    noop = (args) => args;
+    passthroughBufferConcat = desc?.writable === true || desc?.set !== void 0 ? (makeNoOp) => {
+      import_buffer.Buffer.concat = makeNoOp ? noop : OriginalBufferConcat;
+    } : (_) => {
+    };
+    _superWrite = /* @__PURE__ */ Symbol("_superWrite");
+    ZlibError = class extends Error {
+      code;
+      errno;
+      constructor(err, origin) {
+        super("zlib: " + err.message, { cause: err });
+        this.code = err.code;
+        this.errno = err.errno;
+        if (!this.code)
+          this.code = "ZLIB_ERROR";
+        this.message = "zlib: " + err.message;
+        Error.captureStackTrace(this, origin ?? this.constructor);
       }
-      return input.subarray(position.position, position.position = start);
-    }
-    function removeChars(buf, leading, trailing, predicate) {
-      let lead = 0;
-      let trail = buf.length - 1;
-      if (leading) {
-        while (lead < buf.length && predicate(buf[lead])) lead++;
+      get name() {
+        return "ZlibError";
       }
-      if (trailing) {
-        while (trail > 0 && predicate(buf[trail])) trail--;
+    };
+    _flushFlag = /* @__PURE__ */ Symbol("flushFlag");
+    ZlibBase = class extends Minipass {
+      #sawError = false;
+      #ended = false;
+      #flushFlag;
+      #finishFlushFlag;
+      #fullFlushFlag;
+      #handle;
+      #onError;
+      get sawError() {
+        return this.#sawError;
       }
-      return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1);
-    }
-    function bufferStartsWith(buffer, start, position) {
-      if (buffer.length < start.length) {
-        return false;
+      get handle() {
+        return this.#handle;
       }
-      for (let i = 0; i < start.length; i++) {
-        if (start[i] !== buffer[position.position + i]) {
-          return false;
-        }
+      /* c8 ignore start */
+      get flushFlag() {
+        return this.#flushFlag;
       }
-      return true;
-    }
-    module2.exports = {
-      multipartFormDataParser,
-      validateBoundary
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/body.js
-var require_body = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/body.js"(exports2, module2) {
-    "use strict";
-    var util = require_util();
-    var {
-      ReadableStreamFrom,
-      isBlobLike,
-      isReadableStreamLike,
-      readableStreamClose,
-      createDeferredPromise,
-      fullyReadBody,
-      extractMimeType,
-      utf8DecodeBytes
-    } = require_util3();
-    var { FormData } = require_formdata();
-    var { kState } = require_symbols2();
-    var { webidl } = require_webidl();
-    var { Blob: Blob2 } = require("node:buffer");
-    var assert5 = require("node:assert");
-    var { isErrored, isDisturbed } = require("node:stream");
-    var { isArrayBuffer } = require("node:util/types");
-    var { serializeAMimeType } = require_data_url();
-    var { multipartFormDataParser } = require_formdata_parser();
-    var random;
-    try {
-      const crypto = require("node:crypto");
-      random = (max) => crypto.randomInt(0, max);
-    } catch {
-      random = (max) => Math.floor(Math.random(max));
-    }
-    var textEncoder = new TextEncoder();
-    function noop3() {
-    }
-    var hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf("v18") !== 0;
-    var streamRegistry;
-    if (hasFinalizationRegistry) {
-      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(noop3);
+      /* c8 ignore stop */
+      constructor(opts, mode) {
+        if (!opts || typeof opts !== "object")
+          throw new TypeError("invalid options for ZlibBase constructor");
+        super(opts);
+        this.#flushFlag = opts.flush ?? 0;
+        this.#finishFlushFlag = opts.finishFlush ?? 0;
+        this.#fullFlushFlag = opts.fullFlushFlag ?? 0;
+        if (typeof realZlib2[mode] !== "function") {
+          throw new TypeError("Compression method not supported: " + mode);
         }
-      });
-    }
-    function extractBody(object, keepalive = false) {
-      let stream = null;
-      if (object instanceof ReadableStream) {
-        stream = object;
-      } else if (isBlobLike(object)) {
-        stream = object.stream();
-      } else {
-        stream = new ReadableStream({
-          async pull(controller) {
-            const buffer = typeof source === "string" ? textEncoder.encode(source) : source;
-            if (buffer.byteLength) {
-              controller.enqueue(buffer);
-            }
-            queueMicrotask(() => readableStreamClose(controller));
-          },
-          start() {
-          },
-          type: "bytes"
-        });
-      }
-      assert5(isReadableStreamLike(stream));
-      let action = null;
-      let source = null;
-      let length = null;
-      let type = null;
-      if (typeof object === "string") {
-        source = object;
-        type = "text/plain;charset=UTF-8";
-      } else if (object instanceof URLSearchParams) {
-        source = object.toString();
-        type = "application/x-www-form-urlencoded;charset=UTF-8";
-      } else if (isArrayBuffer(object)) {
-        source = new Uint8Array(object.slice());
-      } else if (ArrayBuffer.isView(object)) {
-        source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
-      } else if (util.isFormDataLike(object)) {
-        const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
-        const prefix = `--${boundary}\r
-Content-Disposition: form-data`;
-        const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
-        const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
-        const blobParts = [];
-        const rn = new Uint8Array([13, 10]);
-        length = 0;
-        let hasUnknownSizeValue = false;
-        for (const [name2, value] of object) {
-          if (typeof value === "string") {
-            const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name2))}"\r
-\r
-${normalizeLinefeeds(value)}\r
-`);
-            blobParts.push(chunk2);
-            length += chunk2.byteLength;
-          } else {
-            const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name2))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r
-Content-Type: ${value.type || "application/octet-stream"}\r
-\r
-`);
-            blobParts.push(chunk2, value, rn);
-            if (typeof value.size === "number") {
-              length += chunk2.byteLength + value.size + rn.byteLength;
-            } else {
-              hasUnknownSizeValue = true;
-            }
-          }
+        try {
+          this.#handle = new realZlib2[mode](opts);
+        } catch (er) {
+          throw new ZlibError(er, this.constructor);
         }
-        const chunk = textEncoder.encode(`--${boundary}--\r
-`);
-        blobParts.push(chunk);
-        length += chunk.byteLength;
-        if (hasUnknownSizeValue) {
-          length = null;
-        }
-        source = object;
-        action = async function* () {
-          for (const part of blobParts) {
-            if (part.stream) {
-              yield* part.stream();
-            } else {
-              yield part;
-            }
-          }
+        this.#onError = (err) => {
+          if (this.#sawError)
+            return;
+          this.#sawError = true;
+          this.close();
+          this.emit("error", err);
         };
-        type = `multipart/form-data; boundary=${boundary}`;
-      } else if (isBlobLike(object)) {
-        source = object;
-        length = object.size;
-        if (object.type) {
-          type = object.type;
-        }
-      } else if (typeof object[Symbol.asyncIterator] === "function") {
-        if (keepalive) {
-          throw new TypeError("keepalive");
-        }
-        if (util.isDisturbed(object) || object.locked) {
-          throw new TypeError(
-            "Response body object should not be disturbed or locked"
-          );
-        }
-        stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object);
-      }
-      if (typeof source === "string" || util.isBuffer(source)) {
-        length = Buffer.byteLength(source);
+        this.#handle?.on("error", (er) => this.#onError(new ZlibError(er)));
+        this.once("end", () => this.close);
       }
-      if (action != null) {
-        let iterator;
-        stream = new ReadableStream({
-          async start() {
-            iterator = action(object)[Symbol.asyncIterator]();
-          },
-          async pull(controller) {
-            const { value, done } = await iterator.next();
-            if (done) {
-              queueMicrotask(() => {
-                controller.close();
-                controller.byobRequest?.respond(0);
-              });
-            } else {
-              if (!isErrored(stream)) {
-                const buffer = new Uint8Array(value);
-                if (buffer.byteLength) {
-                  controller.enqueue(buffer);
-                }
-              }
-            }
-            return controller.desiredSize > 0;
-          },
-          async cancel(reason) {
-            await iterator.return();
-          },
-          type: "bytes"
-        });
+      close() {
+        if (this.#handle) {
+          this.#handle.close();
+          this.#handle = void 0;
+          this.emit("close");
+        }
       }
-      const body = { stream, source, length };
-      return [body, type];
-    }
-    function safelyExtractBody(object, keepalive = false) {
-      if (object instanceof ReadableStream) {
-        assert5(!util.isDisturbed(object), "The body has already been consumed.");
-        assert5(!object.locked, "The stream is locked.");
+      reset() {
+        if (!this.#sawError) {
+          (0, import_assert2.default)(this.#handle, "zlib binding closed");
+          return this.#handle.reset?.();
+        }
       }
-      return extractBody(object, keepalive);
-    }
-    function cloneBody(instance, body) {
-      const [out1, out2] = body.stream.tee();
-      body.stream = out1;
-      return {
-        stream: out2,
-        length: body.length,
-        source: body.source
-      };
-    }
-    function throwIfAborted(state) {
-      if (state.aborted) {
-        throw new DOMException("The operation was aborted.", "AbortError");
+      flush(flushFlag) {
+        if (this.ended)
+          return;
+        if (typeof flushFlag !== "number")
+          flushFlag = this.#fullFlushFlag;
+        this.write(Object.assign(import_buffer.Buffer.alloc(0), { [_flushFlag]: flushFlag }));
       }
-    }
-    function bodyMixinMethods(instance) {
-      const methods = {
-        blob() {
-          return consumeBody(this, (bytes) => {
-            let mimeType = bodyMimeType(this);
-            if (mimeType === null) {
-              mimeType = "";
-            } else if (mimeType) {
-              mimeType = serializeAMimeType(mimeType);
-            }
-            return new Blob2([bytes], { type: mimeType });
-          }, instance);
-        },
-        arrayBuffer() {
-          return consumeBody(this, (bytes) => {
-            return new Uint8Array(bytes).buffer;
-          }, instance);
-        },
-        text() {
-          return consumeBody(this, utf8DecodeBytes, instance);
-        },
-        json() {
-          return consumeBody(this, parseJSONFromBytes, instance);
-        },
-        formData() {
-          return consumeBody(this, (value) => {
-            const mimeType = bodyMimeType(this);
-            if (mimeType !== null) {
-              switch (mimeType.essence) {
-                case "multipart/form-data": {
-                  const parsed = multipartFormDataParser(value, mimeType);
-                  if (parsed === "failure") {
-                    throw new TypeError("Failed to parse body as FormData.");
-                  }
-                  const fd = new FormData();
-                  fd[kState] = parsed;
-                  return fd;
-                }
-                case "application/x-www-form-urlencoded": {
-                  const entries = new URLSearchParams(value.toString());
-                  const fd = new FormData();
-                  for (const [name2, value2] of entries) {
-                    fd.append(name2, value2);
-                  }
-                  return fd;
-                }
-              }
-            }
-            throw new TypeError(
-              'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".'
-            );
-          }, instance);
-        },
-        bytes() {
-          return consumeBody(this, (bytes) => {
-            return new Uint8Array(bytes);
-          }, instance);
+      end(chunk, encoding, cb) {
+        if (typeof chunk === "function") {
+          cb = chunk;
+          encoding = void 0;
+          chunk = void 0;
         }
-      };
-      return methods;
-    }
-    function mixinBody(prototype) {
-      Object.assign(prototype.prototype, bodyMixinMethods(prototype));
-    }
-    async function consumeBody(object, convertBytesToJSValue, instance) {
-      webidl.brandCheck(object, instance);
-      if (bodyUnusable(object)) {
-        throw new TypeError("Body is unusable: Body has already been read");
-      }
-      throwIfAborted(object[kState]);
-      const promise = createDeferredPromise();
-      const errorSteps = (error) => promise.reject(error);
-      const successSteps = (data) => {
-        try {
-          promise.resolve(convertBytesToJSValue(data));
-        } catch (e) {
-          errorSteps(e);
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = void 0;
         }
-      };
-      if (object[kState].body == null) {
-        successSteps(Buffer.allocUnsafe(0));
-        return promise.promise;
+        if (chunk) {
+          if (encoding)
+            this.write(chunk, encoding);
+          else
+            this.write(chunk);
+        }
+        this.flush(this.#finishFlushFlag);
+        this.#ended = true;
+        return super.end(cb);
       }
-      await fullyReadBody(object[kState].body, successSteps, errorSteps);
-      return promise.promise;
-    }
-    function bodyUnusable(object) {
-      const body = object[kState].body;
-      return body != null && (body.stream.locked || util.isDisturbed(body.stream));
-    }
-    function parseJSONFromBytes(bytes) {
-      return JSON.parse(utf8DecodeBytes(bytes));
-    }
-    function bodyMimeType(requestOrResponse) {
-      const headers = requestOrResponse[kState].headersList;
-      const mimeType = extractMimeType(headers);
-      if (mimeType === "failure") {
-        return null;
+      get ended() {
+        return this.#ended;
       }
-      return mimeType;
-    }
-    module2.exports = {
-      extractBody,
-      safelyExtractBody,
-      cloneBody,
-      mixinBody,
-      streamRegistry,
-      hasFinalizationRegistry,
-      bodyUnusable
-    };
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h1.js
-var require_client_h1 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h1.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var util = require_util();
-    var { channels } = require_diagnostics();
-    var timers = require_timers();
-    var {
-      RequestContentLengthMismatchError,
-      ResponseContentLengthMismatchError,
-      RequestAbortedError,
-      HeadersTimeoutError,
-      HeadersOverflowError,
-      SocketError,
-      InformationalError,
-      BodyTimeoutError,
-      HTTPParserError,
-      ResponseExceededMaxSizeError
-    } = require_errors();
-    var {
-      kUrl,
-      kReset,
-      kClient,
-      kParser,
-      kBlocking,
-      kRunning,
-      kPending,
-      kSize,
-      kWriting,
-      kQueue,
-      kNoRef,
-      kKeepAliveDefaultTimeout,
-      kHostHeader,
-      kPendingIdx,
-      kRunningIdx,
-      kError,
-      kPipelining,
-      kSocket,
-      kKeepAliveTimeoutValue,
-      kMaxHeadersSize,
-      kKeepAliveMaxTimeout,
-      kKeepAliveTimeoutThreshold,
-      kHeadersTimeout,
-      kBodyTimeout,
-      kStrictContentLength,
-      kMaxRequests,
-      kCounter,
-      kMaxResponseSize,
-      kOnError,
-      kResume,
-      kHTTPContext
-    } = require_symbols();
-    var constants2 = require_constants3();
-    var EMPTY_BUF = Buffer.alloc(0);
-    var FastBuffer = Buffer[Symbol.species];
-    var addListener = util.addListener;
-    var removeAllListeners = util.removeAllListeners;
-    var extractBody;
-    async function lazyllhttp() {
-      const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
-      let mod;
-      try {
-        mod = await WebAssembly.compile(require_llhttp_simd_wasm());
-      } catch (e) {
-        mod = await WebAssembly.compile(llhttpWasmData || require_llhttp_wasm());
-      }
-      return await WebAssembly.instantiate(mod, {
-        env: {
-          /* eslint-disable camelcase */
-          wasm_on_url: (p, at, len) => {
-            return 0;
-          },
-          wasm_on_status: (p, at, len) => {
-            assert5(currentParser.ptr === p);
-            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
-            return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
-          },
-          wasm_on_message_begin: (p) => {
-            assert5(currentParser.ptr === p);
-            return currentParser.onMessageBegin() || 0;
-          },
-          wasm_on_header_field: (p, at, len) => {
-            assert5(currentParser.ptr === p);
-            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
-            return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
-          },
-          wasm_on_header_value: (p, at, len) => {
-            assert5(currentParser.ptr === p);
-            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
-            return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
-          },
-          wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
-            assert5(currentParser.ptr === p);
-            return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
-          },
-          wasm_on_body: (p, at, len) => {
-            assert5(currentParser.ptr === p);
-            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
-            return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
-          },
-          wasm_on_message_complete: (p) => {
-            assert5(currentParser.ptr === p);
-            return currentParser.onMessageComplete() || 0;
-          }
-          /* eslint-enable camelcase */
-        }
-      });
-    }
-    var llhttpInstance = null;
-    var llhttpPromise = lazyllhttp();
-    llhttpPromise.catch();
-    var currentParser = null;
-    var currentBufferRef = null;
-    var currentBufferSize = 0;
-    var currentBufferPtr = null;
-    var USE_NATIVE_TIMER = 0;
-    var USE_FAST_TIMER = 1;
-    var TIMEOUT_HEADERS = 2 | USE_FAST_TIMER;
-    var TIMEOUT_BODY = 4 | USE_FAST_TIMER;
-    var TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER;
-    var Parser2 = class {
-      constructor(client, socket, { exports: exports3 }) {
-        assert5(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
-        this.llhttp = exports3;
-        this.ptr = this.llhttp.llhttp_alloc(constants2.TYPE.RESPONSE);
-        this.client = client;
-        this.socket = socket;
-        this.timeout = null;
-        this.timeoutValue = null;
-        this.timeoutType = null;
-        this.statusCode = null;
-        this.statusText = "";
-        this.upgrade = false;
-        this.headers = [];
-        this.headersSize = 0;
-        this.headersMaxSize = client[kMaxHeadersSize];
-        this.shouldKeepAlive = false;
-        this.paused = false;
-        this.resume = this.resume.bind(this);
-        this.bytesRead = 0;
-        this.keepAlive = "";
-        this.contentLength = "";
-        this.connection = "";
-        this.maxResponseSize = client[kMaxResponseSize];
-      }
-      setTimeout(delay, type) {
-        if (delay !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
-          if (this.timeout) {
-            timers.clearTimeout(this.timeout);
-            this.timeout = null;
-          }
-          if (delay) {
-            if (type & USE_FAST_TIMER) {
-              this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this));
-            } else {
-              this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this));
-              this.timeout.unref();
-            }
-          }
-          this.timeoutValue = delay;
-        } else if (this.timeout) {
-          if (this.timeout.refresh) {
-            this.timeout.refresh();
-          }
-        }
-        this.timeoutType = type;
+      // overridden in the gzip classes to do portable writes
+      [_superWrite](data) {
+        return super.write(data);
       }
-      resume() {
-        if (this.socket.destroyed || !this.paused) {
+      write(chunk, encoding, cb) {
+        if (typeof encoding === "function")
+          cb = encoding, encoding = "utf8";
+        if (typeof chunk === "string")
+          chunk = import_buffer.Buffer.from(chunk, encoding);
+        if (this.#sawError)
           return;
-        }
-        assert5(this.ptr != null);
-        assert5(currentParser == null);
-        this.llhttp.llhttp_resume(this.ptr);
-        assert5(this.timeoutType === TIMEOUT_BODY);
-        if (this.timeout) {
-          if (this.timeout.refresh) {
-            this.timeout.refresh();
+        (0, import_assert2.default)(this.#handle, "zlib binding closed");
+        const nativeHandle = this.#handle._handle;
+        const originalNativeClose = nativeHandle.close;
+        nativeHandle.close = () => {
+        };
+        const originalClose = this.#handle.close;
+        this.#handle.close = () => {
+        };
+        passthroughBufferConcat(true);
+        let result = void 0;
+        try {
+          const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this.#flushFlag;
+          result = this.#handle._processChunk(chunk, flushFlag);
+          passthroughBufferConcat(false);
+        } catch (err) {
+          passthroughBufferConcat(false);
+          this.#onError(new ZlibError(err, this.write));
+        } finally {
+          if (this.#handle) {
+            ;
+            this.#handle._handle = nativeHandle;
+            nativeHandle.close = originalNativeClose;
+            this.#handle.close = originalClose;
+            this.#handle.removeAllListeners("error");
           }
         }
-        this.paused = false;
-        this.execute(this.socket.read() || EMPTY_BUF);
-        this.readMore();
-      }
-      readMore() {
-        while (!this.paused && this.ptr) {
-          const chunk = this.socket.read();
-          if (chunk === null) {
-            break;
+        if (this.#handle)
+          this.#handle.on("error", (er) => this.#onError(new ZlibError(er, this.write)));
+        let writeReturn;
+        if (result) {
+          if (Array.isArray(result) && result.length > 0) {
+            const r = result[0];
+            writeReturn = this[_superWrite](import_buffer.Buffer.from(r));
+            for (let i = 1; i < result.length; i++) {
+              writeReturn = this[_superWrite](result[i]);
+            }
+          } else {
+            writeReturn = this[_superWrite](import_buffer.Buffer.from(result));
           }
-          this.execute(chunk);
         }
+        if (cb)
+          cb();
+        return writeReturn;
       }
-      execute(data) {
-        assert5(this.ptr != null);
-        assert5(currentParser == null);
-        assert5(!this.paused);
-        const { socket, llhttp } = this;
-        if (data.length > currentBufferSize) {
-          if (currentBufferPtr) {
-            llhttp.free(currentBufferPtr);
-          }
-          currentBufferSize = Math.ceil(data.length / 4096) * 4096;
-          currentBufferPtr = llhttp.malloc(currentBufferSize);
-        }
-        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
-        try {
-          let ret;
+    };
+    Zlib = class extends ZlibBase {
+      #level;
+      #strategy;
+      constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants.Z_NO_FLUSH;
+        opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
+        opts.fullFlushFlag = constants.Z_FULL_FLUSH;
+        super(opts, mode);
+        this.#level = opts.level;
+        this.#strategy = opts.strategy;
+      }
+      params(level, strategy) {
+        if (this.sawError)
+          return;
+        if (!this.handle)
+          throw new Error("cannot switch params when binding is closed");
+        if (!this.handle.params)
+          throw new Error("not supported in this implementation");
+        if (this.#level !== level || this.#strategy !== strategy) {
+          this.flush(constants.Z_SYNC_FLUSH);
+          (0, import_assert2.default)(this.handle, "zlib binding closed");
+          const origFlush = this.handle.flush;
+          this.handle.flush = (flushFlag, cb) => {
+            if (typeof flushFlag === "function") {
+              cb = flushFlag;
+              flushFlag = this.flushFlag;
+            }
+            this.flush(flushFlag);
+            cb?.();
+          };
           try {
-            currentBufferRef = data;
-            currentParser = this;
-            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
-          } catch (err) {
-            throw err;
+            ;
+            this.handle.params(level, strategy);
           } finally {
-            currentParser = null;
-            currentBufferRef = null;
+            this.handle.flush = origFlush;
           }
-          const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
-          if (ret === constants2.ERROR.PAUSED_UPGRADE) {
-            this.onUpgrade(data.slice(offset));
-          } else if (ret === constants2.ERROR.PAUSED) {
-            this.paused = true;
-            socket.unshift(data.slice(offset));
-          } else if (ret !== constants2.ERROR.OK) {
-            const ptr = llhttp.llhttp_get_error_reason(this.ptr);
-            let message = "";
-            if (ptr) {
-              const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
-              message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
-            }
-            throw new HTTPParserError(message, constants2.ERROR[ret], data.slice(offset));
+          if (this.handle) {
+            this.#level = level;
+            this.#strategy = strategy;
           }
-        } catch (err) {
-          util.destroy(socket, err);
-        }
-      }
-      destroy() {
-        assert5(this.ptr != null);
-        assert5(currentParser == null);
-        this.llhttp.llhttp_free(this.ptr);
-        this.ptr = null;
-        this.timeout && timers.clearTimeout(this.timeout);
-        this.timeout = null;
-        this.timeoutValue = null;
-        this.timeoutType = null;
-        this.paused = false;
-      }
-      onStatus(buf) {
-        this.statusText = buf.toString();
-      }
-      onMessageBegin() {
-        const { socket, client } = this;
-        if (socket.destroyed) {
-          return -1;
-        }
-        const request = client[kQueue][client[kRunningIdx]];
-        if (!request) {
-          return -1;
         }
-        request.onResponseStarted();
       }
-      onHeaderField(buf) {
-        const len = this.headers.length;
-        if ((len & 1) === 0) {
-          this.headers.push(buf);
-        } else {
-          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
-        }
-        this.trackHeader(buf.length);
+    };
+    Gzip = class extends Zlib {
+      #portable;
+      constructor(opts) {
+        super(opts, "Gzip");
+        this.#portable = opts && !!opts.portable;
       }
-      onHeaderValue(buf) {
-        let len = this.headers.length;
-        if ((len & 1) === 1) {
-          this.headers.push(buf);
-          len += 1;
-        } else {
-          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
-        }
-        const key = this.headers[len - 2];
-        if (key.length === 10) {
-          const headerName = util.bufferToLowerCasedHeaderName(key);
-          if (headerName === "keep-alive") {
-            this.keepAlive += buf.toString();
-          } else if (headerName === "connection") {
-            this.connection += buf.toString();
-          }
-        } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length") {
-          this.contentLength += buf.toString();
-        }
-        this.trackHeader(buf.length);
-      }
-      trackHeader(len) {
-        this.headersSize += len;
-        if (this.headersSize >= this.headersMaxSize) {
-          util.destroy(this.socket, new HeadersOverflowError());
-        }
-      }
-      onUpgrade(head) {
-        const { upgrade, client, socket, headers, statusCode } = this;
-        assert5(upgrade);
-        assert5(client[kSocket] === socket);
-        assert5(!socket.destroyed);
-        assert5(!this.paused);
-        assert5((headers.length & 1) === 0);
-        const request = client[kQueue][client[kRunningIdx]];
-        assert5(request);
-        assert5(request.upgrade || request.method === "CONNECT");
-        this.statusCode = null;
-        this.statusText = "";
-        this.shouldKeepAlive = null;
-        this.headers = [];
-        this.headersSize = 0;
-        socket.unshift(head);
-        socket[kParser].destroy();
-        socket[kParser] = null;
-        socket[kClient] = null;
-        socket[kError] = null;
-        removeAllListeners(socket);
-        client[kSocket] = null;
-        client[kHTTPContext] = null;
-        client[kQueue][client[kRunningIdx]++] = null;
-        client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
-        try {
-          request.onUpgrade(statusCode, headers, socket);
-        } catch (err) {
-          util.destroy(socket, err);
-        }
-        client[kResume]();
+      [_superWrite](data) {
+        if (!this.#portable)
+          return super[_superWrite](data);
+        this.#portable = false;
+        data[9] = 255;
+        return super[_superWrite](data);
       }
-      onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
-        const { client, socket, headers, statusText } = this;
-        if (socket.destroyed) {
-          return -1;
-        }
-        const request = client[kQueue][client[kRunningIdx]];
-        if (!request) {
-          return -1;
-        }
-        assert5(!this.upgrade);
-        assert5(this.statusCode < 200);
-        if (statusCode === 100) {
-          util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
-          return -1;
-        }
-        if (upgrade && !request.upgrade) {
-          util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
-          return -1;
-        }
-        assert5(this.timeoutType === TIMEOUT_HEADERS);
-        this.statusCode = statusCode;
-        this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
-        request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
-        if (this.statusCode >= 200) {
-          const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
-          this.setTimeout(bodyTimeout, TIMEOUT_BODY);
-        } else if (this.timeout) {
-          if (this.timeout.refresh) {
-            this.timeout.refresh();
-          }
-        }
-        if (request.method === "CONNECT") {
-          assert5(client[kRunning] === 1);
-          this.upgrade = true;
-          return 2;
-        }
-        if (upgrade) {
-          assert5(client[kRunning] === 1);
-          this.upgrade = true;
-          return 2;
-        }
-        assert5((this.headers.length & 1) === 0);
-        this.headers = [];
-        this.headersSize = 0;
-        if (this.shouldKeepAlive && client[kPipelining]) {
-          const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
-          if (keepAliveTimeout != null) {
-            const timeout = Math.min(
-              keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
-              client[kKeepAliveMaxTimeout]
-            );
-            if (timeout <= 0) {
-              socket[kReset] = true;
-            } else {
-              client[kKeepAliveTimeoutValue] = timeout;
-            }
-          } else {
-            client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
-          }
-        } else {
-          socket[kReset] = true;
-        }
-        const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
-        if (request.aborted) {
-          return -1;
-        }
-        if (request.method === "HEAD") {
-          return 1;
-        }
-        if (statusCode < 200) {
-          return 1;
-        }
-        if (socket[kBlocking]) {
-          socket[kBlocking] = false;
-          client[kResume]();
-        }
-        return pause ? constants2.ERROR.PAUSED : 0;
+    };
+    Unzip = class extends Zlib {
+      constructor(opts) {
+        super(opts, "Unzip");
       }
-      onBody(buf) {
-        const { client, socket, statusCode, maxResponseSize } = this;
-        if (socket.destroyed) {
-          return -1;
-        }
-        const request = client[kQueue][client[kRunningIdx]];
-        assert5(request);
-        assert5(this.timeoutType === TIMEOUT_BODY);
-        if (this.timeout) {
-          if (this.timeout.refresh) {
-            this.timeout.refresh();
-          }
-        }
-        assert5(statusCode >= 200);
-        if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
-          util.destroy(socket, new ResponseExceededMaxSizeError());
-          return -1;
-        }
-        this.bytesRead += buf.length;
-        if (request.onData(buf) === false) {
-          return constants2.ERROR.PAUSED;
-        }
+    };
+    Brotli = class extends ZlibBase {
+      constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
+        opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
+        opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
+        super(opts, mode);
       }
-      onMessageComplete() {
-        const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
-        if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
-          return -1;
-        }
-        if (upgrade) {
-          return;
-        }
-        assert5(statusCode >= 100);
-        assert5((this.headers.length & 1) === 0);
-        const request = client[kQueue][client[kRunningIdx]];
-        assert5(request);
-        this.statusCode = null;
-        this.statusText = "";
-        this.bytesRead = 0;
-        this.contentLength = "";
-        this.keepAlive = "";
-        this.connection = "";
-        this.headers = [];
-        this.headersSize = 0;
-        if (statusCode < 200) {
-          return;
-        }
-        if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
-          util.destroy(socket, new ResponseContentLengthMismatchError());
-          return -1;
-        }
-        request.onComplete(headers);
-        client[kQueue][client[kRunningIdx]++] = null;
-        if (socket[kWriting]) {
-          assert5(client[kRunning] === 0);
-          util.destroy(socket, new InformationalError("reset"));
-          return constants2.ERROR.PAUSED;
-        } else if (!shouldKeepAlive) {
-          util.destroy(socket, new InformationalError("reset"));
-          return constants2.ERROR.PAUSED;
-        } else if (socket[kReset] && client[kRunning] === 0) {
-          util.destroy(socket, new InformationalError("reset"));
-          return constants2.ERROR.PAUSED;
-        } else if (client[kPipelining] == null || client[kPipelining] === 1) {
-          setImmediate(() => client[kResume]());
-        } else {
-          client[kResume]();
-        }
+    };
+    BrotliCompress = class extends Brotli {
+      constructor(opts) {
+        super(opts, "BrotliCompress");
       }
     };
-    function onParserTimeout(parser) {
-      const { socket, timeoutType, client, paused } = parser.deref();
-      if (timeoutType === TIMEOUT_HEADERS) {
-        if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
-          assert5(!paused, "cannot be paused while waiting for headers");
-          util.destroy(socket, new HeadersTimeoutError());
-        }
-      } else if (timeoutType === TIMEOUT_BODY) {
-        if (!paused) {
-          util.destroy(socket, new BodyTimeoutError());
-        }
-      } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
-        assert5(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
-        util.destroy(socket, new InformationalError("socket idle timeout"));
+    BrotliDecompress = class extends Brotli {
+      constructor(opts) {
+        super(opts, "BrotliDecompress");
       }
-    }
-    async function connectH1(client, socket) {
-      client[kSocket] = socket;
-      if (!llhttpInstance) {
-        llhttpInstance = await llhttpPromise;
-        llhttpPromise = null;
-      }
-      socket[kNoRef] = false;
-      socket[kWriting] = false;
-      socket[kReset] = false;
-      socket[kBlocking] = false;
-      socket[kParser] = new Parser2(client, socket, llhttpInstance);
-      addListener(socket, "error", function(err) {
-        assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
-        const parser = this[kParser];
-        if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
-          parser.onMessageComplete();
-          return;
-        }
-        this[kError] = err;
-        this[kClient][kOnError](err);
-      });
-      addListener(socket, "readable", function() {
-        const parser = this[kParser];
-        if (parser) {
-          parser.readMore();
-        }
-      });
-      addListener(socket, "end", function() {
-        const parser = this[kParser];
-        if (parser.statusCode && !parser.shouldKeepAlive) {
-          parser.onMessageComplete();
-          return;
-        }
-        util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
-      });
-      addListener(socket, "close", function() {
-        const client2 = this[kClient];
-        const parser = this[kParser];
-        if (parser) {
-          if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-            parser.onMessageComplete();
-          }
-          this[kParser].destroy();
-          this[kParser] = null;
-        }
-        const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
-        client2[kSocket] = null;
-        client2[kHTTPContext] = null;
-        if (client2.destroyed) {
-          assert5(client2[kPending] === 0);
-          const requests = client2[kQueue].splice(client2[kRunningIdx]);
-          for (let i = 0; i < requests.length; i++) {
-            const request = requests[i];
-            util.errorRequest(client2, request, err);
-          }
-        } else if (client2[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
-          const request = client2[kQueue][client2[kRunningIdx]];
-          client2[kQueue][client2[kRunningIdx]++] = null;
-          util.errorRequest(client2, request, err);
-        }
-        client2[kPendingIdx] = client2[kRunningIdx];
-        assert5(client2[kRunning] === 0);
-        client2.emit("disconnect", client2[kUrl], [client2], err);
-        client2[kResume]();
-      });
-      let closed = false;
-      socket.on("close", () => {
-        closed = true;
-      });
-      return {
-        version: "h1",
-        defaultPipelining: 1,
-        write(...args) {
-          return writeH1(client, ...args);
-        },
-        resume() {
-          resumeH1(client);
-        },
-        destroy(err, callback) {
-          if (closed) {
-            queueMicrotask(callback);
-          } else {
-            socket.destroy(err).on("close", callback);
-          }
-        },
-        get destroyed() {
-          return socket.destroyed;
-        },
-        busy(request) {
-          if (socket[kWriting] || socket[kReset] || socket[kBlocking]) {
-            return true;
-          }
-          if (request) {
-            if (client[kRunning] > 0 && !request.idempotent) {
-              return true;
-            }
-            if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) {
-              return true;
-            }
-            if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) {
-              return true;
-            }
-          }
-          return false;
-        }
-      };
-    }
-    function resumeH1(client) {
-      const socket = client[kSocket];
-      if (socket && !socket.destroyed) {
-        if (client[kSize] === 0) {
-          if (!socket[kNoRef] && socket.unref) {
-            socket.unref();
-            socket[kNoRef] = true;
-          }
-        } else if (socket[kNoRef] && socket.ref) {
-          socket.ref();
-          socket[kNoRef] = false;
-        }
-        if (client[kSize] === 0) {
-          if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
-            socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE);
-          }
-        } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
-          if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
-            const request = client[kQueue][client[kRunningIdx]];
-            const headersTimeout = request.headersTimeout != null ? request.headersTimeout : client[kHeadersTimeout];
-            socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
-          }
-        }
-      }
-    }
-    function shouldSendContentLength(method) {
-      return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
-    }
-    function writeH1(client, request) {
-      const { method, path: path16, host, upgrade, blocking, reset } = request;
-      let { body, headers, contentLength } = request;
-      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
-      if (util.isFormDataLike(body)) {
-        if (!extractBody) {
-          extractBody = require_body().extractBody;
-        }
-        const [bodyStream, contentType] = extractBody(body);
-        if (request.contentType == null) {
-          headers.push("content-type", contentType);
-        }
-        body = bodyStream.stream;
-        contentLength = bodyStream.length;
-      } else if (util.isBlobLike(body) && request.contentType == null && body.type) {
-        headers.push("content-type", body.type);
-      }
-      if (body && typeof body.read === "function") {
-        body.read(0);
-      }
-      const bodyLength = util.bodyLength(body);
-      contentLength = bodyLength ?? contentLength;
-      if (contentLength === null) {
-        contentLength = request.contentLength;
-      }
-      if (contentLength === 0 && !expectsPayload) {
-        contentLength = null;
-      }
-      if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
-        if (client[kStrictContentLength]) {
-          util.errorRequest(client, request, new RequestContentLengthMismatchError());
-          return false;
-        }
-        process.emitWarning(new RequestContentLengthMismatchError());
-      }
-      const socket = client[kSocket];
-      const abort = (err) => {
-        if (request.aborted || request.completed) {
-          return;
-        }
-        util.errorRequest(client, request, err || new RequestAbortedError());
-        util.destroy(body);
-        util.destroy(socket, new InformationalError("aborted"));
-      };
-      try {
-        request.onConnect(abort);
-      } catch (err) {
-        util.errorRequest(client, request, err);
-      }
-      if (request.aborted) {
-        return false;
-      }
-      if (method === "HEAD") {
-        socket[kReset] = true;
-      }
-      if (upgrade || method === "CONNECT") {
-        socket[kReset] = true;
-      }
-      if (reset != null) {
-        socket[kReset] = reset;
-      }
-      if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
-        socket[kReset] = true;
+    };
+    Zstd = class extends ZlibBase {
+      constructor(opts, mode) {
+        opts = opts || {};
+        opts.flush = opts.flush || constants.ZSTD_e_continue;
+        opts.finishFlush = opts.finishFlush || constants.ZSTD_e_end;
+        opts.fullFlushFlag = constants.ZSTD_e_flush;
+        super(opts, mode);
       }
-      if (blocking) {
-        socket[kBlocking] = true;
+    };
+    ZstdCompress = class extends Zstd {
+      constructor(opts) {
+        super(opts, "ZstdCompress");
       }
-      let header = `${method} ${path16} HTTP/1.1\r
-`;
-      if (typeof host === "string") {
-        header += `host: ${host}\r
-`;
-      } else {
-        header += client[kHostHeader];
+    };
+    ZstdDecompress = class extends Zstd {
+      constructor(opts) {
+        super(opts, "ZstdDecompress");
       }
-      if (upgrade) {
-        header += `connection: upgrade\r
-upgrade: ${upgrade}\r
-`;
-      } else if (client[kPipelining] && !socket[kReset]) {
-        header += "connection: keep-alive\r\n";
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/large-numbers.js
+var encode, encodePositive, encodeNegative, parse, twos, pos, onesComp, twosComp;
+var init_large_numbers = __esm({
+  "node_modules/tar/dist/esm/large-numbers.js"() {
+    encode = (num, buf) => {
+      if (!Number.isSafeInteger(num)) {
+        throw Error("cannot encode number outside of javascript safe integer range");
+      } else if (num < 0) {
+        encodeNegative(num, buf);
       } else {
-        header += "connection: close\r\n";
-      }
-      if (Array.isArray(headers)) {
-        for (let n = 0; n < headers.length; n += 2) {
-          const key = headers[n + 0];
-          const val = headers[n + 1];
-          if (Array.isArray(val)) {
-            for (let i = 0; i < val.length; i++) {
-              header += `${key}: ${val[i]}\r
-`;
-            }
-          } else {
-            header += `${key}: ${val}\r
-`;
-          }
-        }
-      }
-      if (channels.sendHeaders.hasSubscribers) {
-        channels.sendHeaders.publish({ request, headers: header, socket });
+        encodePositive(num, buf);
       }
-      if (!body || bodyLength === 0) {
-        writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload);
-      } else if (util.isBuffer(body)) {
-        writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload);
-      } else if (util.isBlobLike(body)) {
-        if (typeof body.stream === "function") {
-          writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload);
-        } else {
-          writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload);
-        }
-      } else if (util.isStream(body)) {
-        writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload);
-      } else if (util.isIterable(body)) {
-        writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload);
-      } else {
-        assert5(false);
+      return buf;
+    };
+    encodePositive = (num, buf) => {
+      buf[0] = 128;
+      for (var i = buf.length; i > 1; i--) {
+        buf[i - 1] = num & 255;
+        num = Math.floor(num / 256);
       }
-      return true;
-    }
-    function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) {
-      assert5(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
-      let finished = false;
-      const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header });
-      const onData = function(chunk) {
-        if (finished) {
-          return;
-        }
-        try {
-          if (!writer.write(chunk) && this.pause) {
-            this.pause();
-          }
-        } catch (err) {
-          util.destroy(this, err);
-        }
-      };
-      const onDrain = function() {
-        if (finished) {
-          return;
-        }
-        if (body.resume) {
-          body.resume();
-        }
-      };
-      const onClose = function() {
-        queueMicrotask(() => {
-          body.removeListener("error", onFinished);
-        });
-        if (!finished) {
-          const err = new RequestAbortedError();
-          queueMicrotask(() => onFinished(err));
-        }
-      };
-      const onFinished = function(err) {
-        if (finished) {
-          return;
-        }
-        finished = true;
-        assert5(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
-        socket.off("drain", onDrain).off("error", onFinished);
-        body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose);
-        if (!err) {
-          try {
-            writer.end();
-          } catch (er) {
-            err = er;
-          }
-        }
-        writer.destroy(err);
-        if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
-          util.destroy(body, err);
+    };
+    encodeNegative = (num, buf) => {
+      buf[0] = 255;
+      var flipped = false;
+      num = num * -1;
+      for (var i = buf.length; i > 1; i--) {
+        var byte = num & 255;
+        num = Math.floor(num / 256);
+        if (flipped) {
+          buf[i - 1] = onesComp(byte);
+        } else if (byte === 0) {
+          buf[i - 1] = 0;
         } else {
-          util.destroy(body);
-        }
-      };
-      body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose);
-      if (body.resume) {
-        body.resume();
-      }
-      socket.on("drain", onDrain).on("error", onFinished);
-      if (body.errorEmitted ?? body.errored) {
-        setImmediate(() => onFinished(body.errored));
-      } else if (body.endEmitted ?? body.readableEnded) {
-        setImmediate(() => onFinished(null));
-      }
-      if (body.closeEmitted ?? body.closed) {
-        setImmediate(onClose);
-      }
-    }
-    function writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload) {
-      try {
-        if (!body) {
-          if (contentLength === 0) {
-            socket.write(`${header}content-length: 0\r
-\r
-`, "latin1");
-          } else {
-            assert5(contentLength === null, "no body must not have content length");
-            socket.write(`${header}\r
-`, "latin1");
-          }
-        } else if (util.isBuffer(body)) {
-          assert5(contentLength === body.byteLength, "buffer body must have content length");
-          socket.cork();
-          socket.write(`${header}content-length: ${contentLength}\r
-\r
-`, "latin1");
-          socket.write(body);
-          socket.uncork();
-          request.onBodySent(body);
-          if (!expectsPayload && request.reset !== false) {
-            socket[kReset] = true;
-          }
+          flipped = true;
+          buf[i - 1] = twosComp(byte);
         }
-        request.onRequestSent();
-        client[kResume]();
-      } catch (err) {
-        abort(err);
       }
-    }
-    async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) {
-      assert5(contentLength === body.size, "blob body must have content length");
-      try {
-        if (contentLength != null && contentLength !== body.size) {
-          throw new RequestContentLengthMismatchError();
-        }
-        const buffer = Buffer.from(await body.arrayBuffer());
-        socket.cork();
-        socket.write(`${header}content-length: ${contentLength}\r
-\r
-`, "latin1");
-        socket.write(buffer);
-        socket.uncork();
-        request.onBodySent(buffer);
-        request.onRequestSent();
-        if (!expectsPayload && request.reset !== false) {
-          socket[kReset] = true;
-        }
-        client[kResume]();
-      } catch (err) {
-        abort(err);
+    };
+    parse = (buf) => {
+      const pre = buf[0];
+      const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
+      if (value === null) {
+        throw Error("invalid base256 encoding");
       }
-    }
-    async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) {
-      assert5(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
-      let callback = null;
-      function onDrain() {
-        if (callback) {
-          const cb = callback;
-          callback = null;
-          cb();
-        }
+      if (!Number.isSafeInteger(value)) {
+        throw Error("parsed number outside of javascript safe integer range");
       }
-      const waitForDrain = () => new Promise((resolve, reject) => {
-        assert5(callback === null);
-        if (socket[kError]) {
-          reject(socket[kError]);
+      return value;
+    };
+    twos = (buf) => {
+      var len = buf.length;
+      var sum = 0;
+      var flipped = false;
+      for (var i = len - 1; i > -1; i--) {
+        var byte = Number(buf[i]);
+        var f;
+        if (flipped) {
+          f = onesComp(byte);
+        } else if (byte === 0) {
+          f = byte;
         } else {
-          callback = resolve;
-        }
-      });
-      socket.on("close", onDrain).on("drain", onDrain);
-      const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header });
-      try {
-        for await (const chunk of body) {
-          if (socket[kError]) {
-            throw socket[kError];
-          }
-          if (!writer.write(chunk)) {
-            await waitForDrain();
-          }
-        }
-        writer.end();
-      } catch (err) {
-        writer.destroy(err);
-      } finally {
-        socket.off("close", onDrain).off("drain", onDrain);
-      }
-    }
-    var AsyncWriter = class {
-      constructor({ abort, socket, request, contentLength, client, expectsPayload, header }) {
-        this.socket = socket;
-        this.request = request;
-        this.contentLength = contentLength;
-        this.client = client;
-        this.bytesWritten = 0;
-        this.expectsPayload = expectsPayload;
-        this.header = header;
-        this.abort = abort;
-        socket[kWriting] = true;
-      }
-      write(chunk) {
-        const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
-        if (socket[kError]) {
-          throw socket[kError];
-        }
-        if (socket.destroyed) {
-          return false;
-        }
-        const len = Buffer.byteLength(chunk);
-        if (!len) {
-          return true;
-        }
-        if (contentLength !== null && bytesWritten + len > contentLength) {
-          if (client[kStrictContentLength]) {
-            throw new RequestContentLengthMismatchError();
-          }
-          process.emitWarning(new RequestContentLengthMismatchError());
-        }
-        socket.cork();
-        if (bytesWritten === 0) {
-          if (!expectsPayload && request.reset !== false) {
-            socket[kReset] = true;
-          }
-          if (contentLength === null) {
-            socket.write(`${header}transfer-encoding: chunked\r
-`, "latin1");
-          } else {
-            socket.write(`${header}content-length: ${contentLength}\r
-\r
-`, "latin1");
-          }
-        }
-        if (contentLength === null) {
-          socket.write(`\r
-${len.toString(16)}\r
-`, "latin1");
-        }
-        this.bytesWritten += len;
-        const ret = socket.write(chunk);
-        socket.uncork();
-        request.onBodySent(chunk);
-        if (!ret) {
-          if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
-            if (socket[kParser].timeout.refresh) {
-              socket[kParser].timeout.refresh();
-            }
-          }
-        }
-        return ret;
-      }
-      end() {
-        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
-        request.onRequestSent();
-        socket[kWriting] = false;
-        if (socket[kError]) {
-          throw socket[kError];
-        }
-        if (socket.destroyed) {
-          return;
-        }
-        if (bytesWritten === 0) {
-          if (expectsPayload) {
-            socket.write(`${header}content-length: 0\r
-\r
-`, "latin1");
-          } else {
-            socket.write(`${header}\r
-`, "latin1");
-          }
-        } else if (contentLength === null) {
-          socket.write("\r\n0\r\n\r\n", "latin1");
-        }
-        if (contentLength !== null && bytesWritten !== contentLength) {
-          if (client[kStrictContentLength]) {
-            throw new RequestContentLengthMismatchError();
-          } else {
-            process.emitWarning(new RequestContentLengthMismatchError());
-          }
+          flipped = true;
+          f = twosComp(byte);
         }
-        if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
-          if (socket[kParser].timeout.refresh) {
-            socket[kParser].timeout.refresh();
-          }
+        if (f !== 0) {
+          sum -= f * Math.pow(256, len - i - 1);
         }
-        client[kResume]();
       }
-      destroy(err) {
-        const { socket, client, abort } = this;
-        socket[kWriting] = false;
-        if (err) {
-          assert5(client[kRunning] <= 1, "pipeline should only contain this request");
-          abort(err);
+      return sum;
+    };
+    pos = (buf) => {
+      var len = buf.length;
+      var sum = 0;
+      for (var i = len - 1; i > -1; i--) {
+        var byte = Number(buf[i]);
+        if (byte !== 0) {
+          sum += byte * Math.pow(256, len - i - 1);
         }
       }
+      return sum;
     };
-    module2.exports = connectH1;
+    onesComp = (byte) => (255 ^ byte) & 255;
+    twosComp = (byte) => (255 ^ byte) + 1 & 255;
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h2.js
-var require_client_h2 = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h2.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var { pipeline } = require("node:stream");
-    var util = require_util();
-    var {
-      RequestContentLengthMismatchError,
-      RequestAbortedError,
-      SocketError,
-      InformationalError
-    } = require_errors();
-    var {
-      kUrl,
-      kReset,
-      kClient,
-      kRunning,
-      kPending,
-      kQueue,
-      kPendingIdx,
-      kRunningIdx,
-      kError,
-      kSocket,
-      kStrictContentLength,
-      kOnError,
-      kMaxConcurrentStreams,
-      kHTTP2Session,
-      kResume,
-      kSize,
-      kHTTPContext
-    } = require_symbols();
-    var kOpenStreams = /* @__PURE__ */ Symbol("open streams");
-    var extractBody;
-    var h2ExperimentalWarned = false;
-    var http2;
-    try {
-      http2 = require("node:http2");
-    } catch {
-      http2 = { constants: {} };
-    }
-    var {
-      constants: {
-        HTTP2_HEADER_AUTHORITY,
-        HTTP2_HEADER_METHOD,
-        HTTP2_HEADER_PATH,
-        HTTP2_HEADER_SCHEME,
-        HTTP2_HEADER_CONTENT_LENGTH,
-        HTTP2_HEADER_EXPECT,
-        HTTP2_HEADER_STATUS
-      }
-    } = http2;
-    function parseH2Headers(headers) {
-      const result = [];
-      for (const [name2, value] of Object.entries(headers)) {
-        if (Array.isArray(value)) {
-          for (const subvalue of value) {
-            result.push(Buffer.from(name2), Buffer.from(subvalue));
-          }
-        } else {
-          result.push(Buffer.from(name2), Buffer.from(value));
-        }
-      }
-      return result;
-    }
-    async function connectH2(client, socket) {
-      client[kSocket] = socket;
-      if (!h2ExperimentalWarned) {
-        h2ExperimentalWarned = true;
-        process.emitWarning("H2 support is experimental, expect them to change at any time.", {
-          code: "UNDICI-H2"
-        });
-      }
-      const session = http2.connect(client[kUrl], {
-        createConnection: () => socket,
-        peerMaxConcurrentStreams: client[kMaxConcurrentStreams]
-      });
-      session[kOpenStreams] = 0;
-      session[kClient] = client;
-      session[kSocket] = socket;
-      util.addListener(session, "error", onHttp2SessionError);
-      util.addListener(session, "frameError", onHttp2FrameError);
-      util.addListener(session, "end", onHttp2SessionEnd);
-      util.addListener(session, "goaway", onHTTP2GoAway);
-      util.addListener(session, "close", function() {
-        const { [kClient]: client2 } = this;
-        const { [kSocket]: socket2 } = client2;
-        const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket2));
-        client2[kHTTP2Session] = null;
-        if (client2.destroyed) {
-          assert5(client2[kPending] === 0);
-          const requests = client2[kQueue].splice(client2[kRunningIdx]);
-          for (let i = 0; i < requests.length; i++) {
-            const request = requests[i];
-            util.errorRequest(client2, request, err);
-          }
-        }
-      });
-      session.unref();
-      client[kHTTP2Session] = session;
-      socket[kHTTP2Session] = session;
-      util.addListener(socket, "error", function(err) {
-        assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
-        this[kError] = err;
-        this[kClient][kOnError](err);
-      });
-      util.addListener(socket, "end", function() {
-        util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
-      });
-      util.addListener(socket, "close", function() {
-        const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
-        client[kSocket] = null;
-        if (this[kHTTP2Session] != null) {
-          this[kHTTP2Session].destroy(err);
-        }
-        client[kPendingIdx] = client[kRunningIdx];
-        assert5(client[kRunning] === 0);
-        client.emit("disconnect", client[kUrl], [client], err);
-        client[kResume]();
-      });
-      let closed = false;
-      socket.on("close", () => {
-        closed = true;
-      });
-      return {
-        version: "h2",
-        defaultPipelining: Infinity,
-        write(...args) {
-          return writeH2(client, ...args);
-        },
-        resume() {
-          resumeH2(client);
-        },
-        destroy(err, callback) {
-          if (closed) {
-            queueMicrotask(callback);
-          } else {
-            socket.destroy(err).on("close", callback);
-          }
-        },
-        get destroyed() {
-          return socket.destroyed;
-        },
-        busy() {
-          return false;
-        }
-      };
-    }
-    function resumeH2(client) {
-      const socket = client[kSocket];
-      if (socket?.destroyed === false) {
-        if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
-          socket.unref();
-          client[kHTTP2Session].unref();
-        } else {
-          socket.ref();
-          client[kHTTP2Session].ref();
-        }
-      }
-    }
-    function onHttp2SessionError(err) {
-      assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
-      this[kSocket][kError] = err;
-      this[kClient][kOnError](err);
-    }
-    function onHttp2FrameError(type, code2, id) {
-      if (id === 0) {
-        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code2}`);
-        this[kSocket][kError] = err;
-        this[kClient][kOnError](err);
-      }
-    }
-    function onHttp2SessionEnd() {
-      const err = new SocketError("other side closed", util.getSocketInfo(this[kSocket]));
-      this.destroy(err);
-      util.destroy(this[kSocket], err);
-    }
-    function onHTTP2GoAway(code2) {
-      const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code2}`, util.getSocketInfo(this));
-      const client = this[kClient];
-      client[kSocket] = null;
-      client[kHTTPContext] = null;
-      if (this[kHTTP2Session] != null) {
-        this[kHTTP2Session].destroy(err);
-        this[kHTTP2Session] = null;
-      }
-      util.destroy(this[kSocket], err);
-      if (client[kRunningIdx] < client[kQueue].length) {
-        const request = client[kQueue][client[kRunningIdx]];
-        client[kQueue][client[kRunningIdx]++] = null;
-        util.errorRequest(client, request, err);
-        client[kPendingIdx] = client[kRunningIdx];
-      }
-      assert5(client[kRunning] === 0);
-      client.emit("disconnect", client[kUrl], [client], err);
-      client[kResume]();
-    }
-    function shouldSendContentLength(method) {
-      return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
-    }
-    function writeH2(client, request) {
-      const session = client[kHTTP2Session];
-      const { method, path: path16, host, upgrade, expectContinue, signal, headers: reqHeaders } = request;
-      let { body } = request;
-      if (upgrade) {
-        util.errorRequest(client, request, new Error("Upgrade not supported for H2"));
-        return false;
-      }
-      const headers = {};
-      for (let n = 0; n < reqHeaders.length; n += 2) {
-        const key = reqHeaders[n + 0];
-        const val = reqHeaders[n + 1];
-        if (Array.isArray(val)) {
-          for (let i = 0; i < val.length; i++) {
-            if (headers[key]) {
-              headers[key] += `,${val[i]}`;
-            } else {
-              headers[key] = val[i];
-            }
-          }
-        } else {
-          headers[key] = val;
+// node_modules/tar/dist/esm/types.js
+var isCode, name, code;
+var init_types = __esm({
+  "node_modules/tar/dist/esm/types.js"() {
+    isCode = (c) => name.has(c);
+    name = /* @__PURE__ */ new Map([
+      ["0", "File"],
+      // same as File
+      ["", "OldFile"],
+      ["1", "Link"],
+      ["2", "SymbolicLink"],
+      // Devices and FIFOs aren't fully supported
+      // they are parsed, but skipped when unpacking
+      ["3", "CharacterDevice"],
+      ["4", "BlockDevice"],
+      ["5", "Directory"],
+      ["6", "FIFO"],
+      // same as File
+      ["7", "ContiguousFile"],
+      // pax headers
+      ["g", "GlobalExtendedHeader"],
+      ["x", "ExtendedHeader"],
+      // vendor-specific stuff
+      // skip
+      ["A", "SolarisACL"],
+      // like 5, but with data, which should be skipped
+      ["D", "GNUDumpDir"],
+      // metadata only, skip
+      ["I", "Inode"],
+      // data = link path of next file
+      ["K", "NextFileHasLongLinkpath"],
+      // data = path of next file
+      ["L", "NextFileHasLongPath"],
+      // skip
+      ["M", "ContinuationFile"],
+      // like L
+      ["N", "OldGnuLongPath"],
+      // skip
+      ["S", "SparseFile"],
+      // skip
+      ["V", "TapeVolumeHeader"],
+      // like x
+      ["X", "OldExtendedHeader"]
+    ]);
+    code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
+  }
+});
+
+// node_modules/tar/dist/esm/header.js
+var import_node_path, Header, splitPrefix, decString, decDate, numToDate, decNumber, nanUndef, decSmallNumber, MAXNUM, encNumber, encSmallNumber, octalString, padOctal, encDate, NULLS, encString;
+var init_header = __esm({
+  "node_modules/tar/dist/esm/header.js"() {
+    import_node_path = require("node:path");
+    init_large_numbers();
+    init_types();
+    Header = class {
+      cksumValid = false;
+      needPax = false;
+      nullBlock = false;
+      block;
+      path;
+      mode;
+      uid;
+      gid;
+      size;
+      cksum;
+      #type = "Unsupported";
+      linkpath;
+      uname;
+      gname;
+      devmaj = 0;
+      devmin = 0;
+      atime;
+      ctime;
+      mtime;
+      charset;
+      comment;
+      constructor(data, off = 0, ex, gex) {
+        if (Buffer.isBuffer(data)) {
+          this.decode(data, off || 0, ex, gex);
+        } else if (data) {
+          this.#slurp(data);
         }
       }
-      let stream;
-      const { hostname, port } = client[kUrl];
-      headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`;
-      headers[HTTP2_HEADER_METHOD] = method;
-      const abort = (err) => {
-        if (request.aborted || request.completed) {
-          return;
-        }
-        err = err || new RequestAbortedError();
-        util.errorRequest(client, request, err);
-        if (stream != null) {
-          util.destroy(stream, err);
+      decode(buf, off, ex, gex) {
+        if (!off) {
+          off = 0;
         }
-        util.destroy(body, err);
-        client[kQueue][client[kRunningIdx]++] = null;
-        client[kResume]();
-      };
-      try {
-        request.onConnect(abort);
-      } catch (err) {
-        util.errorRequest(client, request, err);
-      }
-      if (request.aborted) {
-        return false;
-      }
-      if (method === "CONNECT") {
-        session.ref();
-        stream = session.request(headers, { endStream: false, signal });
-        if (stream.id && !stream.pending) {
-          request.onUpgrade(null, null, stream);
-          ++session[kOpenStreams];
-          client[kQueue][client[kRunningIdx]++] = null;
-        } else {
-          stream.once("ready", () => {
-            request.onUpgrade(null, null, stream);
-            ++session[kOpenStreams];
-            client[kQueue][client[kRunningIdx]++] = null;
-          });
+        if (!buf || !(buf.length >= off + 512)) {
+          throw new Error("need 512 bytes for header");
         }
-        stream.once("close", () => {
-          session[kOpenStreams] -= 1;
-          if (session[kOpenStreams] === 0) session.unref();
-        });
-        return true;
-      }
-      headers[HTTP2_HEADER_PATH] = path16;
-      headers[HTTP2_HEADER_SCHEME] = "https";
-      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
-      if (body && typeof body.read === "function") {
-        body.read(0);
-      }
-      let contentLength = util.bodyLength(body);
-      if (util.isFormDataLike(body)) {
-        extractBody ??= require_body().extractBody;
-        const [bodyStream, contentType] = extractBody(body);
-        headers["content-type"] = contentType;
-        body = bodyStream.stream;
-        contentLength = bodyStream.length;
-      }
-      if (contentLength == null) {
-        contentLength = request.contentLength;
-      }
-      if (contentLength === 0 || !expectsPayload) {
-        contentLength = null;
-      }
-      if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
-        if (client[kStrictContentLength]) {
-          util.errorRequest(client, request, new RequestContentLengthMismatchError());
-          return false;
+        this.path = ex?.path ?? decString(buf, off, 100);
+        this.mode = ex?.mode ?? gex?.mode ?? decNumber(buf, off + 100, 8);
+        this.uid = ex?.uid ?? gex?.uid ?? decNumber(buf, off + 108, 8);
+        this.gid = ex?.gid ?? gex?.gid ?? decNumber(buf, off + 116, 8);
+        this.size = ex?.size ?? gex?.size ?? decNumber(buf, off + 124, 12);
+        this.mtime = ex?.mtime ?? gex?.mtime ?? decDate(buf, off + 136, 12);
+        this.cksum = decNumber(buf, off + 148, 12);
+        if (gex)
+          this.#slurp(gex, true);
+        if (ex)
+          this.#slurp(ex);
+        const t = decString(buf, off + 156, 1);
+        if (isCode(t)) {
+          this.#type = t || "0";
         }
-        process.emitWarning(new RequestContentLengthMismatchError());
-      }
-      if (contentLength != null) {
-        assert5(body, "no body must not have content length");
-        headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
-      }
-      session.ref();
-      const shouldEndStream = method === "GET" || method === "HEAD" || body === null;
-      if (expectContinue) {
-        headers[HTTP2_HEADER_EXPECT] = "100-continue";
-        stream = session.request(headers, { endStream: shouldEndStream, signal });
-        stream.once("continue", writeBodyH2);
-      } else {
-        stream = session.request(headers, {
-          endStream: shouldEndStream,
-          signal
-        });
-        writeBodyH2();
-      }
-      ++session[kOpenStreams];
-      stream.once("response", (headers2) => {
-        const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
-        request.onResponseStarted();
-        if (request.aborted) {
-          const err = new RequestAbortedError();
-          util.errorRequest(client, request, err);
-          util.destroy(stream, err);
-          return;
+        if (this.#type === "0" && this.path.slice(-1) === "/") {
+          this.#type = "5";
         }
-        if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
-          stream.pause();
+        if (this.#type === "5") {
+          this.size = 0;
         }
-        stream.on("data", (chunk) => {
-          if (request.onData(chunk) === false) {
-            stream.pause();
+        this.linkpath = decString(buf, off + 157, 100);
+        if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
+          this.uname = ex?.uname ?? gex?.uname ?? decString(buf, off + 265, 32);
+          this.gname = ex?.gname ?? gex?.gname ?? decString(buf, off + 297, 32);
+          this.devmaj = ex?.devmaj ?? gex?.devmaj ?? decNumber(buf, off + 329, 8) ?? 0;
+          this.devmin = ex?.devmin ?? gex?.devmin ?? decNumber(buf, off + 337, 8) ?? 0;
+          if (buf[off + 475] !== 0) {
+            const prefix = decString(buf, off + 345, 155);
+            this.path = prefix + "/" + this.path;
+          } else {
+            const prefix = decString(buf, off + 345, 130);
+            if (prefix) {
+              this.path = prefix + "/" + this.path;
+            }
+            this.atime = ex?.atime ?? gex?.atime ?? decDate(buf, off + 476, 12);
+            this.ctime = ex?.ctime ?? gex?.ctime ?? decDate(buf, off + 488, 12);
           }
-        });
-      });
-      stream.once("end", () => {
-        if (stream.state?.state == null || stream.state.state < 6) {
-          request.onComplete([]);
         }
-        if (session[kOpenStreams] === 0) {
-          session.unref();
+        let sum = 8 * 32;
+        for (let i = off; i < off + 148; i++) {
+          sum += buf[i];
         }
-        abort(new InformationalError("HTTP/2: stream half-closed (remote)"));
-        client[kQueue][client[kRunningIdx]++] = null;
-        client[kPendingIdx] = client[kRunningIdx];
-        client[kResume]();
-      });
-      stream.once("close", () => {
-        session[kOpenStreams] -= 1;
-        if (session[kOpenStreams] === 0) {
-          session.unref();
+        for (let i = off + 156; i < off + 512; i++) {
+          sum += buf[i];
         }
-      });
-      stream.once("error", function(err) {
-        abort(err);
-      });
-      stream.once("frameError", (type, code2) => {
-        abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code2}`));
-      });
-      return true;
-      function writeBodyH2() {
-        if (!body || contentLength === 0) {
-          writeBuffer(
-            abort,
-            stream,
-            null,
-            client,
-            request,
-            client[kSocket],
-            contentLength,
-            expectsPayload
-          );
-        } else if (util.isBuffer(body)) {
-          writeBuffer(
-            abort,
-            stream,
-            body,
-            client,
-            request,
-            client[kSocket],
-            contentLength,
-            expectsPayload
-          );
-        } else if (util.isBlobLike(body)) {
-          if (typeof body.stream === "function") {
-            writeIterable(
-              abort,
-              stream,
-              body.stream(),
-              client,
-              request,
-              client[kSocket],
-              contentLength,
-              expectsPayload
-            );
-          } else {
-            writeBlob(
-              abort,
-              stream,
-              body,
-              client,
-              request,
-              client[kSocket],
-              contentLength,
-              expectsPayload
-            );
-          }
-        } else if (util.isStream(body)) {
-          writeStream(
-            abort,
-            client[kSocket],
-            expectsPayload,
-            stream,
-            body,
-            client,
-            request,
-            contentLength
-          );
-        } else if (util.isIterable(body)) {
-          writeIterable(
-            abort,
-            stream,
-            body,
-            client,
-            request,
-            client[kSocket],
-            contentLength,
-            expectsPayload
-          );
-        } else {
-          assert5(false);
+        this.cksumValid = sum === this.cksum;
+        if (this.cksum === void 0 && sum === 8 * 32) {
+          this.nullBlock = true;
         }
       }
-    }
-    function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
-      try {
-        if (body != null && util.isBuffer(body)) {
-          assert5(contentLength === body.byteLength, "buffer body must have content length");
-          h2stream.cork();
-          h2stream.write(body);
-          h2stream.uncork();
-          h2stream.end();
-          request.onBodySent(body);
-        }
-        if (!expectsPayload) {
-          socket[kReset] = true;
-        }
-        request.onRequestSent();
-        client[kResume]();
-      } catch (error) {
-        abort(error);
+      #slurp(ex, gex = false) {
+        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+          return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
+        })));
       }
-    }
-    function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
-      assert5(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
-      const pipe = pipeline(
-        body,
-        h2stream,
-        (err) => {
-          if (err) {
-            util.destroy(pipe, err);
-            abort(err);
-          } else {
-            util.removeAllListeners(pipe);
-            request.onRequestSent();
-            if (!expectsPayload) {
-              socket[kReset] = true;
-            }
-            client[kResume]();
-          }
+      encode(buf, off = 0) {
+        if (!buf) {
+          buf = this.block = Buffer.alloc(512);
         }
-      );
-      util.addListener(pipe, "data", onPipeData);
-      function onPipeData(chunk) {
-        request.onBodySent(chunk);
-      }
-    }
-    async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
-      assert5(contentLength === body.size, "blob body must have content length");
-      try {
-        if (contentLength != null && contentLength !== body.size) {
-          throw new RequestContentLengthMismatchError();
-        }
-        const buffer = Buffer.from(await body.arrayBuffer());
-        h2stream.cork();
-        h2stream.write(buffer);
-        h2stream.uncork();
-        h2stream.end();
-        request.onBodySent(buffer);
-        request.onRequestSent();
-        if (!expectsPayload) {
-          socket[kReset] = true;
-        }
-        client[kResume]();
-      } catch (err) {
-        abort(err);
-      }
-    }
-    async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
-      assert5(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
-      let callback = null;
-      function onDrain() {
-        if (callback) {
-          const cb = callback;
-          callback = null;
-          cb();
+        if (this.#type === "Unsupported") {
+          this.#type = "0";
         }
-      }
-      const waitForDrain = () => new Promise((resolve, reject) => {
-        assert5(callback === null);
-        if (socket[kError]) {
-          reject(socket[kError]);
+        if (!(buf.length >= off + 512)) {
+          throw new Error("need 512 bytes for header");
+        }
+        const prefixSize = this.ctime || this.atime ? 130 : 155;
+        const split = splitPrefix(this.path || "", prefixSize);
+        const path16 = split[0];
+        const prefix = split[1];
+        this.needPax = !!split[2];
+        this.needPax = encString(buf, off, 100, path16) || this.needPax;
+        this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
+        this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
+        this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
+        this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
+        this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
+        buf[off + 156] = Number(this.#type.codePointAt(0));
+        this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
+        buf.write("ustar\x0000", off + 257, 8);
+        this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
+        this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
+        this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
+        this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
+        this.needPax = encString(buf, off + 345, prefixSize, prefix) || this.needPax;
+        if (buf[off + 475] !== 0) {
+          this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax;
         } else {
-          callback = resolve;
+          this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax;
+          this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
+          this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
         }
-      });
-      h2stream.on("close", onDrain).on("drain", onDrain);
-      try {
-        for await (const chunk of body) {
-          if (socket[kError]) {
-            throw socket[kError];
-          }
-          const res = h2stream.write(chunk);
-          request.onBodySent(chunk);
-          if (!res) {
-            await waitForDrain();
-          }
+        let sum = 8 * 32;
+        for (let i = off; i < off + 148; i++) {
+          sum += buf[i];
         }
-        h2stream.end();
-        request.onRequestSent();
-        if (!expectsPayload) {
-          socket[kReset] = true;
+        for (let i = off + 156; i < off + 512; i++) {
+          sum += buf[i];
         }
-        client[kResume]();
-      } catch (err) {
-        abort(err);
-      } finally {
-        h2stream.off("close", onDrain).off("drain", onDrain);
+        this.cksum = sum;
+        encNumber(buf, off + 148, 8, this.cksum);
+        this.cksumValid = true;
+        return this.needPax;
       }
-    }
-    module2.exports = connectH2;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/handler/redirect-handler.js
-var require_redirect_handler = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/handler/redirect-handler.js"(exports2, module2) {
-    "use strict";
-    var util = require_util();
-    var { kBodyUsed } = require_symbols();
-    var assert5 = require("node:assert");
-    var { InvalidArgumentError } = require_errors();
-    var EE3 = require("node:events");
-    var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
-    var kBody = /* @__PURE__ */ Symbol("body");
-    var BodyAsyncIterable = class {
-      constructor(body) {
-        this[kBody] = body;
-        this[kBodyUsed] = false;
-      }
-      async *[Symbol.asyncIterator]() {
-        assert5(!this[kBodyUsed], "disturbed");
-        this[kBodyUsed] = true;
-        yield* this[kBody];
-      }
-    };
-    var RedirectHandler = class {
-      constructor(dispatch, maxRedirections, opts, handler) {
-        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
-          throw new InvalidArgumentError("maxRedirections must be a positive number");
-        }
-        util.validateHandler(handler, opts.method, opts.upgrade);
-        this.dispatch = dispatch;
-        this.location = null;
-        this.abort = null;
-        this.opts = { ...opts, maxRedirections: 0 };
-        this.maxRedirections = maxRedirections;
-        this.handler = handler;
-        this.history = [];
-        this.redirectionLimitReached = false;
-        if (util.isStream(this.opts.body)) {
-          if (util.bodyLength(this.opts.body) === 0) {
-            this.opts.body.on("data", function() {
-              assert5(false);
-            });
-          }
-          if (typeof this.opts.body.readableDidRead !== "boolean") {
-            this.opts.body[kBodyUsed] = false;
-            EE3.prototype.on.call(this.opts.body, "data", function() {
-              this[kBodyUsed] = true;
-            });
-          }
-        } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
-          this.opts.body = new BodyAsyncIterable(this.opts.body);
-        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) {
-          this.opts.body = new BodyAsyncIterable(this.opts.body);
-        }
-      }
-      onConnect(abort) {
-        this.abort = abort;
-        this.handler.onConnect(abort, { history: this.history });
-      }
-      onUpgrade(statusCode, headers, socket) {
-        this.handler.onUpgrade(statusCode, headers, socket);
-      }
-      onError(error) {
-        this.handler.onError(error);
-      }
-      onHeaders(statusCode, headers, resume, statusText) {
-        this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
-        if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
-          if (this.request) {
-            this.request.abort(new Error("max redirects"));
-          }
-          this.redirectionLimitReached = true;
-          this.abort(new Error("max redirects"));
-          return;
-        }
-        if (this.opts.origin) {
-          this.history.push(new URL(this.opts.path, this.opts.origin));
-        }
-        if (!this.location) {
-          return this.handler.onHeaders(statusCode, headers, resume, statusText);
-        }
-        const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path16 = search ? `${pathname}${search}` : pathname;
-        this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path16;
-        this.opts.origin = origin;
-        this.opts.maxRedirections = 0;
-        this.opts.query = null;
-        if (statusCode === 303 && this.opts.method !== "HEAD") {
-          this.opts.method = "GET";
-          this.opts.body = null;
-        }
+      get type() {
+        return this.#type === "Unsupported" ? this.#type : name.get(this.#type);
       }
-      onData(chunk) {
-        if (this.location) {
-        } else {
-          return this.handler.onData(chunk);
-        }
+      get typeKey() {
+        return this.#type;
       }
-      onComplete(trailers) {
-        if (this.location) {
-          this.location = null;
-          this.abort = null;
-          this.dispatch(this.opts, this);
+      set type(type) {
+        const c = String(code.get(type));
+        if (isCode(c) || c === "Unsupported") {
+          this.#type = c;
+        } else if (isCode(type)) {
+          this.#type = type;
         } else {
-          this.handler.onComplete(trailers);
-        }
-      }
-      onBodySent(chunk) {
-        if (this.handler.onBodySent) {
-          this.handler.onBodySent(chunk);
+          throw new TypeError("invalid entry type: " + type);
         }
       }
     };
-    function parseLocation(statusCode, headers) {
-      if (redirectableStatusCodes.indexOf(statusCode) === -1) {
-        return null;
-      }
-      for (let i = 0; i < headers.length; i += 2) {
-        if (headers[i].length === 8 && util.headerNameToString(headers[i]) === "location") {
-          return headers[i + 1];
-        }
-      }
-    }
-    function shouldRemoveHeader(header, removeContent, unknownOrigin) {
-      if (header.length === 4) {
-        return util.headerNameToString(header) === "host";
-      }
-      if (removeContent && util.headerNameToString(header).startsWith("content-")) {
-        return true;
-      }
-      if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
-        const name2 = util.headerNameToString(header);
-        return name2 === "authorization" || name2 === "cookie" || name2 === "proxy-authorization";
-      }
-      return false;
-    }
-    function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
-      const ret = [];
-      if (Array.isArray(headers)) {
-        for (let i = 0; i < headers.length; i += 2) {
-          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
-            ret.push(headers[i], headers[i + 1]);
-          }
-        }
-      } else if (headers && typeof headers === "object") {
-        for (const key of Object.keys(headers)) {
-          if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
-            ret.push(key, headers[key]);
+    splitPrefix = (p, prefixSize) => {
+      const pathSize = 100;
+      let pp = p;
+      let prefix = "";
+      let ret = void 0;
+      const root = import_node_path.posix.parse(p).root || ".";
+      if (Buffer.byteLength(pp) < pathSize) {
+        ret = [pp, prefix, false];
+      } else {
+        prefix = import_node_path.posix.dirname(pp);
+        pp = import_node_path.posix.basename(pp);
+        do {
+          if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) {
+            ret = [pp, prefix, false];
+          } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) {
+            ret = [pp.slice(0, pathSize - 1), prefix, true];
+          } else {
+            pp = import_node_path.posix.join(import_node_path.posix.basename(prefix), pp);
+            prefix = import_node_path.posix.dirname(prefix);
           }
+        } while (prefix !== root && ret === void 0);
+        if (!ret) {
+          ret = [p.slice(0, pathSize - 1), "", true];
         }
-      } else {
-        assert5(headers == null, "headers must be an object or an array");
       }
       return ret;
-    }
-    module2.exports = RedirectHandler;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js
-var require_redirect_interceptor = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js"(exports2, module2) {
-    "use strict";
-    var RedirectHandler = require_redirect_handler();
-    function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
-      return (dispatch) => {
-        return function Intercept(opts, handler) {
-          const { maxRedirections = defaultMaxRedirections } = opts;
-          if (!maxRedirections) {
-            return dispatch(opts, handler);
-          }
-          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler);
-          opts = { ...opts, maxRedirections: 0 };
-          return dispatch(opts, redirectHandler);
-        };
-      };
-    }
-    module2.exports = createRedirectInterceptor;
+    };
+    decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
+    decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
+    numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3);
+    decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
+    nanUndef = (value) => isNaN(value) ? void 0 : value;
+    decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
+    MAXNUM = {
+      12: 8589934591,
+      8: 2097151
+    };
+    encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
+    encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
+    octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
+    padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
+    encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
+    NULLS = new Array(156).join("\0");
+    encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client.js
-var require_client = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client.js"(exports2, module2) {
-    "use strict";
-    var assert5 = require("node:assert");
-    var net = require("node:net");
-    var http = require("node:http");
-    var util = require_util();
-    var { channels } = require_diagnostics();
-    var Request = require_request();
-    var DispatcherBase = require_dispatcher_base();
-    var {
-      InvalidArgumentError,
-      InformationalError,
-      ClientDestroyedError
-    } = require_errors();
-    var buildConnector = require_connect();
-    var {
-      kUrl,
-      kServerName,
-      kClient,
-      kBusy,
-      kConnect,
-      kResuming,
-      kRunning,
-      kPending,
-      kSize,
-      kQueue,
-      kConnected,
-      kConnecting,
-      kNeedDrain,
-      kKeepAliveDefaultTimeout,
-      kHostHeader,
-      kPendingIdx,
-      kRunningIdx,
-      kError,
-      kPipelining,
-      kKeepAliveTimeoutValue,
-      kMaxHeadersSize,
-      kKeepAliveMaxTimeout,
-      kKeepAliveTimeoutThreshold,
-      kHeadersTimeout,
-      kBodyTimeout,
-      kStrictContentLength,
-      kConnector,
-      kMaxRedirections,
-      kMaxRequests,
-      kCounter,
-      kClose,
-      kDestroy,
-      kDispatch,
-      kInterceptors,
-      kLocalAddress,
-      kMaxResponseSize,
-      kOnError,
-      kHTTPContext,
-      kMaxConcurrentStreams,
-      kResume
-    } = require_symbols();
-    var connectH1 = require_client_h1();
-    var connectH2 = require_client_h2();
-    var deprecatedInterceptorWarned = false;
-    var kClosedResolve = /* @__PURE__ */ Symbol("kClosedResolve");
-    var noop3 = () => {
-    };
-    function getPipelining(client) {
-      return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
-    }
-    var Client = class extends DispatcherBase {
-      /**
-       *
-       * @param {string|URL} url
-       * @param {import('../../types/client.js').Client.Options} options
-       */
-      constructor(url, {
-        interceptors,
-        maxHeaderSize,
-        headersTimeout,
-        socketTimeout,
-        requestTimeout,
-        connectTimeout,
-        bodyTimeout,
-        idleTimeout,
-        keepAlive,
-        keepAliveTimeout,
-        maxKeepAliveTimeout,
-        keepAliveMaxTimeout,
-        keepAliveTimeoutThreshold,
-        socketPath,
-        pipelining,
-        tls,
-        strictContentLength,
-        maxCachedSessions,
-        maxRedirections,
-        connect: connect2,
-        maxRequestsPerClient,
-        localAddress,
-        maxResponseSize,
-        autoSelectFamily,
-        autoSelectFamilyAttemptTimeout,
-        // h2
-        maxConcurrentStreams,
-        allowH2,
-        webSocket
-      } = {}) {
-        super({ webSocket });
-        if (keepAlive !== void 0) {
-          throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
-        }
-        if (socketTimeout !== void 0) {
-          throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
-        }
-        if (requestTimeout !== void 0) {
-          throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
-        }
-        if (idleTimeout !== void 0) {
-          throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
-        }
-        if (maxKeepAliveTimeout !== void 0) {
-          throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
-        }
-        if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
-          throw new InvalidArgumentError("invalid maxHeaderSize");
-        }
-        if (socketPath != null && typeof socketPath !== "string") {
-          throw new InvalidArgumentError("invalid socketPath");
-        }
-        if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
-          throw new InvalidArgumentError("invalid connectTimeout");
-        }
-        if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
-          throw new InvalidArgumentError("invalid keepAliveTimeout");
-        }
-        if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
-          throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
-        }
-        if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
-          throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
-        }
-        if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
-          throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
-        }
-        if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
-          throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
-        }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
-          throw new InvalidArgumentError("connect must be a function or an object");
-        }
-        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
-          throw new InvalidArgumentError("maxRedirections must be a positive number");
-        }
-        if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
-          throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
-        }
-        if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) {
-          throw new InvalidArgumentError("localAddress must be valid string IP address");
-        }
-        if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
-          throw new InvalidArgumentError("maxResponseSize must be a positive number");
-        }
-        if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
-          throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
-        }
-        if (allowH2 != null && typeof allowH2 !== "boolean") {
-          throw new InvalidArgumentError("allowH2 must be a valid boolean value");
-        }
-        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
-          throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0");
-        }
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
-            ...tls,
-            maxCachedSessions,
-            allowH2,
-            socketPath,
-            timeout: connectTimeout,
-            ...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
-          });
-        }
-        if (interceptors?.Client && Array.isArray(interceptors.Client)) {
-          this[kInterceptors] = interceptors.Client;
-          if (!deprecatedInterceptorWarned) {
-            deprecatedInterceptorWarned = true;
-            process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.", {
-              code: "UNDICI-CLIENT-INTERCEPTOR-DEPRECATED"
-            });
-          }
-        } else {
-          this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })];
-        }
-        this[kUrl] = util.parseOrigin(url);
-        this[kConnector] = connect2;
-        this[kPipelining] = pipelining != null ? pipelining : 1;
-        this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
-        this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
-        this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
-        this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold;
-        this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
-        this[kServerName] = null;
-        this[kLocalAddress] = localAddress != null ? localAddress : null;
-        this[kResuming] = 0;
-        this[kNeedDrain] = 0;
-        this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
-`;
-        this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
-        this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
-        this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
-        this[kMaxRedirections] = maxRedirections;
-        this[kMaxRequests] = maxRequestsPerClient;
-        this[kClosedResolve] = null;
-        this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
-        this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100;
-        this[kHTTPContext] = null;
-        this[kQueue] = [];
-        this[kRunningIdx] = 0;
-        this[kPendingIdx] = 0;
-        this[kResume] = (sync) => resume(this, sync);
-        this[kOnError] = (err) => onError(this, err);
-      }
-      get pipelining() {
-        return this[kPipelining];
-      }
-      set pipelining(value) {
-        this[kPipelining] = value;
-        this[kResume](true);
-      }
-      get [kPending]() {
-        return this[kQueue].length - this[kPendingIdx];
-      }
-      get [kRunning]() {
-        return this[kPendingIdx] - this[kRunningIdx];
-      }
-      get [kSize]() {
-        return this[kQueue].length - this[kRunningIdx];
-      }
-      get [kConnected]() {
-        return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed;
-      }
-      get [kBusy]() {
-        return Boolean(
-          this[kHTTPContext]?.busy(null) || this[kSize] >= (getPipelining(this) || 1) || this[kPending] > 0
-        );
+// node_modules/tar/dist/esm/pax.js
+var import_node_path2, Pax, merge, parseKV, parseKVLine;
+var init_pax = __esm({
+  "node_modules/tar/dist/esm/pax.js"() {
+    import_node_path2 = require("node:path");
+    init_header();
+    Pax = class _Pax {
+      atime;
+      mtime;
+      ctime;
+      charset;
+      comment;
+      gid;
+      uid;
+      gname;
+      uname;
+      linkpath;
+      dev;
+      ino;
+      nlink;
+      path;
+      size;
+      mode;
+      global;
+      constructor(obj, global2 = false) {
+        this.atime = obj.atime;
+        this.charset = obj.charset;
+        this.comment = obj.comment;
+        this.ctime = obj.ctime;
+        this.dev = obj.dev;
+        this.gid = obj.gid;
+        this.global = global2;
+        this.gname = obj.gname;
+        this.ino = obj.ino;
+        this.linkpath = obj.linkpath;
+        this.mtime = obj.mtime;
+        this.nlink = obj.nlink;
+        this.path = obj.path;
+        this.size = obj.size;
+        this.uid = obj.uid;
+        this.uname = obj.uname;
       }
-      /* istanbul ignore: only used for test */
-      [kConnect](cb) {
-        connect(this);
-        this.once("connect", cb);
-      }
-      [kDispatch](opts, handler) {
-        const origin = opts.origin || this[kUrl].origin;
-        const request = new Request(origin, opts, handler);
-        this[kQueue].push(request);
-        if (this[kResuming]) {
-        } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
-          this[kResuming] = 1;
-          queueMicrotask(() => resume(this));
-        } else {
-          this[kResume](true);
+      encode() {
+        const body = this.encodeBody();
+        if (body === "") {
+          return Buffer.allocUnsafe(0);
         }
-        if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
-          this[kNeedDrain] = 2;
+        const bodyLen = Buffer.byteLength(body);
+        const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
+        const buf = Buffer.allocUnsafe(bufLen);
+        for (let i = 0; i < 512; i++) {
+          buf[i] = 0;
         }
-        return this[kNeedDrain] < 2;
-      }
-      async [kClose]() {
-        return new Promise((resolve) => {
-          if (this[kSize]) {
-            this[kClosedResolve] = resolve;
-          } else {
-            resolve(null);
-          }
-        });
-      }
-      async [kDestroy](err) {
-        return new Promise((resolve) => {
-          const requests = this[kQueue].splice(this[kPendingIdx]);
-          for (let i = 0; i < requests.length; i++) {
-            const request = requests[i];
-            util.errorRequest(this, request, err);
-          }
-          const callback = () => {
-            if (this[kClosedResolve]) {
-              this[kClosedResolve]();
-              this[kClosedResolve] = null;
-            }
-            resolve(null);
-          };
-          if (this[kHTTPContext]) {
-            this[kHTTPContext].destroy(err, callback);
-            this[kHTTPContext] = null;
-          } else {
-            queueMicrotask(callback);
-          }
-          this[kResume]();
-        });
-      }
-    };
-    var createRedirectInterceptor = require_redirect_interceptor();
-    function onError(client, err) {
-      if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
-        assert5(client[kPendingIdx] === client[kRunningIdx]);
-        const requests = client[kQueue].splice(client[kRunningIdx]);
-        for (let i = 0; i < requests.length; i++) {
-          const request = requests[i];
-          util.errorRequest(client, request, err);
+        new Header({
+          // XXX split the path
+          // then the path should be PaxHeader + basename, but less than 99,
+          // prepend with the dirname
+          /* c8 ignore start */
+          path: ("PaxHeader/" + (0, import_node_path2.basename)(this.path ?? "")).slice(0, 99),
+          /* c8 ignore stop */
+          mode: this.mode || 420,
+          uid: this.uid,
+          gid: this.gid,
+          size: bodyLen,
+          mtime: this.mtime,
+          type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
+          linkpath: "",
+          uname: this.uname || "",
+          gname: this.gname || "",
+          devmaj: 0,
+          devmin: 0,
+          atime: this.atime,
+          ctime: this.ctime
+        }).encode(buf);
+        buf.write(body, 512, bodyLen, "utf8");
+        for (let i = bodyLen + 512; i < buf.length; i++) {
+          buf[i] = 0;
         }
-        assert5(client[kSize] === 0);
+        return buf;
       }
-    }
-    async function connect(client) {
-      assert5(!client[kConnecting]);
-      assert5(!client[kHTTPContext]);
-      let { host, hostname, protocol, port } = client[kUrl];
-      if (hostname[0] === "[") {
-        const idx = hostname.indexOf("]");
-        assert5(idx !== -1);
-        const ip = hostname.substring(1, idx);
-        assert5(net.isIP(ip));
-        hostname = ip;
-      }
-      client[kConnecting] = true;
-      if (channels.beforeConnect.hasSubscribers) {
-        channels.beforeConnect.publish({
-          connectParams: {
-            host,
-            hostname,
-            protocol,
-            port,
-            version: client[kHTTPContext]?.version,
-            servername: client[kServerName],
-            localAddress: client[kLocalAddress]
-          },
-          connector: client[kConnector]
-        });
+      encodeBody() {
+        return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
       }
-      try {
-        const socket = await new Promise((resolve, reject) => {
-          client[kConnector]({
-            host,
-            hostname,
-            protocol,
-            port,
-            servername: client[kServerName],
-            localAddress: client[kLocalAddress]
-          }, (err, socket2) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(socket2);
-            }
-          });
-        });
-        if (client.destroyed) {
-          util.destroy(socket.on("error", noop3), new ClientDestroyedError());
-          return;
-        }
-        assert5(socket);
-        try {
-          client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket);
-        } catch (err) {
-          socket.destroy().on("error", noop3);
-          throw err;
-        }
-        client[kConnecting] = false;
-        socket[kCounter] = 0;
-        socket[kMaxRequests] = client[kMaxRequests];
-        socket[kClient] = client;
-        socket[kError] = null;
-        if (channels.connected.hasSubscribers) {
-          channels.connected.publish({
-            connectParams: {
-              host,
-              hostname,
-              protocol,
-              port,
-              version: client[kHTTPContext]?.version,
-              servername: client[kServerName],
-              localAddress: client[kLocalAddress]
-            },
-            connector: client[kConnector],
-            socket
-          });
-        }
-        client.emit("connect", client[kUrl], [client]);
-      } catch (err) {
-        if (client.destroyed) {
-          return;
-        }
-        client[kConnecting] = false;
-        if (channels.connectError.hasSubscribers) {
-          channels.connectError.publish({
-            connectParams: {
-              host,
-              hostname,
-              protocol,
-              port,
-              version: client[kHTTPContext]?.version,
-              servername: client[kServerName],
-              localAddress: client[kLocalAddress]
-            },
-            connector: client[kConnector],
-            error: err
-          });
+      encodeField(field) {
+        if (this[field] === void 0) {
+          return "";
         }
-        if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
-          assert5(client[kRunning] === 0);
-          while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
-            const request = client[kQueue][client[kPendingIdx]++];
-            util.errorRequest(client, request, err);
-          }
-        } else {
-          onError(client, err);
+        const r = this[field];
+        const v = r instanceof Date ? r.getTime() / 1e3 : r;
+        const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
+        const byteLen = Buffer.byteLength(s);
+        let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
+        if (byteLen + digits >= Math.pow(10, digits)) {
+          digits += 1;
         }
-        client.emit("connectionError", client[kUrl], [client], err);
+        const len = digits + byteLen;
+        return len + s;
       }
-      client[kResume]();
-    }
-    function emitDrain(client) {
-      client[kNeedDrain] = 0;
-      client.emit("drain", client[kUrl], [client]);
-    }
-    function resume(client, sync) {
-      if (client[kResuming] === 2) {
-        return;
+      static parse(str, ex, g = false) {
+        return new _Pax(merge(parseKV(str), ex), g);
       }
-      client[kResuming] = 2;
-      _resume(client, sync);
-      client[kResuming] = 0;
-      if (client[kRunningIdx] > 256) {
-        client[kQueue].splice(0, client[kRunningIdx]);
-        client[kPendingIdx] -= client[kRunningIdx];
-        client[kRunningIdx] = 0;
+    };
+    merge = (a, b) => b ? Object.assign({}, b, a) : a;
+    parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
+    parseKVLine = (set, line) => {
+      const n = parseInt(line, 10);
+      if (n !== Buffer.byteLength(line) + 1) {
+        return set;
       }
-    }
-    function _resume(client, sync) {
-      while (true) {
-        if (client.destroyed) {
-          assert5(client[kPending] === 0);
-          return;
-        }
-        if (client[kClosedResolve] && !client[kSize]) {
-          client[kClosedResolve]();
-          client[kClosedResolve] = null;
-          return;
-        }
-        if (client[kHTTPContext]) {
-          client[kHTTPContext].resume();
-        }
-        if (client[kBusy]) {
-          client[kNeedDrain] = 2;
-        } else if (client[kNeedDrain] === 2) {
-          if (sync) {
-            client[kNeedDrain] = 1;
-            queueMicrotask(() => emitDrain(client));
-          } else {
-            emitDrain(client);
-          }
-          continue;
-        }
-        if (client[kPending] === 0) {
-          return;
-        }
-        if (client[kRunning] >= (getPipelining(client) || 1)) {
-          return;
-        }
-        const request = client[kQueue][client[kPendingIdx]];
-        if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
-          if (client[kRunning] > 0) {
-            return;
-          }
-          client[kServerName] = request.servername;
-          client[kHTTPContext]?.destroy(new InformationalError("servername changed"), () => {
-            client[kHTTPContext] = null;
-            resume(client);
-          });
-        }
-        if (client[kConnecting]) {
-          return;
-        }
-        if (!client[kHTTPContext]) {
-          connect(client);
-          return;
-        }
-        if (client[kHTTPContext].destroyed) {
-          return;
-        }
-        if (client[kHTTPContext].busy(request)) {
-          return;
-        }
-        if (!request.aborted && client[kHTTPContext].write(request)) {
-          client[kPendingIdx]++;
-        } else {
-          client[kQueue].splice(client[kPendingIdx], 1);
-        }
+      line = line.slice((n + " ").length);
+      const kv = line.split("=");
+      const r = kv.shift();
+      if (!r) {
+        return set;
       }
-    }
-    module2.exports = Client;
+      const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
+      const v = kv.join("=");
+      set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
+      return set;
+    };
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool.js
-var require_pool = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool.js"(exports2, module2) {
-    "use strict";
-    var {
-      PoolBase,
-      kClients,
-      kNeedDrain,
-      kAddClient,
-      kGetDispatcher
-    } = require_pool_base();
-    var Client = require_client();
-    var {
-      InvalidArgumentError
-    } = require_errors();
-    var util = require_util();
-    var { kUrl, kInterceptors } = require_symbols();
-    var buildConnector = require_connect();
-    var kOptions = /* @__PURE__ */ Symbol("options");
-    var kConnections = /* @__PURE__ */ Symbol("connections");
-    var kFactory = /* @__PURE__ */ Symbol("factory");
-    function defaultFactory(origin, opts) {
-      return new Client(origin, opts);
-    }
-    var Pool = class extends PoolBase {
-      constructor(origin, {
-        connections,
-        factory = defaultFactory,
-        connect,
-        connectTimeout,
-        tls,
-        maxCachedSessions,
-        socketPath,
-        autoSelectFamily,
-        autoSelectFamilyAttemptTimeout,
-        allowH2,
-        ...options
-      } = {}) {
-        if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
-          throw new InvalidArgumentError("invalid connections");
-        }
-        if (typeof factory !== "function") {
-          throw new InvalidArgumentError("factory must be a function.");
-        }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
-          throw new InvalidArgumentError("connect must be a function or an object");
-        }
-        if (typeof connect !== "function") {
-          connect = buildConnector({
-            ...tls,
-            maxCachedSessions,
-            allowH2,
-            socketPath,
-            timeout: connectTimeout,
-            ...autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect
-          });
-        }
-        super(options);
-        this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : [];
-        this[kConnections] = connections || null;
-        this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect, allowH2 };
-        this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
-        this[kFactory] = factory;
-        this.on("connectionError", (origin2, targets, error) => {
-          for (const target of targets) {
-            const idx = this[kClients].indexOf(target);
-            if (idx !== -1) {
-              this[kClients].splice(idx, 1);
-            }
-          }
-        });
-      }
-      [kGetDispatcher]() {
-        for (const client of this[kClients]) {
-          if (!client[kNeedDrain]) {
-            return client;
-          }
-        }
-        if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-          const dispatcher = this[kFactory](this[kUrl], this[kOptions]);
-          this[kAddClient](dispatcher);
-          return dispatcher;
-        }
-      }
-    };
-    module2.exports = Pool;
+// node_modules/tar/dist/esm/normalize-windows-path.js
+var platform, normalizeWindowsPath;
+var init_normalize_windows_path = __esm({
+  "node_modules/tar/dist/esm/normalize-windows-path.js"() {
+    platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+    normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.replaceAll(/\\/g, "/");
   }
 });
 
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/agent.js
-var require_agent = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/agent.js"(exports2, module2) {
-    "use strict";
-    var { InvalidArgumentError } = require_errors();
-    var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
-    var DispatcherBase = require_dispatcher_base();
-    var Pool = require_pool();
-    var Client = require_client();
-    var util = require_util();
-    var createRedirectInterceptor = require_redirect_interceptor();
-    var kOnConnect = /* @__PURE__ */ Symbol("onConnect");
-    var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect");
-    var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError");
-    var kMaxRedirections = /* @__PURE__ */ Symbol("maxRedirections");
-    var kOnDrain = /* @__PURE__ */ Symbol("onDrain");
-    var kFactory = /* @__PURE__ */ Symbol("factory");
-    var kOptions = /* @__PURE__ */ Symbol("options");
-    function defaultFactory(origin, opts) {
-      return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
-    }
-    var Agent = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
-        if (typeof factory !== "function") {
-          throw new InvalidArgumentError("factory must be a function.");
-        }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
-          throw new InvalidArgumentError("connect must be a function or an object");
-        }
-        if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
-          throw new InvalidArgumentError("maxRedirections must be a positive number");
-        }
-        super(options);
-        if (connect && typeof connect !== "function") {
-          connect = { ...connect };
-        }
-        this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
-        this[kOptions] = { ...util.deepClone(options), connect };
-        this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
-        this[kMaxRedirections] = maxRedirections;
-        this[kFactory] = factory;
-        this[kClients] = /* @__PURE__ */ new Map();
-        this[kOnDrain] = (origin, targets) => {
-          this.emit("drain", origin, [this, ...targets]);
-        };
-        this[kOnConnect] = (origin, targets) => {
-          this.emit("connect", origin, [this, ...targets]);
-        };
-        this[kOnDisconnect] = (origin, targets, err) => {
-          this.emit("disconnect", origin, [this, ...targets], err);
-        };
-        this[kOnConnectionError] = (origin, targets, err) => {
-          this.emit("connectionError", origin, [this, ...targets], err);
-        };
-      }
-      get [kRunning]() {
-        let ret = 0;
-        for (const client of this[kClients].values()) {
-          ret += client[kRunning];
+// node_modules/tar/dist/esm/read-entry.js
+var ReadEntry;
+var init_read_entry = __esm({
+  "node_modules/tar/dist/esm/read-entry.js"() {
+    init_esm();
+    init_normalize_windows_path();
+    ReadEntry = class extends Minipass {
+      extended;
+      globalExtended;
+      header;
+      startBlockSize;
+      blockRemain;
+      remain;
+      type;
+      meta = false;
+      ignore = false;
+      path;
+      mode;
+      uid;
+      gid;
+      uname;
+      gname;
+      size = 0;
+      mtime;
+      atime;
+      ctime;
+      linkpath;
+      dev;
+      ino;
+      nlink;
+      invalid = false;
+      absolute;
+      unsupported = false;
+      constructor(header, ex, gex) {
+        super({});
+        this.pause();
+        this.extended = ex;
+        this.globalExtended = gex;
+        this.header = header;
+        this.remain = header.size ?? 0;
+        this.startBlockSize = 512 * Math.ceil(this.remain / 512);
+        this.blockRemain = this.startBlockSize;
+        this.type = header.type;
+        switch (this.type) {
+          case "File":
+          case "OldFile":
+          case "Link":
+          case "SymbolicLink":
+          case "CharacterDevice":
+          case "BlockDevice":
+          case "Directory":
+          case "FIFO":
+          case "ContiguousFile":
+          case "GNUDumpDir":
+            break;
+          case "NextFileHasLongLinkpath":
+          case "NextFileHasLongPath":
+          case "OldGnuLongPath":
+          case "GlobalExtendedHeader":
+          case "ExtendedHeader":
+          case "OldExtendedHeader":
+            this.meta = true;
+            break;
+          // NOTE: gnutar and bsdtar treat unrecognized types as 'File'
+          // it may be worth doing the same, but with a warning.
+          default:
+            this.ignore = true;
         }
-        return ret;
-      }
-      [kDispatch](opts, handler) {
-        let key;
-        if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
-          key = String(opts.origin);
-        } else {
-          throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
+        if (!header.path) {
+          throw new Error("no path provided for tar.ReadEntry");
         }
-        let dispatcher = this[kClients].get(key);
-        if (!dispatcher) {
-          dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
-          this[kClients].set(key, dispatcher);
+        this.path = normalizeWindowsPath(header.path);
+        this.mode = header.mode;
+        if (this.mode) {
+          this.mode = this.mode & 4095;
         }
-        return dispatcher.dispatch(opts, handler);
-      }
-      async [kClose]() {
-        const closePromises = [];
-        for (const client of this[kClients].values()) {
-          closePromises.push(client.close());
+        this.uid = header.uid;
+        this.gid = header.gid;
+        this.uname = header.uname;
+        this.gname = header.gname;
+        this.size = this.remain;
+        this.mtime = header.mtime;
+        this.atime = header.atime;
+        this.ctime = header.ctime;
+        this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0;
+        this.uname = header.uname;
+        this.gname = header.gname;
+        if (ex) {
+          this.#slurp(ex);
         }
-        this[kClients].clear();
-        await Promise.all(closePromises);
-      }
-      async [kDestroy](err) {
-        const destroyPromises = [];
-        for (const client of this[kClients].values()) {
-          destroyPromises.push(client.destroy(err));
+        if (gex) {
+          this.#slurp(gex, true);
         }
-        this[kClients].clear();
-        await Promise.all(destroyPromises);
-      }
-    };
-    module2.exports = Agent;
-  }
-});
-
-// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/proxy-agent.js
-var require_proxy_agent = __commonJS({
-  ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/proxy-agent.js"(exports2, module2) {
-    "use strict";
-    var { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
-    var { URL: URL2 } = require("node:url");
-    var Agent = require_agent();
-    var Pool = require_pool();
-    var DispatcherBase = require_dispatcher_base();
-    var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors();
-    var buildConnector = require_connect();
-    var Client = require_client();
-    var kAgent = /* @__PURE__ */ Symbol("proxy agent");
-    var kClient = /* @__PURE__ */ Symbol("proxy client");
-    var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers");
-    var kRequestTls = /* @__PURE__ */ Symbol("request tls settings");
-    var kProxyTls = /* @__PURE__ */ Symbol("proxy tls settings");
-    var kConnectEndpoint = /* @__PURE__ */ Symbol("connect endpoint function");
-    var kTunnelProxy = /* @__PURE__ */ Symbol("tunnel proxy");
-    function defaultProtocolPort(protocol) {
-      return protocol === "https:" ? 443 : 80;
-    }
-    function defaultFactory(origin, opts) {
-      return new Pool(origin, opts);
-    }
-    var noop3 = () => {
-    };
-    function defaultAgentFactory(origin, opts) {
-      if (opts.connections === 1) {
-        return new Client(origin, opts);
       }
-      return new Pool(origin, opts);
-    }
-    var Http1ProxyWrapper = class extends DispatcherBase {
-      #client;
-      constructor(proxyUrl, { headers = {}, connect, factory }) {
-        super();
-        if (!proxyUrl) {
-          throw new InvalidArgumentError("Proxy URL is mandatory");
+      write(data) {
+        const writeLen = data.length;
+        if (writeLen > this.blockRemain) {
+          throw new Error("writing more to entry than is appropriate");
         }
-        this[kProxyHeaders] = headers;
-        if (factory) {
-          this.#client = factory(proxyUrl, { connect });
-        } else {
-          this.#client = new Client(proxyUrl, { connect });
+        const r = this.remain;
+        const br = this.blockRemain;
+        this.remain = Math.max(0, r - writeLen);
+        this.blockRemain = Math.max(0, br - writeLen);
+        if (this.ignore) {
+          return true;
         }
-      }
-      [kDispatch](opts, handler) {
-        const onHeaders = handler.onHeaders;
-        handler.onHeaders = function(statusCode, data, resume) {
-          if (statusCode === 407) {
-            if (typeof handler.onError === "function") {
-              handler.onError(new InvalidArgumentError("Proxy Authentication Required (407)"));
-            }
-            return;
-          }
-          if (onHeaders) onHeaders.call(this, statusCode, data, resume);
-        };
-        const {
-          origin,
-          path: path16 = "/",
-          headers = {}
-        } = opts;
-        opts.path = origin + path16;
-        if (!("host" in headers) && !("Host" in headers)) {
-          const { host } = new URL2(origin);
-          headers.host = host;
+        if (r >= writeLen) {
+          return super.write(data);
         }
-        opts.headers = { ...this[kProxyHeaders], ...headers };
-        return this.#client[kDispatch](opts, handler);
-      }
-      async [kClose]() {
-        return this.#client.close();
+        return super.write(data.subarray(0, r));
       }
-      async [kDestroy](err) {
-        return this.#client.destroy(err);
+      #slurp(ex, gex = false) {
+        if (ex.path)
+          ex.path = normalizeWindowsPath(ex.path);
+        if (ex.linkpath)
+          ex.linkpath = normalizeWindowsPath(ex.linkpath);
+        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
+          return !(v === null || v === void 0 || k === "path" && gex);
+        })));
       }
     };
-    var ProxyAgent2 = class extends DispatcherBase {
-      constructor(opts) {
-        super();
-        if (!opts || typeof opts === "object" && !(opts instanceof URL2) && !opts.uri) {
-          throw new InvalidArgumentError("Proxy uri is mandatory");
-        }
-        const { clientFactory = defaultFactory } = opts;
-        if (typeof clientFactory !== "function") {
-          throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
-        }
-        const { proxyTunnel = true } = opts;
-        const url = this.#getUrl(opts);
-        const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url;
-        this[kProxy] = { uri: href, protocol };
-        this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
-        this[kRequestTls] = opts.requestTls;
-        this[kProxyTls] = opts.proxyTls;
-        this[kProxyHeaders] = opts.headers || {};
-        this[kTunnelProxy] = proxyTunnel;
-        if (opts.auth && opts.token) {
-          throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
-        } else if (opts.auth) {
-          this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
-        } else if (opts.token) {
-          this[kProxyHeaders]["proxy-authorization"] = opts.token;
-        } else if (username && password) {
-          this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
-        }
-        const connect = buildConnector({ ...opts.proxyTls });
-        this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
-        const agentFactory = opts.factory || defaultAgentFactory;
-        const factory = (origin2, options) => {
-          const { protocol: protocol2 } = new URL2(origin2);
-          if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
-            return new Http1ProxyWrapper(this[kProxy].uri, {
-              headers: this[kProxyHeaders],
-              connect,
-              factory: agentFactory
-            });
-          }
-          return agentFactory(origin2, options);
-        };
-        this[kClient] = clientFactory(url, { connect });
-        this[kAgent] = new Agent({
-          ...opts,
-          factory,
-          connect: async (opts2, callback) => {
-            let requestedPath = opts2.host;
-            if (!opts2.port) {
-              requestedPath += `:${defaultProtocolPort(opts2.protocol)}`;
-            }
-            try {
-              const { socket, statusCode } = await this[kClient].connect({
-                origin,
-                port,
-                path: requestedPath,
-                signal: opts2.signal,
-                headers: {
-                  ...this[kProxyHeaders],
-                  host: opts2.host
-                },
-                servername: this[kProxyTls]?.servername || proxyHostname
-              });
-              if (statusCode !== 200) {
-                socket.on("error", noop3).destroy();
-                callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
-              }
-              if (opts2.protocol !== "https:") {
-                callback(null, socket);
-                return;
-              }
-              let servername;
-              if (this[kRequestTls]) {
-                servername = this[kRequestTls].servername;
-              } else {
-                servername = opts2.servername;
-              }
-              this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
-            } catch (err) {
-              if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
-                callback(new SecureProxyConnectionError(err));
-              } else {
-                callback(err);
-              }
-            }
-          }
-        });
+  }
+});
+
+// node_modules/tar/dist/esm/warn-method.js
+var warnMethod;
+var init_warn_method = __esm({
+  "node_modules/tar/dist/esm/warn-method.js"() {
+    warnMethod = (self2, code2, message, data = {}) => {
+      if (self2.file) {
+        data.file = self2.file;
       }
-      dispatch(opts, handler) {
-        const headers = buildHeaders(opts.headers);
-        throwIfProxyAuthIsSent(headers);
-        if (headers && !("host" in headers) && !("Host" in headers)) {
-          const { host } = new URL2(opts.origin);
-          headers.host = host;
-        }
-        return this[kAgent].dispatch(
-          {
-            ...opts,
-            headers
-          },
-          handler
-        );
+      if (self2.cwd) {
+        data.cwd = self2.cwd;
       }
-      /**
-       * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
-       * @returns {URL}
-       */
-      #getUrl(opts) {
-        if (typeof opts === "string") {
-          return new URL2(opts);
-        } else if (opts instanceof URL2) {
-          return opts;
-        } else {
-          return new URL2(opts.uri);
+      data.code = message instanceof Error && message.code || code2;
+      data.tarCode = code2;
+      if (!self2.strict && data.recoverable !== false) {
+        if (message instanceof Error) {
+          data = Object.assign(message, data);
+          message = message.message;
         }
-      }
-      async [kClose]() {
-        await this[kAgent].close();
-        await this[kClient].close();
-      }
-      async [kDestroy]() {
-        await this[kAgent].destroy();
-        await this[kClient].destroy();
+        self2.emit("warn", code2, message, data);
+      } else if (message instanceof Error) {
+        self2.emit("error", Object.assign(message, data));
+      } else {
+        self2.emit("error", Object.assign(new Error(`${code2}: ${message}`), data));
       }
     };
-    function buildHeaders(headers) {
-      if (Array.isArray(headers)) {
-        const headersPair = {};
-        for (let i = 0; i < headers.length; i += 2) {
-          headersPair[headers[i]] = headers[i + 1];
-        }
-        return headersPair;
-      }
-      return headers;
-    }
-    function throwIfProxyAuthIsSent(headers) {
-      const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
-      if (existProxyAuth) {
-        throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
-      }
-    }
-    module2.exports = ProxyAgent2;
   }
 });
 
-// .yarn/cache/minipass-npm-7.1.2-3a5327d36d-b0fd20bb9f.zip/node_modules/minipass/dist/esm/index.js
-var import_node_events, import_node_stream, import_node_string_decoder, proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass;
-var init_esm = __esm({
-  ".yarn/cache/minipass-npm-7.1.2-3a5327d36d-b0fd20bb9f.zip/node_modules/minipass/dist/esm/index.js"() {
-    import_node_events = require("node:events");
-    import_node_stream = __toESM(require("node:stream"), 1);
-    import_node_string_decoder = require("node:string_decoder");
-    proc = typeof process === "object" && process ? process : {
-      stdout: null,
-      stderr: null
-    };
-    isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof import_node_stream.default || isReadable(s) || isWritable(s));
-    isReadable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
-    s.pipe !== import_node_stream.default.Writable.prototype.pipe;
-    isWritable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.write === "function" && typeof s.end === "function";
-    EOF = /* @__PURE__ */ Symbol("EOF");
-    MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
-    EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
-    EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
-    EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
-    CLOSED = /* @__PURE__ */ Symbol("closed");
-    READ = /* @__PURE__ */ Symbol("read");
-    FLUSH = /* @__PURE__ */ Symbol("flush");
-    FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
-    ENCODING = /* @__PURE__ */ Symbol("encoding");
-    DECODER = /* @__PURE__ */ Symbol("decoder");
-    FLOWING = /* @__PURE__ */ Symbol("flowing");
-    PAUSED = /* @__PURE__ */ Symbol("paused");
-    RESUME = /* @__PURE__ */ Symbol("resume");
-    BUFFER = /* @__PURE__ */ Symbol("buffer");
-    PIPES = /* @__PURE__ */ Symbol("pipes");
-    BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
-    BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
-    BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
-    OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
-    DESTROYED = /* @__PURE__ */ Symbol("destroyed");
-    ERROR = /* @__PURE__ */ Symbol("error");
-    EMITDATA = /* @__PURE__ */ Symbol("emitData");
-    EMITEND = /* @__PURE__ */ Symbol("emitEnd");
-    EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
-    ASYNC = /* @__PURE__ */ Symbol("async");
-    ABORT = /* @__PURE__ */ Symbol("abort");
-    ABORTED = /* @__PURE__ */ Symbol("aborted");
-    SIGNAL = /* @__PURE__ */ Symbol("signal");
-    DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
-    DISCARDED = /* @__PURE__ */ Symbol("discarded");
-    defer = (fn2) => Promise.resolve().then(fn2);
-    nodefer = (fn2) => fn2();
-    isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
-    isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
-    isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
-    Pipe = class {
-      src;
-      dest;
-      opts;
-      ondrain;
-      constructor(src, dest, opts) {
-        this.src = src;
-        this.dest = dest;
-        this.opts = opts;
-        this.ondrain = () => src[RESUME]();
-        this.dest.on("drain", this.ondrain);
-      }
-      unpipe() {
-        this.dest.removeListener("drain", this.ondrain);
-      }
-      // only here for the prototype
-      /* c8 ignore start */
-      proxyErrors(_er) {
-      }
-      /* c8 ignore stop */
-      end() {
-        this.unpipe();
-        if (this.opts.end)
-          this.dest.end();
-      }
-    };
-    PipeProxyErrors = class extends Pipe {
-      unpipe() {
-        this.src.removeListener("error", this.proxyErrors);
-        super.unpipe();
-      }
-      constructor(src, dest, opts) {
-        super(src, dest, opts);
-        this.proxyErrors = (er) => dest.emit("error", er);
-        src.on("error", this.proxyErrors);
-      }
-    };
-    isObjectModeOptions = (o) => !!o.objectMode;
-    isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
-    Minipass = class extends import_node_events.EventEmitter {
-      [FLOWING] = false;
-      [PAUSED] = false;
-      [PIPES] = [];
-      [BUFFER] = [];
-      [OBJECTMODE];
-      [ENCODING];
-      [ASYNC];
-      [DECODER];
-      [EOF] = false;
-      [EMITTED_END] = false;
-      [EMITTING_END] = false;
-      [CLOSED] = false;
-      [EMITTED_ERROR] = null;
-      [BUFFERLENGTH] = 0;
-      [DESTROYED] = false;
-      [SIGNAL];
-      [ABORTED] = false;
-      [DATALISTENERS] = 0;
-      [DISCARDED] = false;
-      /**
-       * true if the stream can be written
-       */
+// node_modules/tar/dist/esm/parse.js
+var import_events3, maxMetaEntrySize, gzipHeader, zstdHeader, ZIP_HEADER_LEN, STATE, WRITEENTRY, READENTRY, NEXTENTRY, PROCESSENTRY, EX, GEX, META, EMITMETA, BUFFER2, QUEUE, ENDED, EMITTEDEND, EMIT, UNZIP, CONSUMECHUNK, CONSUMECHUNKSUB, CONSUMEBODY, CONSUMEMETA, CONSUMEHEADER, CONSUMING, BUFFERCONCAT, MAYBEEND, WRITING, ABORTED2, DONE, SAW_VALID_ENTRY, SAW_NULL_BLOCK, SAW_EOF, CLOSESTREAM, noop2, Parser;
+var init_parse = __esm({
+  "node_modules/tar/dist/esm/parse.js"() {
+    import_events3 = require("events");
+    init_esm3();
+    init_header();
+    init_pax();
+    init_read_entry();
+    init_warn_method();
+    maxMetaEntrySize = 1024 * 1024;
+    gzipHeader = Buffer.from([31, 139]);
+    zstdHeader = Buffer.from([40, 181, 47, 253]);
+    ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length);
+    STATE = /* @__PURE__ */ Symbol("state");
+    WRITEENTRY = /* @__PURE__ */ Symbol("writeEntry");
+    READENTRY = /* @__PURE__ */ Symbol("readEntry");
+    NEXTENTRY = /* @__PURE__ */ Symbol("nextEntry");
+    PROCESSENTRY = /* @__PURE__ */ Symbol("processEntry");
+    EX = /* @__PURE__ */ Symbol("extendedHeader");
+    GEX = /* @__PURE__ */ Symbol("globalExtendedHeader");
+    META = /* @__PURE__ */ Symbol("meta");
+    EMITMETA = /* @__PURE__ */ Symbol("emitMeta");
+    BUFFER2 = /* @__PURE__ */ Symbol("buffer");
+    QUEUE = /* @__PURE__ */ Symbol("queue");
+    ENDED = /* @__PURE__ */ Symbol("ended");
+    EMITTEDEND = /* @__PURE__ */ Symbol("emittedEnd");
+    EMIT = /* @__PURE__ */ Symbol("emit");
+    UNZIP = /* @__PURE__ */ Symbol("unzip");
+    CONSUMECHUNK = /* @__PURE__ */ Symbol("consumeChunk");
+    CONSUMECHUNKSUB = /* @__PURE__ */ Symbol("consumeChunkSub");
+    CONSUMEBODY = /* @__PURE__ */ Symbol("consumeBody");
+    CONSUMEMETA = /* @__PURE__ */ Symbol("consumeMeta");
+    CONSUMEHEADER = /* @__PURE__ */ Symbol("consumeHeader");
+    CONSUMING = /* @__PURE__ */ Symbol("consuming");
+    BUFFERCONCAT = /* @__PURE__ */ Symbol("bufferConcat");
+    MAYBEEND = /* @__PURE__ */ Symbol("maybeEnd");
+    WRITING = /* @__PURE__ */ Symbol("writing");
+    ABORTED2 = /* @__PURE__ */ Symbol("aborted");
+    DONE = /* @__PURE__ */ Symbol("onDone");
+    SAW_VALID_ENTRY = /* @__PURE__ */ Symbol("sawValidEntry");
+    SAW_NULL_BLOCK = /* @__PURE__ */ Symbol("sawNullBlock");
+    SAW_EOF = /* @__PURE__ */ Symbol("sawEOF");
+    CLOSESTREAM = /* @__PURE__ */ Symbol("closeStream");
+    noop2 = () => true;
+    Parser = class extends import_events3.EventEmitter {
+      file;
+      strict;
+      maxMetaEntrySize;
+      filter;
+      brotli;
+      zstd;
       writable = true;
-      /**
-       * true if the stream can be read
-       */
-      readable = true;
-      /**
-       * If `RType` is Buffer, then options do not need to be provided.
-       * Otherwise, an options object must be provided to specify either
-       * {@link Minipass.SharedOptions.objectMode} or
-       * {@link Minipass.SharedOptions.encoding}, as appropriate.
-       */
-      constructor(...args) {
-        const options = args[0] || {};
+      readable = false;
+      [QUEUE] = [];
+      [BUFFER2];
+      [READENTRY];
+      [WRITEENTRY];
+      [STATE] = "begin";
+      [META] = "";
+      [EX];
+      [GEX];
+      [ENDED] = false;
+      [UNZIP];
+      [ABORTED2] = false;
+      [SAW_VALID_ENTRY];
+      [SAW_NULL_BLOCK] = false;
+      [SAW_EOF] = false;
+      [WRITING] = false;
+      [CONSUMING] = false;
+      [EMITTEDEND] = false;
+      constructor(opt = {}) {
         super();
-        if (options.objectMode && typeof options.encoding === "string") {
-          throw new TypeError("Encoding and objectMode may not be used together");
-        }
-        if (isObjectModeOptions(options)) {
-          this[OBJECTMODE] = true;
-          this[ENCODING] = null;
-        } else if (isEncodingOptions(options)) {
-          this[ENCODING] = options.encoding;
-          this[OBJECTMODE] = false;
+        this.file = opt.file || "";
+        this.on(DONE, () => {
+          if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) {
+            this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
+          }
+        });
+        if (opt.ondone) {
+          this.on(DONE, opt.ondone);
         } else {
-          this[OBJECTMODE] = false;
-          this[ENCODING] = null;
-        }
-        this[ASYNC] = !!options.async;
-        this[DECODER] = this[ENCODING] ? new import_node_string_decoder.StringDecoder(this[ENCODING]) : null;
-        if (options && options.debugExposeBuffer === true) {
-          Object.defineProperty(this, "buffer", { get: () => this[BUFFER] });
+          this.on(DONE, () => {
+            this.emit("prefinish");
+            this.emit("finish");
+            this.emit("end");
+          });
         }
-        if (options && options.debugExposePipes === true) {
-          Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
+        this.strict = !!opt.strict;
+        this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
+        this.filter = typeof opt.filter === "function" ? opt.filter : noop2;
+        const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr"));
+        this.brotli = !(opt.gzip || opt.zstd) && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false;
+        const isTZST = opt.file && (opt.file.endsWith(".tar.zst") || opt.file.endsWith(".tzst"));
+        this.zstd = !(opt.gzip || opt.brotli) && opt.zstd !== void 0 ? opt.zstd : isTZST ? true : void 0;
+        this.on("end", () => this[CLOSESTREAM]());
+        if (typeof opt.onwarn === "function") {
+          this.on("warn", opt.onwarn);
         }
-        const { signal } = options;
-        if (signal) {
-          this[SIGNAL] = signal;
-          if (signal.aborted) {
-            this[ABORT]();
-          } else {
-            signal.addEventListener("abort", () => this[ABORT]());
-          }
+        if (typeof opt.onReadEntry === "function") {
+          this.on("entry", opt.onReadEntry);
         }
       }
-      /**
-       * The amount of data stored in the buffer waiting to be read.
-       *
-       * For Buffer strings, this will be the total byte length.
-       * For string encoding streams, this will be the string character length,
-       * according to JavaScript's `string.length` logic.
-       * For objectMode streams, this is a count of the items waiting to be
-       * emitted.
-       */
-      get bufferLength() {
-        return this[BUFFERLENGTH];
-      }
-      /**
-       * The `BufferEncoding` currently in use, or `null`
-       */
-      get encoding() {
-        return this[ENCODING];
-      }
-      /**
-       * @deprecated - This is a read only property
-       */
-      set encoding(_enc) {
-        throw new Error("Encoding must be set at instantiation time");
-      }
-      /**
-       * @deprecated - Encoding may only be set at instantiation time
-       */
-      setEncoding(_enc) {
-        throw new Error("Encoding must be set at instantiation time");
+      warn(code2, message, data = {}) {
+        warnMethod(this, code2, message, data);
       }
-      /**
-       * True if this is an objectMode stream
-       */
-      get objectMode() {
-        return this[OBJECTMODE];
+      [CONSUMEHEADER](chunk, position) {
+        if (this[SAW_VALID_ENTRY] === void 0) {
+          this[SAW_VALID_ENTRY] = false;
+        }
+        let header;
+        try {
+          header = new Header(chunk, position, this[EX], this[GEX]);
+        } catch (er) {
+          return this.warn("TAR_ENTRY_INVALID", er);
+        }
+        if (header.nullBlock) {
+          if (this[SAW_NULL_BLOCK]) {
+            this[SAW_EOF] = true;
+            if (this[STATE] === "begin") {
+              this[STATE] = "header";
+            }
+            this[EMIT]("eof");
+          } else {
+            this[SAW_NULL_BLOCK] = true;
+            this[EMIT]("nullBlock");
+          }
+        } else {
+          this[SAW_NULL_BLOCK] = false;
+          if (!header.cksumValid) {
+            this.warn("TAR_ENTRY_INVALID", "checksum failure", { header });
+          } else if (!header.path) {
+            this.warn("TAR_ENTRY_INVALID", "path is required", { header });
+          } else {
+            const type = header.type;
+            if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) {
+              this.warn("TAR_ENTRY_INVALID", "linkpath required", {
+                header
+              });
+            } else if (!/^(Symbolic)?Link$/.test(type) && !/^(Global)?ExtendedHeader$/.test(type) && header.linkpath) {
+              this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", {
+                header
+              });
+            } else {
+              const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]);
+              if (!this[SAW_VALID_ENTRY]) {
+                if (entry.remain) {
+                  const onend = () => {
+                    if (!entry.invalid) {
+                      this[SAW_VALID_ENTRY] = true;
+                    }
+                  };
+                  entry.on("end", onend);
+                } else {
+                  this[SAW_VALID_ENTRY] = true;
+                }
+              }
+              if (entry.meta) {
+                if (entry.size > this.maxMetaEntrySize) {
+                  entry.ignore = true;
+                  this[EMIT]("ignoredEntry", entry);
+                  this[STATE] = "ignore";
+                  entry.resume();
+                } else if (entry.size > 0) {
+                  this[META] = "";
+                  entry.on("data", (c) => this[META] += c);
+                  this[STATE] = "meta";
+                }
+              } else {
+                this[EX] = void 0;
+                entry.ignore = entry.ignore || !this.filter(entry.path, entry);
+                if (entry.ignore) {
+                  this[EMIT]("ignoredEntry", entry);
+                  this[STATE] = entry.remain ? "ignore" : "header";
+                  entry.resume();
+                } else {
+                  if (entry.remain) {
+                    this[STATE] = "body";
+                  } else {
+                    this[STATE] = "header";
+                    entry.end();
+                  }
+                  if (!this[READENTRY]) {
+                    this[QUEUE].push(entry);
+                    this[NEXTENTRY]();
+                  } else {
+                    this[QUEUE].push(entry);
+                  }
+                }
+              }
+            }
+          }
+        }
       }
-      /**
-       * @deprecated - This is a read-only property
-       */
-      set objectMode(_om) {
-        throw new Error("objectMode must be set at instantiation time");
+      [CLOSESTREAM]() {
+        queueMicrotask(() => this.emit("close"));
       }
-      /**
-       * true if this is an async stream
-       */
-      get ["async"]() {
-        return this[ASYNC];
+      [PROCESSENTRY](entry) {
+        let go = true;
+        if (!entry) {
+          this[READENTRY] = void 0;
+          go = false;
+        } else if (Array.isArray(entry)) {
+          const [ev, ...args] = entry;
+          this.emit(ev, ...args);
+        } else {
+          this[READENTRY] = entry;
+          this.emit("entry", entry);
+          if (!entry.emittedEnd) {
+            entry.on("end", () => this[NEXTENTRY]());
+            go = false;
+          }
+        }
+        return go;
       }
-      /**
-       * Set to true to make this stream async.
-       *
-       * Once set, it cannot be unset, as this would potentially cause incorrect
-       * behavior.  Ie, a sync stream can be made async, but an async stream
-       * cannot be safely made sync.
-       */
-      set ["async"](a) {
-        this[ASYNC] = this[ASYNC] || !!a;
+      [NEXTENTRY]() {
+        do {
+        } while (this[PROCESSENTRY](this[QUEUE].shift()));
+        if (this[QUEUE].length === 0) {
+          const re = this[READENTRY];
+          const drainNow = !re || re.flowing || re.size === re.remain;
+          if (drainNow) {
+            if (!this[WRITING]) {
+              this.emit("drain");
+            }
+          } else {
+            re.once("drain", () => this.emit("drain"));
+          }
+        }
       }
-      // drop everything and get out of the flow completely
-      [ABORT]() {
-        this[ABORTED] = true;
-        this.emit("abort", this[SIGNAL]?.reason);
-        this.destroy(this[SIGNAL]?.reason);
+      [CONSUMEBODY](chunk, position) {
+        const entry = this[WRITEENTRY];
+        if (!entry) {
+          throw new Error("attempt to consume body without entry??");
+        }
+        const br = entry.blockRemain ?? 0;
+        const c = br >= chunk.length && position === 0 ? chunk : chunk.subarray(position, position + br);
+        entry.write(c);
+        if (!entry.blockRemain) {
+          this[STATE] = "header";
+          this[WRITEENTRY] = void 0;
+          entry.end();
+        }
+        return c.length;
       }
-      /**
-       * True if the stream has been aborted.
-       */
-      get aborted() {
-        return this[ABORTED];
+      [CONSUMEMETA](chunk, position) {
+        const entry = this[WRITEENTRY];
+        const ret = this[CONSUMEBODY](chunk, position);
+        if (!this[WRITEENTRY] && entry) {
+          this[EMITMETA](entry);
+        }
+        return ret;
       }
-      /**
-       * No-op setter. Stream aborted status is set via the AbortSignal provided
-       * in the constructor options.
-       */
-      set aborted(_) {
+      [EMIT](ev, data, extra) {
+        if (this[QUEUE].length === 0 && !this[READENTRY]) {
+          this.emit(ev, data, extra);
+        } else {
+          this[QUEUE].push([ev, data, extra]);
+        }
       }
-      write(chunk, encoding, cb) {
-        if (this[ABORTED])
-          return false;
-        if (this[EOF])
-          throw new Error("write after end");
-        if (this[DESTROYED]) {
-          this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
-          return true;
+      [EMITMETA](entry) {
+        this[EMIT]("meta", this[META]);
+        switch (entry.type) {
+          case "ExtendedHeader":
+          case "OldExtendedHeader":
+            this[EX] = Pax.parse(this[META], this[EX], false);
+            break;
+          case "GlobalExtendedHeader":
+            this[GEX] = Pax.parse(this[META], this[GEX], true);
+            break;
+          case "NextFileHasLongPath":
+          case "OldGnuLongPath": {
+            const ex = this[EX] ?? /* @__PURE__ */ Object.create(null);
+            this[EX] = ex;
+            ex.path = this[META].replace(/\0.*/, "");
+            break;
+          }
+          case "NextFileHasLongLinkpath": {
+            const ex = this[EX] || /* @__PURE__ */ Object.create(null);
+            this[EX] = ex;
+            ex.linkpath = this[META].replace(/\0.*/, "");
+            break;
+          }
+          /* c8 ignore start */
+          default:
+            throw new Error("unknown meta: " + entry.type);
         }
+      }
+      abort(error) {
+        this[ABORTED2] = true;
+        this.emit("abort", error);
+        this.warn("TAR_ABORT", error, { recoverable: false });
+      }
+      write(chunk, encoding, cb) {
         if (typeof encoding === "function") {
           cb = encoding;
-          encoding = "utf8";
+          encoding = void 0;
         }
-        if (!encoding)
-          encoding = "utf8";
-        const fn2 = this[ASYNC] ? defer : nodefer;
-        if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
-          if (isArrayBufferView(chunk)) {
-            chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-          } else if (isArrayBufferLike(chunk)) {
-            chunk = Buffer.from(chunk);
-          } else if (typeof chunk !== "string") {
-            throw new Error("Non-contiguous data written to non-objectMode stream");
-          }
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(
+            chunk,
+            /* c8 ignore next */
+            typeof encoding === "string" ? encoding : "utf8"
+          );
         }
-        if (this[OBJECTMODE]) {
-          if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
-            this[FLUSH](true);
-          if (this[FLOWING])
-            this.emit("data", chunk);
-          else
-            this[BUFFERPUSH](chunk);
-          if (this[BUFFERLENGTH] !== 0)
-            this.emit("readable");
-          if (cb)
-            fn2(cb);
-          return this[FLOWING];
+        if (this[ABORTED2]) {
+          cb?.();
+          return false;
         }
-        if (!chunk.length) {
-          if (this[BUFFERLENGTH] !== 0)
-            this.emit("readable");
-          if (cb)
-            fn2(cb);
-          return this[FLOWING];
+        const needSniff = this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false;
+        if (needSniff && chunk) {
+          if (this[BUFFER2]) {
+            chunk = Buffer.concat([this[BUFFER2], chunk]);
+            this[BUFFER2] = void 0;
+          }
+          if (chunk.length < ZIP_HEADER_LEN) {
+            this[BUFFER2] = chunk;
+            cb?.();
+            return true;
+          }
+          for (let i = 0; this[UNZIP] === void 0 && i < gzipHeader.length; i++) {
+            if (chunk[i] !== gzipHeader[i]) {
+              this[UNZIP] = false;
+            }
+          }
+          let isZstd = false;
+          if (this[UNZIP] === false && this.zstd !== false) {
+            isZstd = true;
+            for (let i = 0; i < zstdHeader.length; i++) {
+              if (chunk[i] !== zstdHeader[i]) {
+                isZstd = false;
+                break;
+              }
+            }
+          }
+          const maybeBrotli = this.brotli === void 0 && !isZstd;
+          if (this[UNZIP] === false && maybeBrotli) {
+            if (chunk.length < 512) {
+              if (this[ENDED]) {
+                this.brotli = true;
+              } else {
+                this[BUFFER2] = chunk;
+                cb?.();
+                return true;
+              }
+            } else {
+              try {
+                new Header(chunk.subarray(0, 512));
+                this.brotli = false;
+              } catch (_) {
+                this.brotli = true;
+              }
+            }
+          }
+          if (this[UNZIP] === void 0 || this[UNZIP] === false && (this.brotli || isZstd)) {
+            const ended = this[ENDED];
+            this[ENDED] = false;
+            this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : isZstd ? new ZstdDecompress({}) : new BrotliDecompress({});
+            this[UNZIP].on("data", (chunk2) => this[CONSUMECHUNK](chunk2));
+            this[UNZIP].on("error", (er) => this.abort(er));
+            this[UNZIP].on("end", () => {
+              this[ENDED] = true;
+              this[CONSUMECHUNK]();
+            });
+            this[WRITING] = true;
+            const ret2 = !!this[UNZIP][ended ? "end" : "write"](chunk);
+            this[WRITING] = false;
+            cb?.();
+            return ret2;
+          }
         }
-        if (typeof chunk === "string" && // unless it is a string already ready for us to use
-        !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) {
-          chunk = Buffer.from(chunk, encoding);
+        this[WRITING] = true;
+        if (this[UNZIP]) {
+          this[UNZIP].write(chunk);
+        } else {
+          this[CONSUMECHUNK](chunk);
         }
-        if (Buffer.isBuffer(chunk) && this[ENCODING]) {
-          chunk = this[DECODER].write(chunk);
+        this[WRITING] = false;
+        const ret = this[QUEUE].length > 0 ? false : this[READENTRY] ? this[READENTRY].flowing : true;
+        if (!ret && this[QUEUE].length === 0) {
+          this[READENTRY]?.once("drain", () => this.emit("drain"));
         }
-        if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
-          this[FLUSH](true);
-        if (this[FLOWING])
-          this.emit("data", chunk);
-        else
-          this[BUFFERPUSH](chunk);
-        if (this[BUFFERLENGTH] !== 0)
-          this.emit("readable");
-        if (cb)
-          fn2(cb);
-        return this[FLOWING];
+        cb?.();
+        return ret;
       }
-      /**
-       * Low-level explicit read method.
-       *
-       * In objectMode, the argument is ignored, and one item is returned if
-       * available.
-       *
-       * `n` is the number of bytes (or in the case of encoding streams,
-       * characters) to consume. If `n` is not provided, then the entire buffer
-       * is returned, or `null` is returned if no data is available.
-       *
-       * If `n` is greater that the amount of data in the internal buffer,
-       * then `null` is returned.
-       */
-      read(n) {
-        if (this[DESTROYED])
-          return null;
-        this[DISCARDED] = false;
-        if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) {
-          this[MAYBE_EMIT_END]();
-          return null;
+      [BUFFERCONCAT](c) {
+        if (c && !this[ABORTED2]) {
+          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([this[BUFFER2], c]) : c;
         }
-        if (this[OBJECTMODE])
-          n = null;
-        if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
-          this[BUFFER] = [
-            this[ENCODING] ? this[BUFFER].join("") : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
-          ];
+      }
+      [MAYBEEND]() {
+        if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED2] && !this[CONSUMING]) {
+          this[EMITTEDEND] = true;
+          const entry = this[WRITEENTRY];
+          if (entry && entry.blockRemain) {
+            const have = this[BUFFER2] ? this[BUFFER2].length : 0;
+            this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
+            if (this[BUFFER2]) {
+              entry.write(this[BUFFER2]);
+            }
+            entry.end();
+          }
+          this[EMIT](DONE);
         }
-        const ret = this[READ](n || null, this[BUFFER][0]);
-        this[MAYBE_EMIT_END]();
-        return ret;
       }
-      [READ](n, chunk) {
-        if (this[OBJECTMODE])
-          this[BUFFERSHIFT]();
-        else {
-          const c = chunk;
-          if (n === c.length || n === null)
-            this[BUFFERSHIFT]();
-          else if (typeof c === "string") {
-            this[BUFFER][0] = c.slice(n);
-            chunk = c.slice(0, n);
-            this[BUFFERLENGTH] -= n;
+      [CONSUMECHUNK](chunk) {
+        if (this[CONSUMING] && chunk) {
+          this[BUFFERCONCAT](chunk);
+        } else if (!chunk && !this[BUFFER2]) {
+          this[MAYBEEND]();
+        } else if (chunk) {
+          this[CONSUMING] = true;
+          if (this[BUFFER2]) {
+            this[BUFFERCONCAT](chunk);
+            const c = this[BUFFER2];
+            this[BUFFER2] = void 0;
+            this[CONSUMECHUNKSUB](c);
           } else {
-            this[BUFFER][0] = c.subarray(n);
-            chunk = c.subarray(0, n);
-            this[BUFFERLENGTH] -= n;
+            this[CONSUMECHUNKSUB](chunk);
+          }
+          while (this[BUFFER2] && this[BUFFER2]?.length >= 512 && !this[ABORTED2] && !this[SAW_EOF]) {
+            const c = this[BUFFER2];
+            this[BUFFER2] = void 0;
+            this[CONSUMECHUNKSUB](c);
           }
+          this[CONSUMING] = false;
+        }
+        if (!this[BUFFER2] || this[ENDED]) {
+          this[MAYBEEND]();
+        }
+      }
+      [CONSUMECHUNKSUB](chunk) {
+        let position = 0;
+        const length = chunk.length;
+        while (position + 512 <= length && !this[ABORTED2] && !this[SAW_EOF]) {
+          switch (this[STATE]) {
+            case "begin":
+            case "header":
+              this[CONSUMEHEADER](chunk, position);
+              position += 512;
+              break;
+            case "ignore":
+            case "body":
+              position += this[CONSUMEBODY](chunk, position);
+              break;
+            case "meta":
+              position += this[CONSUMEMETA](chunk, position);
+              break;
+            /* c8 ignore start */
+            default:
+              throw new Error("invalid state: " + this[STATE]);
+          }
+        }
+        if (position < length) {
+          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([chunk.subarray(position), this[BUFFER2]]) : chunk.subarray(position);
         }
-        this.emit("data", chunk);
-        if (!this[BUFFER].length && !this[EOF])
-          this.emit("drain");
-        return chunk;
       }
       end(chunk, encoding, cb) {
         if (typeof chunk === "function") {
           cb = chunk;
+          encoding = void 0;
           chunk = void 0;
         }
         if (typeof encoding === "function") {
           cb = encoding;
-          encoding = "utf8";
+          encoding = void 0;
+        }
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(chunk, encoding);
         }
-        if (chunk !== void 0)
-          this.write(chunk, encoding);
         if (cb)
-          this.once("end", cb);
-        this[EOF] = true;
-        this.writable = false;
-        if (this[FLOWING] || !this[PAUSED])
-          this[MAYBE_EMIT_END]();
-        return this;
-      }
-      // don't let the internal resume be overwritten
-      [RESUME]() {
-        if (this[DESTROYED])
-          return;
-        if (!this[DATALISTENERS] && !this[PIPES].length) {
-          this[DISCARDED] = true;
+          this.once("finish", cb);
+        if (!this[ABORTED2]) {
+          if (this[UNZIP]) {
+            if (chunk)
+              this[UNZIP].write(chunk);
+            this[UNZIP].end();
+          } else {
+            this[ENDED] = true;
+            if (this.brotli === void 0 || this.zstd === void 0)
+              chunk = chunk || Buffer.alloc(0);
+            if (chunk)
+              this.write(chunk);
+            this[MAYBEEND]();
+          }
         }
-        this[PAUSED] = false;
-        this[FLOWING] = true;
-        this.emit("resume");
-        if (this[BUFFER].length)
-          this[FLUSH]();
-        else if (this[EOF])
-          this[MAYBE_EMIT_END]();
-        else
-          this.emit("drain");
+        return this;
       }
-      /**
-       * Resume the stream if it is currently in a paused state
-       *
-       * If called when there are no pipe destinations or `data` event listeners,
-       * this will place the stream in a "discarded" state, where all data will
-       * be thrown away. The discarded state is removed if a pipe destination or
-       * data handler is added, if pause() is called, or if any synchronous or
-       * asynchronous iteration is started.
-       */
-      resume() {
-        return this[RESUME]();
-      }
-      /**
-       * Pause the stream
-       */
-      pause() {
-        this[FLOWING] = false;
-        this[PAUSED] = true;
-        this[DISCARDED] = false;
-      }
-      /**
-       * true if the stream has been forcibly destroyed
-       */
-      get destroyed() {
-        return this[DESTROYED];
-      }
-      /**
-       * true if the stream is currently in a flowing state, meaning that
-       * any writes will be immediately emitted.
-       */
-      get flowing() {
-        return this[FLOWING];
-      }
-      /**
-       * true if the stream is currently in a paused state
-       */
-      get paused() {
-        return this[PAUSED];
-      }
-      [BUFFERPUSH](chunk) {
-        if (this[OBJECTMODE])
-          this[BUFFERLENGTH] += 1;
-        else
-          this[BUFFERLENGTH] += chunk.length;
-        this[BUFFER].push(chunk);
-      }
-      [BUFFERSHIFT]() {
-        if (this[OBJECTMODE])
-          this[BUFFERLENGTH] -= 1;
-        else
-          this[BUFFERLENGTH] -= this[BUFFER][0].length;
-        return this[BUFFER].shift();
-      }
-      [FLUSH](noDrain = false) {
-        do {
-        } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
-        if (!noDrain && !this[BUFFER].length && !this[EOF])
-          this.emit("drain");
-      }
-      [FLUSHCHUNK](chunk) {
-        this.emit("data", chunk);
-        return this[FLOWING];
-      }
-      /**
-       * Pipe all data emitted by this stream into the destination provided.
-       *
-       * Triggers the flow of data.
-       */
-      pipe(dest, opts) {
-        if (this[DESTROYED])
-          return dest;
-        this[DISCARDED] = false;
-        const ended = this[EMITTED_END];
-        opts = opts || {};
-        if (dest === proc.stdout || dest === proc.stderr)
-          opts.end = false;
-        else
-          opts.end = opts.end !== false;
-        opts.proxyErrors = !!opts.proxyErrors;
-        if (ended) {
-          if (opts.end)
-            dest.end();
-        } else {
-          this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
-          if (this[ASYNC])
-            defer(() => this[RESUME]());
-          else
-            this[RESUME]();
-        }
-        return dest;
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/strip-trailing-slashes.js
+var stripTrailingSlashes;
+var init_strip_trailing_slashes = __esm({
+  "node_modules/tar/dist/esm/strip-trailing-slashes.js"() {
+    stripTrailingSlashes = (str) => {
+      let i = str.length - 1;
+      let slashesStart = -1;
+      while (i > -1 && str.charAt(i) === "/") {
+        slashesStart = i;
+        i--;
       }
-      /**
-       * Fully unhook a piped destination stream.
-       *
-       * If the destination stream was the only consumer of this stream (ie,
-       * there are no other piped destinations or `'data'` event listeners)
-       * then the flow of data will stop until there is another consumer or
-       * {@link Minipass#resume} is explicitly called.
-       */
-      unpipe(dest) {
-        const p = this[PIPES].find((p2) => p2.dest === dest);
-        if (p) {
-          if (this[PIPES].length === 1) {
-            if (this[FLOWING] && this[DATALISTENERS] === 0) {
-              this[FLOWING] = false;
-            }
-            this[PIPES] = [];
-          } else
-            this[PIPES].splice(this[PIPES].indexOf(p), 1);
-          p.unpipe();
+      return slashesStart === -1 ? str : str.slice(0, slashesStart);
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/list.js
+var list_exports = {};
+__export(list_exports, {
+  filesFilter: () => filesFilter,
+  list: () => list
+});
+var import_node_fs, import_path2, onReadEntryFunction, filesFilter, listFileSync, listFile, list;
+var init_list = __esm({
+  "node_modules/tar/dist/esm/list.js"() {
+    init_esm2();
+    import_node_fs = __toESM(require("node:fs"), 1);
+    import_path2 = require("path");
+    init_make_command();
+    init_parse();
+    init_strip_trailing_slashes();
+    onReadEntryFunction = (opt) => {
+      const onReadEntry = opt.onReadEntry;
+      opt.onReadEntry = onReadEntry ? (e) => {
+        onReadEntry(e);
+        e.resume();
+      } : (e) => e.resume();
+    };
+    filesFilter = (opt, files) => {
+      const map = new Map(files.map((f) => [stripTrailingSlashes(f), true]));
+      const filter = opt.filter;
+      const mapHas = (file, r = "") => {
+        const root = r || (0, import_path2.parse)(file).root || ".";
+        let ret;
+        if (file === root)
+          ret = false;
+        else {
+          const m = map.get(file);
+          ret = m !== void 0 ? m : mapHas((0, import_path2.dirname)(file), root);
         }
-      }
-      /**
-       * Alias for {@link Minipass#on}
-       */
-      addListener(ev, handler) {
-        return this.on(ev, handler);
-      }
-      /**
-       * Mostly identical to `EventEmitter.on`, with the following
-       * behavior differences to prevent data loss and unnecessary hangs:
-       *
-       * - Adding a 'data' event handler will trigger the flow of data
-       *
-       * - Adding a 'readable' event handler when there is data waiting to be read
-       *   will cause 'readable' to be emitted immediately.
-       *
-       * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
-       *   already passed will cause the event to be emitted immediately and all
-       *   handlers removed.
-       *
-       * - Adding an 'error' event handler after an error has been emitted will
-       *   cause the event to be re-emitted immediately with the error previously
-       *   raised.
-       */
-      on(ev, handler) {
-        const ret = super.on(ev, handler);
-        if (ev === "data") {
-          this[DISCARDED] = false;
-          this[DATALISTENERS]++;
-          if (!this[PIPES].length && !this[FLOWING]) {
-            this[RESUME]();
+        map.set(file, ret);
+        return ret;
+      };
+      opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file)) : (file) => mapHas(stripTrailingSlashes(file));
+    };
+    listFileSync = (opt) => {
+      const p = new Parser(opt);
+      const file = opt.file;
+      let fd;
+      try {
+        fd = import_node_fs.default.openSync(file, "r");
+        const stat = import_node_fs.default.fstatSync(fd);
+        const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+        if (stat.size < readSize) {
+          const buf = Buffer.allocUnsafe(stat.size);
+          const read = import_node_fs.default.readSync(fd, buf, 0, stat.size, 0);
+          p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
+        } else {
+          let pos2 = 0;
+          const buf = Buffer.allocUnsafe(readSize);
+          while (pos2 < stat.size) {
+            const bytesRead = import_node_fs.default.readSync(fd, buf, 0, readSize, pos2);
+            if (bytesRead === 0)
+              break;
+            pos2 += bytesRead;
+            p.write(buf.subarray(0, bytesRead));
           }
-        } else if (ev === "readable" && this[BUFFERLENGTH] !== 0) {
-          super.emit("readable");
-        } else if (isEndish(ev) && this[EMITTED_END]) {
-          super.emit(ev);
-          this.removeAllListeners(ev);
-        } else if (ev === "error" && this[EMITTED_ERROR]) {
-          const h = handler;
-          if (this[ASYNC])
-            defer(() => h.call(this, this[EMITTED_ERROR]));
-          else
-            h.call(this, this[EMITTED_ERROR]);
+          p.end();
         }
-        return ret;
-      }
-      /**
-       * Alias for {@link Minipass#off}
-       */
-      removeListener(ev, handler) {
-        return this.off(ev, handler);
-      }
-      /**
-       * Mostly identical to `EventEmitter.off`
-       *
-       * If a 'data' event handler is removed, and it was the last consumer
-       * (ie, there are no pipe destinations or other 'data' event listeners),
-       * then the flow of data will stop until there is another consumer or
-       * {@link Minipass#resume} is explicitly called.
-       */
-      off(ev, handler) {
-        const ret = super.off(ev, handler);
-        if (ev === "data") {
-          this[DATALISTENERS] = this.listeners("data").length;
-          if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) {
-            this[FLOWING] = false;
+      } finally {
+        if (typeof fd === "number") {
+          try {
+            import_node_fs.default.closeSync(fd);
+          } catch {
           }
         }
-        return ret;
       }
-      /**
-       * Mostly identical to `EventEmitter.removeAllListeners`
-       *
-       * If all 'data' event handlers are removed, and they were the last consumer
-       * (ie, there are no pipe destinations), then the flow of data will stop
-       * until there is another consumer or {@link Minipass#resume} is explicitly
-       * called.
-       */
-      removeAllListeners(ev) {
-        const ret = super.removeAllListeners(ev);
-        if (ev === "data" || ev === void 0) {
-          this[DATALISTENERS] = 0;
-          if (!this[DISCARDED] && !this[PIPES].length) {
-            this[FLOWING] = false;
+    };
+    listFile = (opt, _files) => {
+      const parse4 = new Parser(opt);
+      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+      const file = opt.file;
+      const p = new Promise((resolve, reject) => {
+        parse4.on("error", reject);
+        parse4.on("end", resolve);
+        import_node_fs.default.stat(file, (er, stat) => {
+          if (er) {
+            reject(er);
+          } else {
+            const stream = new ReadStream(file, {
+              readSize,
+              size: stat.size
+            });
+            stream.on("error", reject);
+            stream.pipe(parse4);
           }
-        }
-        return ret;
+        });
+      });
+      return p;
+    };
+    list = makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => {
+      if (files?.length)
+        filesFilter(opt, files);
+      if (!opt.noResume)
+        onReadEntryFunction(opt);
+    });
+  }
+});
+
+// node_modules/tar/dist/esm/get-write-flag.js
+var import_fs3, platform2, isWindows, O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, noFollowFlag, getWriteFlag;
+var init_get_write_flag = __esm({
+  "node_modules/tar/dist/esm/get-write-flag.js"() {
+    import_fs3 = __toESM(require("fs"), 1);
+    platform2 = process.env.__FAKE_PLATFORM__ || process.platform;
+    isWindows = platform2 === "win32";
+    ({ O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = import_fs3.default.constants);
+    UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs3.default.constants.UV_FS_O_FILEMAP || 0;
+    fMapEnabled = isWindows && !!UV_FS_O_FILEMAP;
+    fMapLimit = 512 * 1024;
+    fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
+    noFollowFlag = !isWindows && typeof O_NOFOLLOW === "number" ? O_NOFOLLOW | O_TRUNC | O_CREAT | O_WRONLY : null;
+    getWriteFlag = noFollowFlag !== null ? () => noFollowFlag : !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w";
+  }
+});
+
+// node_modules/chownr/dist/esm/index.js
+var import_node_fs2, import_node_path3, lchownSync, chown, chownrKid, chownr, chownrKidSync, chownrSync;
+var init_esm4 = __esm({
+  "node_modules/chownr/dist/esm/index.js"() {
+    import_node_fs2 = __toESM(require("node:fs"), 1);
+    import_node_path3 = __toESM(require("node:path"), 1);
+    lchownSync = (path16, uid, gid) => {
+      try {
+        return import_node_fs2.default.lchownSync(path16, uid, gid);
+      } catch (er) {
+        if (er?.code !== "ENOENT")
+          throw er;
       }
-      /**
-       * true if the 'end' event has been emitted
-       */
-      get emittedEnd() {
-        return this[EMITTED_END];
+    };
+    chown = (cpath, uid, gid, cb) => {
+      import_node_fs2.default.lchown(cpath, uid, gid, (er) => {
+        cb(er && er?.code !== "ENOENT" ? er : null);
+      });
+    };
+    chownrKid = (p, child, uid, gid, cb) => {
+      if (child.isDirectory()) {
+        chownr(import_node_path3.default.resolve(p, child.name), uid, gid, (er) => {
+          if (er)
+            return cb(er);
+          const cpath = import_node_path3.default.resolve(p, child.name);
+          chown(cpath, uid, gid, cb);
+        });
+      } else {
+        const cpath = import_node_path3.default.resolve(p, child.name);
+        chown(cpath, uid, gid, cb);
       }
-      [MAYBE_EMIT_END]() {
-        if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF]) {
-          this[EMITTING_END] = true;
-          this.emit("end");
-          this.emit("prefinish");
-          this.emit("finish");
-          if (this[CLOSED])
-            this.emit("close");
-          this[EMITTING_END] = false;
+    };
+    chownr = (p, uid, gid, cb) => {
+      import_node_fs2.default.readdir(p, { withFileTypes: true }, (er, children) => {
+        if (er) {
+          if (er.code === "ENOENT")
+            return cb();
+          else if (er.code !== "ENOTDIR" && er.code !== "ENOTSUP")
+            return cb(er);
         }
-      }
-      /**
-       * Mostly identical to `EventEmitter.emit`, with the following
-       * behavior differences to prevent data loss and unnecessary hangs:
-       *
-       * If the stream has been destroyed, and the event is something other
-       * than 'close' or 'error', then `false` is returned and no handlers
-       * are called.
-       *
-       * If the event is 'end', and has already been emitted, then the event
-       * is ignored. If the stream is in a paused or non-flowing state, then
-       * the event will be deferred until data flow resumes. If the stream is
-       * async, then handlers will be called on the next tick rather than
-       * immediately.
-       *
-       * If the event is 'close', and 'end' has not yet been emitted, then
-       * the event will be deferred until after 'end' is emitted.
-       *
-       * If the event is 'error', and an AbortSignal was provided for the stream,
-       * and there are no listeners, then the event is ignored, matching the
-       * behavior of node core streams in the presense of an AbortSignal.
-       *
-       * If the event is 'finish' or 'prefinish', then all listeners will be
-       * removed after emitting the event, to prevent double-firing.
-       */
-      emit(ev, ...args) {
-        const data = args[0];
-        if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) {
-          return false;
-        } else if (ev === "data") {
-          return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data);
-        } else if (ev === "end") {
-          return this[EMITEND]();
-        } else if (ev === "close") {
-          this[CLOSED] = true;
-          if (!this[EMITTED_END] && !this[DESTROYED])
-            return false;
-          const ret2 = super.emit("close");
-          this.removeAllListeners("close");
-          return ret2;
-        } else if (ev === "error") {
-          this[EMITTED_ERROR] = data;
-          super.emit(ERROR, data);
-          const ret2 = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
-          this[MAYBE_EMIT_END]();
-          return ret2;
-        } else if (ev === "resume") {
-          const ret2 = super.emit("resume");
-          this[MAYBE_EMIT_END]();
-          return ret2;
-        } else if (ev === "finish" || ev === "prefinish") {
-          const ret2 = super.emit(ev);
-          this.removeAllListeners(ev);
-          return ret2;
+        if (er || !children.length)
+          return chown(p, uid, gid, cb);
+        let len = children.length;
+        let errState = null;
+        const then = (er2) => {
+          if (errState)
+            return;
+          if (er2)
+            return cb(errState = er2);
+          if (--len === 0)
+            return chown(p, uid, gid, cb);
+        };
+        for (const child of children) {
+          chownrKid(p, child, uid, gid, then);
         }
-        const ret = super.emit(ev, ...args);
-        this[MAYBE_EMIT_END]();
-        return ret;
+      });
+    };
+    chownrKidSync = (p, child, uid, gid) => {
+      if (child.isDirectory())
+        chownrSync(import_node_path3.default.resolve(p, child.name), uid, gid);
+      lchownSync(import_node_path3.default.resolve(p, child.name), uid, gid);
+    };
+    chownrSync = (p, uid, gid) => {
+      let children;
+      try {
+        children = import_node_fs2.default.readdirSync(p, { withFileTypes: true });
+      } catch (er) {
+        const e = er;
+        if (e?.code === "ENOENT")
+          return;
+        else if (e?.code === "ENOTDIR" || e?.code === "ENOTSUP")
+          return lchownSync(p, uid, gid);
+        else
+          throw e;
       }
-      [EMITDATA](data) {
-        for (const p of this[PIPES]) {
-          if (p.dest.write(data) === false)
-            this.pause();
-        }
-        const ret = this[DISCARDED] ? false : super.emit("data", data);
-        this[MAYBE_EMIT_END]();
-        return ret;
+      for (const child of children) {
+        chownrKidSync(p, child, uid, gid);
       }
-      [EMITEND]() {
-        if (this[EMITTED_END])
-          return false;
-        this[EMITTED_END] = true;
-        this.readable = false;
-        return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]();
+      return lchownSync(p, uid, gid);
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/cwd-error.js
+var CwdError;
+var init_cwd_error = __esm({
+  "node_modules/tar/dist/esm/cwd-error.js"() {
+    CwdError = class extends Error {
+      path;
+      code;
+      syscall = "chdir";
+      constructor(path16, code2) {
+        super(`${code2}: Cannot cd into '${path16}'`);
+        this.path = path16;
+        this.code = code2;
       }
-      [EMITEND2]() {
-        if (this[DECODER]) {
-          const data = this[DECODER].end();
-          if (data) {
-            for (const p of this[PIPES]) {
-              p.dest.write(data);
-            }
-            if (!this[DISCARDED])
-              super.emit("data", data);
-          }
-        }
-        for (const p of this[PIPES]) {
-          p.end();
-        }
-        const ret = super.emit("end");
-        this.removeAllListeners("end");
-        return ret;
+      get name() {
+        return "CwdError";
       }
-      /**
-       * Return a Promise that resolves to an array of all emitted data once
-       * the stream ends.
-       */
-      async collect() {
-        const buf = Object.assign([], {
-          dataLength: 0
-        });
-        if (!this[OBJECTMODE])
-          buf.dataLength = 0;
-        const p = this.promise();
-        this.on("data", (c) => {
-          buf.push(c);
-          if (!this[OBJECTMODE])
-            buf.dataLength += c.length;
-        });
-        await p;
-        return buf;
-      }
-      /**
-       * Return a Promise that resolves to the concatenation of all emitted data
-       * once the stream ends.
-       *
-       * Not allowed on objectMode streams.
-       */
-      async concat() {
-        if (this[OBJECTMODE]) {
-          throw new Error("cannot concat in objectMode");
-        }
-        const buf = await this.collect();
-        return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
-      }
-      /**
-       * Return a void Promise that resolves once the stream ends.
-       */
-      async promise() {
-        return new Promise((resolve, reject) => {
-          this.on(DESTROYED, () => reject(new Error("stream destroyed")));
-          this.on("error", (er) => reject(er));
-          this.on("end", () => resolve());
-        });
-      }
-      /**
-       * Asynchronous `for await of` iteration.
-       *
-       * This will continue emitting all chunks until the stream terminates.
-       */
-      [Symbol.asyncIterator]() {
-        this[DISCARDED] = false;
-        let stopped = false;
-        const stop = async () => {
-          this.pause();
-          stopped = true;
-          return { value: void 0, done: true };
-        };
-        const next = () => {
-          if (stopped)
-            return stop();
-          const res = this.read();
-          if (res !== null)
-            return Promise.resolve({ done: false, value: res });
-          if (this[EOF])
-            return stop();
-          let resolve;
-          let reject;
-          const onerr = (er) => {
-            this.off("data", ondata);
-            this.off("end", onend);
-            this.off(DESTROYED, ondestroy);
-            stop();
-            reject(er);
-          };
-          const ondata = (value) => {
-            this.off("error", onerr);
-            this.off("end", onend);
-            this.off(DESTROYED, ondestroy);
-            this.pause();
-            resolve({ value, done: !!this[EOF] });
-          };
-          const onend = () => {
-            this.off("error", onerr);
-            this.off("data", ondata);
-            this.off(DESTROYED, ondestroy);
-            stop();
-            resolve({ done: true, value: void 0 });
-          };
-          const ondestroy = () => onerr(new Error("stream destroyed"));
-          return new Promise((res2, rej) => {
-            reject = rej;
-            resolve = res2;
-            this.once(DESTROYED, ondestroy);
-            this.once("error", onerr);
-            this.once("end", onend);
-            this.once("data", ondata);
-          });
-        };
-        return {
-          next,
-          throw: stop,
-          return: stop,
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-      }
-      /**
-       * Synchronous `for of` iteration.
-       *
-       * The iteration will terminate when the internal buffer runs out, even
-       * if the stream has not yet terminated.
-       */
-      [Symbol.iterator]() {
-        this[DISCARDED] = false;
-        let stopped = false;
-        const stop = () => {
-          this.pause();
-          this.off(ERROR, stop);
-          this.off(DESTROYED, stop);
-          this.off("end", stop);
-          stopped = true;
-          return { done: true, value: void 0 };
-        };
-        const next = () => {
-          if (stopped)
-            return stop();
-          const value = this.read();
-          return value === null ? stop() : { done: false, value };
-        };
-        this.once("end", stop);
-        this.once(ERROR, stop);
-        this.once(DESTROYED, stop);
-        return {
-          next,
-          throw: stop,
-          return: stop,
-          [Symbol.iterator]() {
-            return this;
-          }
-        };
-      }
-      /**
-       * Destroy a stream, preventing it from being used for any further purpose.
-       *
-       * If the stream has a `close()` method, then it will be called on
-       * destruction.
-       *
-       * After destruction, any attempt to write data, read data, or emit most
-       * events will be ignored.
-       *
-       * If an error argument is provided, then it will be emitted in an
-       * 'error' event.
-       */
-      destroy(er) {
-        if (this[DESTROYED]) {
-          if (er)
-            this.emit("error", er);
-          else
-            this.emit(DESTROYED);
-          return this;
-        }
-        this[DESTROYED] = true;
-        this[DISCARDED] = true;
-        this[BUFFER].length = 0;
-        this[BUFFERLENGTH] = 0;
-        const wc = this;
-        if (typeof wc.close === "function" && !this[CLOSED])
-          wc.close();
-        if (er)
-          this.emit("error", er);
-        else
-          this.emit(DESTROYED);
-        return this;
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/symlink-error.js
+var SymlinkError;
+var init_symlink_error = __esm({
+  "node_modules/tar/dist/esm/symlink-error.js"() {
+    SymlinkError = class extends Error {
+      path;
+      symlink;
+      syscall = "symlink";
+      code = "TAR_SYMLINK_ERROR";
+      constructor(symlink, path16) {
+        super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link");
+        this.symlink = symlink;
+        this.path = path16;
       }
-      /**
-       * Alias for {@link isStream}
-       *
-       * Former export location, maintained for backwards compatibility.
-       *
-       * @deprecated
-       */
-      static get isStream() {
-        return isStream;
+      get name() {
+        return "SymlinkError";
       }
     };
   }
 });
 
-// .yarn/cache/@isaacs-fs-minipass-npm-4.0.1-677026e841-c25b6dc159.zip/node_modules/@isaacs/fs-minipass/dist/esm/index.js
-var import_events2, import_fs2, writev, _autoClose, _close, _ended, _fd, _finished, _flags, _flush, _handleChunk, _makeBuf, _mode, _needDrain, _onerror, _onopen, _onread, _onwrite, _open, _path, _pos, _queue, _read, _readSize, _reading, _remain, _size, _write, _writing, _defaultFlag, _errored, ReadStream, ReadStreamSync, WriteStream, WriteStreamSync;
-var init_esm2 = __esm({
-  ".yarn/cache/@isaacs-fs-minipass-npm-4.0.1-677026e841-c25b6dc159.zip/node_modules/@isaacs/fs-minipass/dist/esm/index.js"() {
-    import_events2 = __toESM(require("events"), 1);
-    import_fs2 = __toESM(require("fs"), 1);
-    init_esm();
-    writev = import_fs2.default.writev;
-    _autoClose = /* @__PURE__ */ Symbol("_autoClose");
-    _close = /* @__PURE__ */ Symbol("_close");
-    _ended = /* @__PURE__ */ Symbol("_ended");
-    _fd = /* @__PURE__ */ Symbol("_fd");
-    _finished = /* @__PURE__ */ Symbol("_finished");
-    _flags = /* @__PURE__ */ Symbol("_flags");
-    _flush = /* @__PURE__ */ Symbol("_flush");
-    _handleChunk = /* @__PURE__ */ Symbol("_handleChunk");
-    _makeBuf = /* @__PURE__ */ Symbol("_makeBuf");
-    _mode = /* @__PURE__ */ Symbol("_mode");
-    _needDrain = /* @__PURE__ */ Symbol("_needDrain");
-    _onerror = /* @__PURE__ */ Symbol("_onerror");
-    _onopen = /* @__PURE__ */ Symbol("_onopen");
-    _onread = /* @__PURE__ */ Symbol("_onread");
-    _onwrite = /* @__PURE__ */ Symbol("_onwrite");
-    _open = /* @__PURE__ */ Symbol("_open");
-    _path = /* @__PURE__ */ Symbol("_path");
-    _pos = /* @__PURE__ */ Symbol("_pos");
-    _queue = /* @__PURE__ */ Symbol("_queue");
-    _read = /* @__PURE__ */ Symbol("_read");
-    _readSize = /* @__PURE__ */ Symbol("_readSize");
-    _reading = /* @__PURE__ */ Symbol("_reading");
-    _remain = /* @__PURE__ */ Symbol("_remain");
-    _size = /* @__PURE__ */ Symbol("_size");
-    _write = /* @__PURE__ */ Symbol("_write");
-    _writing = /* @__PURE__ */ Symbol("_writing");
-    _defaultFlag = /* @__PURE__ */ Symbol("_defaultFlag");
-    _errored = /* @__PURE__ */ Symbol("_errored");
-    ReadStream = class extends Minipass {
-      [_errored] = false;
-      [_fd];
-      [_path];
-      [_readSize];
-      [_reading] = false;
-      [_size];
-      [_remain];
-      [_autoClose];
-      constructor(path16, opt) {
-        opt = opt || {};
-        super(opt);
-        this.readable = true;
-        this.writable = false;
-        if (typeof path16 !== "string") {
-          throw new TypeError("path must be a string");
+// node_modules/tar/dist/esm/mkdir.js
+var import_node_fs3, import_promises, import_node_path4, checkCwd, mkdir, mkdir_, onmkdir, checkCwdSync, mkdirSync2;
+var init_mkdir = __esm({
+  "node_modules/tar/dist/esm/mkdir.js"() {
+    init_esm4();
+    import_node_fs3 = __toESM(require("node:fs"), 1);
+    import_promises = __toESM(require("node:fs/promises"), 1);
+    import_node_path4 = __toESM(require("node:path"), 1);
+    init_cwd_error();
+    init_normalize_windows_path();
+    init_symlink_error();
+    checkCwd = (dir, cb) => {
+      import_node_fs3.default.stat(dir, (er, st) => {
+        if (er || !st.isDirectory()) {
+          er = new CwdError(dir, er?.code || "ENOTDIR");
         }
-        this[_errored] = false;
-        this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
-        this[_path] = path16;
-        this[_readSize] = opt.readSize || 16 * 1024 * 1024;
-        this[_reading] = false;
-        this[_size] = typeof opt.size === "number" ? opt.size : Infinity;
-        this[_remain] = this[_size];
-        this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
-        if (typeof this[_fd] === "number") {
-          this[_read]();
-        } else {
-          this[_open]();
-        }
-      }
-      get fd() {
-        return this[_fd];
-      }
-      get path() {
-        return this[_path];
-      }
-      //@ts-ignore
-      write() {
-        throw new TypeError("this is a readable stream");
-      }
-      //@ts-ignore
-      end() {
-        throw new TypeError("this is a readable stream");
-      }
-      [_open]() {
-        import_fs2.default.open(this[_path], "r", (er, fd) => this[_onopen](er, fd));
-      }
-      [_onopen](er, fd) {
+        cb(er);
+      });
+    };
+    mkdir = (dir, opt, cb) => {
+      dir = normalizeWindowsPath(dir);
+      const umask2 = opt.umask ?? 18;
+      const mode = opt.mode | 448;
+      const needChmod = (mode & umask2) !== 0;
+      const uid = opt.uid;
+      const gid = opt.gid;
+      const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+      const preserve = opt.preserve;
+      const unlink = opt.unlink;
+      const cwd = normalizeWindowsPath(opt.cwd);
+      const done = (er, created) => {
         if (er) {
-          this[_onerror](er);
+          cb(er);
         } else {
-          this[_fd] = fd;
-          this.emit("open", fd);
-          this[_read]();
-        }
-      }
-      [_makeBuf]() {
-        return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain]));
-      }
-      [_read]() {
-        if (!this[_reading]) {
-          this[_reading] = true;
-          const buf = this[_makeBuf]();
-          if (buf.length === 0) {
-            return process.nextTick(() => this[_onread](null, 0, buf));
+          if (created && doChown) {
+            chownr(created, uid, gid, (er2) => done(er2));
+          } else if (needChmod) {
+            import_node_fs3.default.chmod(dir, mode, cb);
+          } else {
+            cb();
           }
-          import_fs2.default.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b));
-        }
-      }
-      [_onread](er, br, buf) {
-        this[_reading] = false;
-        if (er) {
-          this[_onerror](er);
-        } else if (this[_handleChunk](br, buf)) {
-          this[_read]();
         }
+      };
+      if (dir === cwd) {
+        return checkCwd(dir, done);
       }
-      [_close]() {
-        if (this[_autoClose] && typeof this[_fd] === "number") {
-          const fd = this[_fd];
-          this[_fd] = void 0;
-          import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
-        }
+      if (preserve) {
+        return import_promises.default.mkdir(dir, { mode, recursive: true }).then(
+          (made) => done(null, made ?? void 0),
+          // oh, ts
+          done
+        );
       }
-      [_onerror](er) {
-        this[_reading] = true;
-        this[_close]();
-        this.emit("error", er);
+      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
+      const parts = sub.split("/");
+      mkdir_(cwd, parts, mode, unlink, cwd, void 0, done);
+    };
+    mkdir_ = (base, parts, mode, unlink, cwd, created, cb) => {
+      if (parts.length === 0) {
+        return cb(null, created);
       }
-      [_handleChunk](br, buf) {
-        let ret = false;
-        this[_remain] -= br;
-        if (br > 0) {
-          ret = super.write(br < buf.length ? buf.subarray(0, br) : buf);
-        }
-        if (br === 0 || this[_remain] <= 0) {
-          ret = false;
-          this[_close]();
-          super.end();
-        }
-        return ret;
+      const p = parts.shift();
+      const part = normalizeWindowsPath(import_node_path4.default.resolve(base + "/" + p));
+      import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+    };
+    onmkdir = (part, parts, mode, unlink, cwd, created, cb) => (er) => {
+      if (er) {
+        import_node_fs3.default.lstat(part, (statEr, st) => {
+          if (statEr) {
+            statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
+            cb(statEr);
+          } else if (st.isDirectory()) {
+            mkdir_(part, parts, mode, unlink, cwd, created, cb);
+          } else if (unlink) {
+            import_node_fs3.default.unlink(part, (er2) => {
+              if (er2) {
+                return cb(er2);
+              }
+              import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+            });
+          } else if (st.isSymbolicLink()) {
+            return cb(new SymlinkError(part, part + "/" + parts.join("/")));
+          } else {
+            cb(er);
+          }
+        });
+      } else {
+        created = created || part;
+        mkdir_(part, parts, mode, unlink, cwd, created, cb);
       }
-      emit(ev, ...args) {
-        switch (ev) {
-          case "prefinish":
-          case "finish":
-            return false;
-          case "drain":
-            if (typeof this[_fd] === "number") {
-              this[_read]();
-            }
-            return false;
-          case "error":
-            if (this[_errored]) {
-              return false;
-            }
-            this[_errored] = true;
-            return super.emit(ev, ...args);
-          default:
-            return super.emit(ev, ...args);
+    };
+    checkCwdSync = (dir) => {
+      let ok = false;
+      let code2;
+      try {
+        ok = import_node_fs3.default.statSync(dir).isDirectory();
+      } catch (er) {
+        code2 = er?.code;
+      } finally {
+        if (!ok) {
+          throw new CwdError(dir, code2 ?? "ENOTDIR");
         }
       }
     };
-    ReadStreamSync = class extends ReadStream {
-      [_open]() {
-        let threw = true;
-        try {
-          this[_onopen](null, import_fs2.default.openSync(this[_path], "r"));
-          threw = false;
-        } finally {
-          if (threw) {
-            this[_close]();
-          }
+    mkdirSync2 = (dir, opt) => {
+      dir = normalizeWindowsPath(dir);
+      const umask2 = opt.umask ?? 18;
+      const mode = opt.mode | 448;
+      const needChmod = (mode & umask2) !== 0;
+      const uid = opt.uid;
+      const gid = opt.gid;
+      const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
+      const preserve = opt.preserve;
+      const unlink = opt.unlink;
+      const cwd = normalizeWindowsPath(opt.cwd);
+      const done = (created2) => {
+        if (created2 && doChown) {
+          chownrSync(created2, uid, gid);
+        }
+        if (needChmod) {
+          import_node_fs3.default.chmodSync(dir, mode);
         }
+      };
+      if (dir === cwd) {
+        checkCwdSync(cwd);
+        return done();
       }
-      [_read]() {
-        let threw = true;
+      if (preserve) {
+        return done(import_node_fs3.default.mkdirSync(dir, { mode, recursive: true }) ?? void 0);
+      }
+      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
+      const parts = sub.split("/");
+      let created;
+      for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) {
+        part = normalizeWindowsPath(import_node_path4.default.resolve(part));
         try {
-          if (!this[_reading]) {
-            this[_reading] = true;
-            do {
-              const buf = this[_makeBuf]();
-              const br = buf.length === 0 ? 0 : import_fs2.default.readSync(this[_fd], buf, 0, buf.length, null);
-              if (!this[_handleChunk](br, buf)) {
-                break;
-              }
-            } while (true);
-            this[_reading] = false;
-          }
-          threw = false;
-        } finally {
-          if (threw) {
-            this[_close]();
+          import_node_fs3.default.mkdirSync(part, mode);
+          created = created || part;
+        } catch {
+          const st = import_node_fs3.default.lstatSync(part);
+          if (st.isDirectory()) {
+            continue;
+          } else if (unlink) {
+            import_node_fs3.default.unlinkSync(part);
+            import_node_fs3.default.mkdirSync(part, mode);
+            created = created || part;
+            continue;
+          } else if (st.isSymbolicLink()) {
+            return new SymlinkError(part, part + "/" + parts.join("/"));
           }
         }
       }
-      [_close]() {
-        if (this[_autoClose] && typeof this[_fd] === "number") {
-          const fd = this[_fd];
-          this[_fd] = void 0;
-          import_fs2.default.closeSync(fd);
-          this.emit("close");
-        }
-      }
+      return done(created);
     };
-    WriteStream = class extends import_events2.default {
-      readable = false;
-      writable = true;
-      [_errored] = false;
-      [_writing] = false;
-      [_ended] = false;
-      [_queue] = [];
-      [_needDrain] = false;
-      [_path];
-      [_mode];
-      [_autoClose];
-      [_fd];
-      [_defaultFlag];
-      [_flags];
-      [_finished] = false;
-      [_pos];
-      constructor(path16, opt) {
-        opt = opt || {};
-        super(opt);
-        this[_path] = path16;
-        this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0;
-        this[_mode] = opt.mode === void 0 ? 438 : opt.mode;
-        this[_pos] = typeof opt.start === "number" ? opt.start : void 0;
-        this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true;
-        const defaultFlag = this[_pos] !== void 0 ? "r+" : "w";
-        this[_defaultFlag] = opt.flags === void 0;
-        this[_flags] = opt.flags === void 0 ? defaultFlag : opt.flags;
-        if (this[_fd] === void 0) {
-          this[_open]();
+  }
+});
+
+// node_modules/tar/dist/esm/strip-absolute-path.js
+var import_node_path5, isAbsolute, parse3, stripAbsolutePath;
+var init_strip_absolute_path = __esm({
+  "node_modules/tar/dist/esm/strip-absolute-path.js"() {
+    import_node_path5 = require("node:path");
+    ({ isAbsolute, parse: parse3 } = import_node_path5.win32);
+    stripAbsolutePath = (path16) => {
+      let r = "";
+      let parsed = parse3(path16);
+      while (isAbsolute(path16) || parsed.root) {
+        const root = path16.charAt(0) === "/" && path16.slice(0, 4) !== "//?/" ? "/" : parsed.root;
+        path16 = path16.slice(root.length);
+        r += root;
+        parsed = parse3(path16);
+      }
+      return [r, path16];
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/winchars.js
+var raw, win, toWin, toRaw, encode2, decode;
+var init_winchars = __esm({
+  "node_modules/tar/dist/esm/winchars.js"() {
+    raw = ["|", "<", ">", "?", ":"];
+    win = raw.map((char) => String.fromCodePoint(61440 + Number(char.codePointAt(0))));
+    toWin = new Map(raw.map((char, i) => [char, win[i]]));
+    toRaw = new Map(win.map((char, i) => [char, raw[i]]));
+    encode2 = (s) => raw.reduce((s2, c) => s2.split(c).join(toWin.get(c)), s);
+    decode = (s) => win.reduce((s2, c) => s2.split(c).join(toRaw.get(c)), s);
+  }
+});
+
+// node_modules/tar/dist/esm/normalize-unicode.js
+var normalizeCache, MAX, cache, normalizeUnicode;
+var init_normalize_unicode = __esm({
+  "node_modules/tar/dist/esm/normalize-unicode.js"() {
+    normalizeCache = /* @__PURE__ */ Object.create(null);
+    MAX = 1e4;
+    cache = /* @__PURE__ */ new Set();
+    normalizeUnicode = (s) => {
+      if (!cache.has(s)) {
+        normalizeCache[s] = s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en");
+      } else {
+        cache.delete(s);
+      }
+      cache.add(s);
+      const ret = normalizeCache[s];
+      let i = cache.size - MAX;
+      if (i > MAX / 10) {
+        for (const s2 of cache) {
+          cache.delete(s2);
+          delete normalizeCache[s2];
+          if (--i <= 0)
+            break;
         }
       }
-      emit(ev, ...args) {
-        if (ev === "error") {
-          if (this[_errored]) {
-            return false;
+      return ret;
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/path-reservations.js
+var import_node_path6, platform3, isWindows2, getDirs, PathReservations;
+var init_path_reservations = __esm({
+  "node_modules/tar/dist/esm/path-reservations.js"() {
+    import_node_path6 = require("node:path");
+    init_normalize_unicode();
+    init_strip_trailing_slashes();
+    platform3 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+    isWindows2 = platform3 === "win32";
+    getDirs = (path16) => {
+      const dirs = path16.split("/").slice(0, -1).reduce((set, path17) => {
+        const s = set.at(-1);
+        if (s !== void 0) {
+          path17 = (0, import_node_path6.join)(s, path17);
+        }
+        set.push(path17 || "/");
+        return set;
+      }, []);
+      return dirs;
+    };
+    PathReservations = class {
+      // path => [function or Set]
+      // A Set object means a directory reservation
+      // A fn is a direct reservation on that path
+      #queues = /* @__PURE__ */ new Map();
+      // fn => {paths:[path,...], dirs:[path, ...]}
+      #reservations = /* @__PURE__ */ new Map();
+      // functions currently running
+      #running = /* @__PURE__ */ new Set();
+      reserve(paths, fn2) {
+        paths = isWindows2 ? ["win32 parallelization disabled"] : paths.map((p) => {
+          return stripTrailingSlashes((0, import_node_path6.join)(normalizeUnicode(p)));
+        });
+        const dirs = new Set(paths.map((path16) => getDirs(path16)).reduce((a, b) => a.concat(b)));
+        this.#reservations.set(fn2, { dirs, paths });
+        for (const p of paths) {
+          const q = this.#queues.get(p);
+          if (!q) {
+            this.#queues.set(p, [fn2]);
+          } else {
+            q.push(fn2);
           }
-          this[_errored] = true;
         }
-        return super.emit(ev, ...args);
-      }
-      get fd() {
-        return this[_fd];
-      }
-      get path() {
-        return this[_path];
-      }
-      [_onerror](er) {
-        this[_close]();
-        this[_writing] = true;
-        this.emit("error", er);
-      }
-      [_open]() {
-        import_fs2.default.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd));
-      }
-      [_onopen](er, fd) {
-        if (this[_defaultFlag] && this[_flags] === "r+" && er && er.code === "ENOENT") {
-          this[_flags] = "w";
-          this[_open]();
-        } else if (er) {
-          this[_onerror](er);
-        } else {
-          this[_fd] = fd;
-          this.emit("open", fd);
-          if (!this[_writing]) {
-            this[_flush]();
+        for (const dir of dirs) {
+          const q = this.#queues.get(dir);
+          if (!q) {
+            this.#queues.set(dir, [/* @__PURE__ */ new Set([fn2])]);
+          } else {
+            const l = q.at(-1);
+            if (l instanceof Set) {
+              l.add(fn2);
+            } else {
+              q.push(/* @__PURE__ */ new Set([fn2]));
+            }
           }
         }
+        return this.#run(fn2);
       }
-      end(buf, enc) {
-        if (buf) {
-          this.write(buf, enc);
-        }
-        this[_ended] = true;
-        if (!this[_writing] && !this[_queue].length && typeof this[_fd] === "number") {
-          this[_onwrite](null, 0);
+      // return the queues for each path the function cares about
+      // fn => {paths, dirs}
+      #getQueues(fn2) {
+        const res = this.#reservations.get(fn2);
+        if (!res) {
+          throw new Error("function does not have any path reservations");
         }
-        return this;
+        return {
+          paths: res.paths.map((path16) => this.#queues.get(path16)),
+          dirs: [...res.dirs].map((path16) => this.#queues.get(path16))
+        };
       }
-      write(buf, enc) {
-        if (typeof buf === "string") {
-          buf = Buffer.from(buf, enc);
-        }
-        if (this[_ended]) {
-          this.emit("error", new Error("write() after end()"));
-          return false;
-        }
-        if (this[_fd] === void 0 || this[_writing] || this[_queue].length) {
-          this[_queue].push(buf);
-          this[_needDrain] = true;
+      // check if fn is first in line for all its paths, and is
+      // included in the first set for all its dir queues
+      check(fn2) {
+        const { paths, dirs } = this.#getQueues(fn2);
+        return paths.every((q) => q && q[0] === fn2) && dirs.every((q) => q && q[0] instanceof Set && q[0].has(fn2));
+      }
+      // run the function if it's first in line and not already running
+      #run(fn2) {
+        if (this.#running.has(fn2) || !this.check(fn2)) {
           return false;
         }
-        this[_writing] = true;
-        this[_write](buf);
+        this.#running.add(fn2);
+        fn2(() => this.#clear(fn2));
         return true;
       }
-      [_write](buf) {
-        import_fs2.default.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw));
-      }
-      [_onwrite](er, bw) {
-        if (er) {
-          this[_onerror](er);
-        } else {
-          if (this[_pos] !== void 0 && typeof bw === "number") {
-            this[_pos] += bw;
+      #clear(fn2) {
+        if (!this.#running.has(fn2)) {
+          return false;
+        }
+        const res = this.#reservations.get(fn2);
+        if (!res) {
+          throw new Error("invalid reservation");
+        }
+        const { paths, dirs } = res;
+        const next = /* @__PURE__ */ new Set();
+        for (const path16 of paths) {
+          const q = this.#queues.get(path16);
+          if (!q || q?.[0] !== fn2) {
+            continue;
           }
-          if (this[_queue].length) {
-            this[_flush]();
+          const q0 = q[1];
+          if (!q0) {
+            this.#queues.delete(path16);
+            continue;
+          }
+          q.shift();
+          if (typeof q0 === "function") {
+            next.add(q0);
           } else {
-            this[_writing] = false;
-            if (this[_ended] && !this[_finished]) {
-              this[_finished] = true;
-              this[_close]();
-              this.emit("finish");
-            } else if (this[_needDrain]) {
-              this[_needDrain] = false;
-              this.emit("drain");
+            for (const f of q0) {
+              next.add(f);
             }
           }
         }
-      }
-      [_flush]() {
-        if (this[_queue].length === 0) {
-          if (this[_ended]) {
-            this[_onwrite](null, 0);
-          }
-        } else if (this[_queue].length === 1) {
-          this[_write](this[_queue].pop());
-        } else {
-          const iovec = this[_queue];
-          this[_queue] = [];
-          writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw));
-        }
-      }
-      [_close]() {
-        if (this[_autoClose] && typeof this[_fd] === "number") {
-          const fd = this[_fd];
-          this[_fd] = void 0;
-          import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close"));
-        }
-      }
-    };
-    WriteStreamSync = class extends WriteStream {
-      [_open]() {
-        let fd;
-        if (this[_defaultFlag] && this[_flags] === "r+") {
-          try {
-            fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
-          } catch (er) {
-            if (er?.code === "ENOENT") {
-              this[_flags] = "w";
-              return this[_open]();
-            } else {
-              throw er;
-            }
-          }
-        } else {
-          fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]);
-        }
-        this[_onopen](null, fd);
-      }
-      [_close]() {
-        if (this[_autoClose] && typeof this[_fd] === "number") {
-          const fd = this[_fd];
-          this[_fd] = void 0;
-          import_fs2.default.closeSync(fd);
-          this.emit("close");
-        }
-      }
-      [_write](buf) {
-        let threw = true;
-        try {
-          this[_onwrite](null, import_fs2.default.writeSync(this[_fd], buf, 0, buf.length, this[_pos]));
-          threw = false;
-        } finally {
-          if (threw) {
-            try {
-              this[_close]();
-            } catch {
+        for (const dir of dirs) {
+          const q = this.#queues.get(dir);
+          const q0 = q?.[0];
+          if (!q || !(q0 instanceof Set))
+            continue;
+          if (q0.size === 1 && q.length === 1) {
+            this.#queues.delete(dir);
+            continue;
+          } else if (q0.size === 1) {
+            q.shift();
+            const n = q[0];
+            if (typeof n === "function") {
+              next.add(n);
             }
+          } else {
+            q0.delete(fn2);
           }
         }
+        this.#running.delete(fn2);
+        next.forEach((fn3) => this.#run(fn3));
+        return true;
       }
     };
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/options.js
-var argmap, isSyncFile, isAsyncFile, isSyncNoFile, isAsyncNoFile, dealiasKey, dealias;
-var init_options = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/options.js"() {
-    argmap = /* @__PURE__ */ new Map([
-      ["C", "cwd"],
-      ["f", "file"],
-      ["z", "gzip"],
-      ["P", "preservePaths"],
-      ["U", "unlink"],
-      ["strip-components", "strip"],
-      ["stripComponents", "strip"],
-      ["keep-newer", "newer"],
-      ["keepNewer", "newer"],
-      ["keep-newer-files", "newer"],
-      ["keepNewerFiles", "newer"],
-      ["k", "keep"],
-      ["keep-existing", "keep"],
-      ["keepExisting", "keep"],
-      ["m", "noMtime"],
-      ["no-mtime", "noMtime"],
-      ["p", "preserveOwner"],
-      ["L", "follow"],
-      ["h", "follow"],
-      ["onentry", "onReadEntry"]
-    ]);
-    isSyncFile = (o) => !!o.sync && !!o.file;
-    isAsyncFile = (o) => !o.sync && !!o.file;
-    isSyncNoFile = (o) => !!o.sync && !o.file;
-    isAsyncNoFile = (o) => !o.sync && !o.file;
-    dealiasKey = (k) => {
-      const d = argmap.get(k);
-      if (d)
-        return d;
-      return k;
-    };
-    dealias = (opt = {}) => {
-      if (!opt)
-        return {};
-      const result = {};
-      for (const [key, v] of Object.entries(opt)) {
-        const k = dealiasKey(key);
-        result[k] = v;
-      }
-      if (result.chmod === void 0 && result.noChmod === false) {
-        result.chmod = true;
-      }
-      delete result.noChmod;
-      return result;
-    };
+// node_modules/tar/dist/esm/process-umask.js
+var umask;
+var init_process_umask = __esm({
+  "node_modules/tar/dist/esm/process-umask.js"() {
+    umask = () => process.umask();
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/make-command.js
-var makeCommand;
-var init_make_command = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/make-command.js"() {
-    init_options();
-    makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => {
-      return Object.assign((opt_ = [], entries, cb) => {
-        if (Array.isArray(opt_)) {
-          entries = opt_;
-          opt_ = {};
-        }
-        if (typeof entries === "function") {
-          cb = entries;
-          entries = void 0;
-        }
-        entries = !entries ? [] : Array.from(entries);
-        const opt = dealias(opt_);
-        validate?.(opt, entries);
-        if (isSyncFile(opt)) {
-          if (typeof cb === "function") {
-            throw new TypeError("callback not supported for sync tar functions");
-          }
-          return syncFile(opt, entries);
-        } else if (isAsyncFile(opt)) {
-          const p = asyncFile(opt, entries);
-          return cb ? p.then(() => cb(), cb) : p;
-        } else if (isSyncNoFile(opt)) {
-          if (typeof cb === "function") {
-            throw new TypeError("callback not supported for sync tar functions");
-          }
-          return syncNoFile(opt, entries);
-        } else if (isAsyncNoFile(opt)) {
-          if (typeof cb === "function") {
-            throw new TypeError("callback only supported with file option");
-          }
-          return asyncNoFile(opt, entries);
+// node_modules/tar/dist/esm/unpack.js
+var import_node_assert, import_node_crypto, import_node_fs4, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, ENSURE_NO_SYMLINK, UNSUPPORTED, CHECKPATH, STRIPABSOLUTEPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform4, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, Unpack, callSync, UnpackSync;
+var init_unpack = __esm({
+  "node_modules/tar/dist/esm/unpack.js"() {
+    init_esm2();
+    import_node_assert = __toESM(require("node:assert"), 1);
+    import_node_crypto = require("node:crypto");
+    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_path7 = __toESM(require("node:path"), 1);
+    init_get_write_flag();
+    init_mkdir();
+    init_normalize_windows_path();
+    init_parse();
+    init_strip_absolute_path();
+    init_winchars();
+    init_path_reservations();
+    init_symlink_error();
+    init_process_umask();
+    ONENTRY = /* @__PURE__ */ Symbol("onEntry");
+    CHECKFS = /* @__PURE__ */ Symbol("checkFs");
+    CHECKFS2 = /* @__PURE__ */ Symbol("checkFs2");
+    ISREUSABLE = /* @__PURE__ */ Symbol("isReusable");
+    MAKEFS = /* @__PURE__ */ Symbol("makeFs");
+    FILE = /* @__PURE__ */ Symbol("file");
+    DIRECTORY = /* @__PURE__ */ Symbol("directory");
+    LINK = /* @__PURE__ */ Symbol("link");
+    SYMLINK = /* @__PURE__ */ Symbol("symlink");
+    HARDLINK = /* @__PURE__ */ Symbol("hardlink");
+    ENSURE_NO_SYMLINK = /* @__PURE__ */ Symbol("ensureNoSymlink");
+    UNSUPPORTED = /* @__PURE__ */ Symbol("unsupported");
+    CHECKPATH = /* @__PURE__ */ Symbol("checkPath");
+    STRIPABSOLUTEPATH = /* @__PURE__ */ Symbol("stripAbsolutePath");
+    MKDIR = /* @__PURE__ */ Symbol("mkdir");
+    ONERROR = /* @__PURE__ */ Symbol("onError");
+    PENDING = /* @__PURE__ */ Symbol("pending");
+    PEND = /* @__PURE__ */ Symbol("pend");
+    UNPEND = /* @__PURE__ */ Symbol("unpend");
+    ENDED2 = /* @__PURE__ */ Symbol("ended");
+    MAYBECLOSE = /* @__PURE__ */ Symbol("maybeClose");
+    SKIP = /* @__PURE__ */ Symbol("skip");
+    DOCHOWN = /* @__PURE__ */ Symbol("doChown");
+    UID = /* @__PURE__ */ Symbol("uid");
+    GID = /* @__PURE__ */ Symbol("gid");
+    CHECKED_CWD = /* @__PURE__ */ Symbol("checkedCwd");
+    platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+    isWindows3 = platform4 === "win32";
+    DEFAULT_MAX_DEPTH = 1024;
+    unlinkFile = (path16, cb) => {
+      if (!isWindows3) {
+        return import_node_fs4.default.unlink(path16, cb);
+      }
+      const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex");
+      import_node_fs4.default.rename(path16, name2, (er) => {
+        if (er) {
+          return cb(er);
         }
-        throw new Error("impossible options??");
-      }, {
-        syncFile,
-        asyncFile,
-        syncNoFile,
-        asyncNoFile,
-        validate
+        import_node_fs4.default.unlink(name2, cb);
       });
     };
-  }
-});
-
-// .yarn/cache/minizlib-npm-3.1.0-6680befdba-5aad75ab00.zip/node_modules/minizlib/dist/esm/constants.js
-var import_zlib, realZlibConstants, constants;
-var init_constants = __esm({
-  ".yarn/cache/minizlib-npm-3.1.0-6680befdba-5aad75ab00.zip/node_modules/minizlib/dist/esm/constants.js"() {
-    import_zlib = __toESM(require("zlib"), 1);
-    realZlibConstants = import_zlib.default.constants || { ZLIB_VERNUM: 4736 };
-    constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
-      Z_NO_FLUSH: 0,
-      Z_PARTIAL_FLUSH: 1,
-      Z_SYNC_FLUSH: 2,
-      Z_FULL_FLUSH: 3,
-      Z_FINISH: 4,
-      Z_BLOCK: 5,
-      Z_OK: 0,
-      Z_STREAM_END: 1,
-      Z_NEED_DICT: 2,
-      Z_ERRNO: -1,
-      Z_STREAM_ERROR: -2,
-      Z_DATA_ERROR: -3,
-      Z_MEM_ERROR: -4,
-      Z_BUF_ERROR: -5,
-      Z_VERSION_ERROR: -6,
-      Z_NO_COMPRESSION: 0,
-      Z_BEST_SPEED: 1,
-      Z_BEST_COMPRESSION: 9,
-      Z_DEFAULT_COMPRESSION: -1,
-      Z_FILTERED: 1,
-      Z_HUFFMAN_ONLY: 2,
-      Z_RLE: 3,
-      Z_FIXED: 4,
-      Z_DEFAULT_STRATEGY: 0,
-      DEFLATE: 1,
-      INFLATE: 2,
-      GZIP: 3,
-      GUNZIP: 4,
-      DEFLATERAW: 5,
-      INFLATERAW: 6,
-      UNZIP: 7,
-      BROTLI_DECODE: 8,
-      BROTLI_ENCODE: 9,
-      Z_MIN_WINDOWBITS: 8,
-      Z_MAX_WINDOWBITS: 15,
-      Z_DEFAULT_WINDOWBITS: 15,
-      Z_MIN_CHUNK: 64,
-      Z_MAX_CHUNK: Infinity,
-      Z_DEFAULT_CHUNK: 16384,
-      Z_MIN_MEMLEVEL: 1,
-      Z_MAX_MEMLEVEL: 9,
-      Z_DEFAULT_MEMLEVEL: 8,
-      Z_MIN_LEVEL: -1,
-      Z_MAX_LEVEL: 9,
-      Z_DEFAULT_LEVEL: -1,
-      BROTLI_OPERATION_PROCESS: 0,
-      BROTLI_OPERATION_FLUSH: 1,
-      BROTLI_OPERATION_FINISH: 2,
-      BROTLI_OPERATION_EMIT_METADATA: 3,
-      BROTLI_MODE_GENERIC: 0,
-      BROTLI_MODE_TEXT: 1,
-      BROTLI_MODE_FONT: 2,
-      BROTLI_DEFAULT_MODE: 0,
-      BROTLI_MIN_QUALITY: 0,
-      BROTLI_MAX_QUALITY: 11,
-      BROTLI_DEFAULT_QUALITY: 11,
-      BROTLI_MIN_WINDOW_BITS: 10,
-      BROTLI_MAX_WINDOW_BITS: 24,
-      BROTLI_LARGE_MAX_WINDOW_BITS: 30,
-      BROTLI_DEFAULT_WINDOW: 22,
-      BROTLI_MIN_INPUT_BLOCK_BITS: 16,
-      BROTLI_MAX_INPUT_BLOCK_BITS: 24,
-      BROTLI_PARAM_MODE: 0,
-      BROTLI_PARAM_QUALITY: 1,
-      BROTLI_PARAM_LGWIN: 2,
-      BROTLI_PARAM_LGBLOCK: 3,
-      BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4,
-      BROTLI_PARAM_SIZE_HINT: 5,
-      BROTLI_PARAM_LARGE_WINDOW: 6,
-      BROTLI_PARAM_NPOSTFIX: 7,
-      BROTLI_PARAM_NDIRECT: 8,
-      BROTLI_DECODER_RESULT_ERROR: 0,
-      BROTLI_DECODER_RESULT_SUCCESS: 1,
-      BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2,
-      BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3,
-      BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0,
-      BROTLI_DECODER_PARAM_LARGE_WINDOW: 1,
-      BROTLI_DECODER_NO_ERROR: 0,
-      BROTLI_DECODER_SUCCESS: 1,
-      BROTLI_DECODER_NEEDS_MORE_INPUT: 2,
-      BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3,
-      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1,
-      BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2,
-      BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3,
-      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4,
-      BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5,
-      BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6,
-      BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7,
-      BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8,
-      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9,
-      BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10,
-      BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11,
-      BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12,
-      BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13,
-      BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14,
-      BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15,
-      BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16,
-      BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19,
-      BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20,
-      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21,
-      BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22,
-      BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25,
-      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26,
-      BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27,
-      BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30,
-      BROTLI_DECODER_ERROR_UNREACHABLE: -31
-    }, realZlibConstants));
-  }
-});
-
-// .yarn/cache/minizlib-npm-3.1.0-6680befdba-5aad75ab00.zip/node_modules/minizlib/dist/esm/index.js
-var import_assert2, import_buffer, realZlib2, OriginalBufferConcat, desc, noop, passthroughBufferConcat, _superWrite, ZlibError, _flushFlag, ZlibBase, Zlib, Gzip, Unzip, Brotli, BrotliCompress, BrotliDecompress, Zstd, ZstdCompress, ZstdDecompress;
-var init_esm3 = __esm({
-  ".yarn/cache/minizlib-npm-3.1.0-6680befdba-5aad75ab00.zip/node_modules/minizlib/dist/esm/index.js"() {
-    import_assert2 = __toESM(require("assert"), 1);
-    import_buffer = require("buffer");
-    init_esm();
-    realZlib2 = __toESM(require("zlib"), 1);
-    init_constants();
-    init_constants();
-    OriginalBufferConcat = import_buffer.Buffer.concat;
-    desc = Object.getOwnPropertyDescriptor(import_buffer.Buffer, "concat");
-    noop = (args) => args;
-    passthroughBufferConcat = desc?.writable === true || desc?.set !== void 0 ? (makeNoOp) => {
-      import_buffer.Buffer.concat = makeNoOp ? noop : OriginalBufferConcat;
-    } : (_) => {
-    };
-    _superWrite = /* @__PURE__ */ Symbol("_superWrite");
-    ZlibError = class extends Error {
-      code;
-      errno;
-      constructor(err, origin) {
-        super("zlib: " + err.message, { cause: err });
-        this.code = err.code;
-        this.errno = err.errno;
-        if (!this.code)
-          this.code = "ZLIB_ERROR";
-        this.message = "zlib: " + err.message;
-        Error.captureStackTrace(this, origin ?? this.constructor);
-      }
-      get name() {
-        return "ZlibError";
+    unlinkFileSync = (path16) => {
+      if (!isWindows3) {
+        return import_node_fs4.default.unlinkSync(path16);
       }
+      const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex");
+      import_node_fs4.default.renameSync(path16, name2);
+      import_node_fs4.default.unlinkSync(name2);
     };
-    _flushFlag = /* @__PURE__ */ Symbol("flushFlag");
-    ZlibBase = class extends Minipass {
-      #sawError = false;
-      #ended = false;
-      #flushFlag;
-      #finishFlushFlag;
-      #fullFlushFlag;
-      #handle;
-      #onError;
-      get sawError() {
-        return this.#sawError;
-      }
-      get handle() {
-        return this.#handle;
-      }
-      /* c8 ignore start */
-      get flushFlag() {
-        return this.#flushFlag;
-      }
-      /* c8 ignore stop */
-      constructor(opts, mode) {
-        if (!opts || typeof opts !== "object")
-          throw new TypeError("invalid options for ZlibBase constructor");
-        super(opts);
-        this.#flushFlag = opts.flush ?? 0;
-        this.#finishFlushFlag = opts.finishFlush ?? 0;
-        this.#fullFlushFlag = opts.fullFlushFlag ?? 0;
-        if (typeof realZlib2[mode] !== "function") {
-          throw new TypeError("Compression method not supported: " + mode);
-        }
-        try {
-          this.#handle = new realZlib2[mode](opts);
-        } catch (er) {
-          throw new ZlibError(er, this.constructor);
-        }
-        this.#onError = (err) => {
-          if (this.#sawError)
-            return;
-          this.#sawError = true;
-          this.close();
-          this.emit("error", err);
+    uint32 = (a, b, c) => a !== void 0 && a === a >>> 0 ? a : b !== void 0 && b === b >>> 0 ? b : c;
+    Unpack = class extends Parser {
+      [ENDED2] = false;
+      [CHECKED_CWD] = false;
+      [PENDING] = 0;
+      reservations = new PathReservations();
+      transform;
+      writable = true;
+      readable = false;
+      uid;
+      gid;
+      setOwner;
+      preserveOwner;
+      processGid;
+      processUid;
+      maxDepth;
+      forceChown;
+      win32;
+      newer;
+      keep;
+      noMtime;
+      preservePaths;
+      unlink;
+      cwd;
+      strip;
+      processUmask;
+      umask;
+      dmode;
+      fmode;
+      chmod;
+      constructor(opt = {}) {
+        opt.ondone = () => {
+          this[ENDED2] = true;
+          this[MAYBECLOSE]();
         };
-        this.#handle?.on("error", (er) => this.#onError(new ZlibError(er)));
-        this.once("end", () => this.close);
-      }
-      close() {
-        if (this.#handle) {
-          this.#handle.close();
-          this.#handle = void 0;
-          this.emit("close");
+        super(opt);
+        this.transform = opt.transform;
+        this.chmod = !!opt.chmod;
+        if (typeof opt.uid === "number" || typeof opt.gid === "number") {
+          if (typeof opt.uid !== "number" || typeof opt.gid !== "number") {
+            throw new TypeError("cannot set owner without number uid and gid");
+          }
+          if (opt.preserveOwner) {
+            throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
+          }
+          this.uid = opt.uid;
+          this.gid = opt.gid;
+          this.setOwner = true;
+        } else {
+          this.uid = void 0;
+          this.gid = void 0;
+          this.setOwner = false;
         }
+        this.preserveOwner = opt.preserveOwner === void 0 && typeof opt.uid !== "number" ? !!(process.getuid && process.getuid() === 0) : !!opt.preserveOwner;
+        this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0;
+        this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0;
+        this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH;
+        this.forceChown = opt.forceChown === true;
+        this.win32 = !!opt.win32 || isWindows3;
+        this.newer = !!opt.newer;
+        this.keep = !!opt.keep;
+        this.noMtime = !!opt.noMtime;
+        this.preservePaths = !!opt.preservePaths;
+        this.unlink = !!opt.unlink;
+        this.cwd = normalizeWindowsPath(import_node_path7.default.resolve(opt.cwd || process.cwd()));
+        this.strip = Number(opt.strip) || 0;
+        this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : umask();
+        this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask;
+        this.dmode = opt.dmode || 511 & ~this.umask;
+        this.fmode = opt.fmode || 438 & ~this.umask;
+        this.on("entry", (entry) => this[ONENTRY](entry));
       }
-      reset() {
-        if (!this.#sawError) {
-          (0, import_assert2.default)(this.#handle, "zlib binding closed");
-          return this.#handle.reset?.();
+      // a bad or damaged archive is a warning for Parser, but an error
+      // when extracting.  Mark those errors as unrecoverable, because
+      // the Unpack contract cannot be met.
+      warn(code2, msg, data = {}) {
+        if (code2 === "TAR_BAD_ARCHIVE" || code2 === "TAR_ABORT") {
+          data.recoverable = false;
         }
+        return super.warn(code2, msg, data);
       }
-      flush(flushFlag) {
-        if (this.ended)
-          return;
-        if (typeof flushFlag !== "number")
-          flushFlag = this.#fullFlushFlag;
-        this.write(Object.assign(import_buffer.Buffer.alloc(0), { [_flushFlag]: flushFlag }));
+      [MAYBECLOSE]() {
+        if (this[ENDED2] && this[PENDING] === 0) {
+          this.emit("prefinish");
+          this.emit("finish");
+          this.emit("end");
+        }
       }
-      end(chunk, encoding, cb) {
-        if (typeof chunk === "function") {
-          cb = chunk;
-          encoding = void 0;
-          chunk = void 0;
-        }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
+      // return false if we need to skip this file
+      // return true if the field was successfully sanitized
+      [STRIPABSOLUTEPATH](entry, field) {
+        const p = entry[field];
+        const { type } = entry;
+        if (!p || this.preservePaths)
+          return true;
+        const [root, stripped] = stripAbsolutePath(p);
+        const parts = stripped.replaceAll(/\\/g, "/").split("/");
+        if (parts.includes("..") || /* c8 ignore next */
+        isWindows3 && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) {
+          if (field === "path" || type === "Link") {
+            this.warn("TAR_ENTRY_ERROR", `${field} contains '..'`, {
+              entry,
+              [field]: p
+            });
+            return false;
+          }
+          const entryDir = import_node_path7.default.posix.dirname(entry.path);
+          const resolved = import_node_path7.default.posix.normalize(import_node_path7.default.posix.join(entryDir, parts.join("/")));
+          if (resolved.startsWith("../") || resolved === "..") {
+            this.warn("TAR_ENTRY_ERROR", `${field} escapes extraction directory`, {
+              entry,
+              [field]: p
+            });
+            return false;
+          }
         }
-        if (chunk) {
-          if (encoding)
-            this.write(chunk, encoding);
-          else
-            this.write(chunk);
+        if (root) {
+          entry[field] = String(stripped);
+          this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute ${field}`, {
+            entry,
+            [field]: p
+          });
         }
-        this.flush(this.#finishFlushFlag);
-        this.#ended = true;
-        return super.end(cb);
-      }
-      get ended() {
-        return this.#ended;
-      }
-      // overridden in the gzip classes to do portable writes
-      [_superWrite](data) {
-        return super.write(data);
+        return true;
       }
-      write(chunk, encoding, cb) {
-        if (typeof encoding === "function")
-          cb = encoding, encoding = "utf8";
-        if (typeof chunk === "string")
-          chunk = import_buffer.Buffer.from(chunk, encoding);
-        if (this.#sawError)
-          return;
-        (0, import_assert2.default)(this.#handle, "zlib binding closed");
-        const nativeHandle = this.#handle._handle;
-        const originalNativeClose = nativeHandle.close;
-        nativeHandle.close = () => {
-        };
-        const originalClose = this.#handle.close;
-        this.#handle.close = () => {
-        };
-        passthroughBufferConcat(true);
-        let result = void 0;
-        try {
-          const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this.#flushFlag;
-          result = this.#handle._processChunk(chunk, flushFlag);
-          passthroughBufferConcat(false);
-        } catch (err) {
-          passthroughBufferConcat(false);
-          this.#onError(new ZlibError(err, this.write));
-        } finally {
-          if (this.#handle) {
-            ;
-            this.#handle._handle = nativeHandle;
-            nativeHandle.close = originalNativeClose;
-            this.#handle.close = originalClose;
-            this.#handle.removeAllListeners("error");
+      // no IO, just string checking for absolute indicators
+      [CHECKPATH](entry) {
+        const p = normalizeWindowsPath(entry.path);
+        const parts = p.split("/");
+        if (this.strip) {
+          if (parts.length < this.strip) {
+            return false;
           }
-        }
-        if (this.#handle)
-          this.#handle.on("error", (er) => this.#onError(new ZlibError(er, this.write)));
-        let writeReturn;
-        if (result) {
-          if (Array.isArray(result) && result.length > 0) {
-            const r = result[0];
-            writeReturn = this[_superWrite](import_buffer.Buffer.from(r));
-            for (let i = 1; i < result.length; i++) {
-              writeReturn = this[_superWrite](result[i]);
+          if (entry.type === "Link") {
+            const linkparts = normalizeWindowsPath(String(entry.linkpath)).split("/");
+            if (linkparts.length >= this.strip) {
+              entry.linkpath = linkparts.slice(this.strip).join("/");
+            } else {
+              return false;
             }
-          } else {
-            writeReturn = this[_superWrite](import_buffer.Buffer.from(result));
           }
+          parts.splice(0, this.strip);
+          entry.path = parts.join("/");
         }
-        if (cb)
-          cb();
-        return writeReturn;
-      }
-    };
-    Zlib = class extends ZlibBase {
-      #level;
-      #strategy;
-      constructor(opts, mode) {
-        opts = opts || {};
-        opts.flush = opts.flush || constants.Z_NO_FLUSH;
-        opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
-        opts.fullFlushFlag = constants.Z_FULL_FLUSH;
-        super(opts, mode);
-        this.#level = opts.level;
-        this.#strategy = opts.strategy;
+        if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
+          this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
+            entry,
+            path: p,
+            depth: parts.length,
+            maxDepth: this.maxDepth
+          });
+          return false;
+        }
+        if (!this[STRIPABSOLUTEPATH](entry, "path") || !this[STRIPABSOLUTEPATH](entry, "linkpath")) {
+          return false;
+        }
+        entry.absolute = import_node_path7.default.isAbsolute(entry.path) ? normalizeWindowsPath(import_node_path7.default.resolve(entry.path)) : normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path));
+        if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) {
+          this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
+            entry,
+            path: normalizeWindowsPath(entry.path),
+            resolvedPath: entry.absolute,
+            cwd: this.cwd
+          });
+          return false;
+        }
+        if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") {
+          return false;
+        }
+        if (this.win32) {
+          const { root: aRoot } = import_node_path7.default.win32.parse(String(entry.absolute));
+          entry.absolute = aRoot + encode2(String(entry.absolute).slice(aRoot.length));
+          const { root: pRoot } = import_node_path7.default.win32.parse(entry.path);
+          entry.path = pRoot + encode2(entry.path.slice(pRoot.length));
+        }
+        return true;
       }
-      params(level, strategy) {
-        if (this.sawError)
-          return;
-        if (!this.handle)
-          throw new Error("cannot switch params when binding is closed");
-        if (!this.handle.params)
-          throw new Error("not supported in this implementation");
-        if (this.#level !== level || this.#strategy !== strategy) {
-          this.flush(constants.Z_SYNC_FLUSH);
-          (0, import_assert2.default)(this.handle, "zlib binding closed");
-          const origFlush = this.handle.flush;
-          this.handle.flush = (flushFlag, cb) => {
-            if (typeof flushFlag === "function") {
-              cb = flushFlag;
-              flushFlag = this.flushFlag;
+      [ONENTRY](entry) {
+        if (!this[CHECKPATH](entry)) {
+          return entry.resume();
+        }
+        import_node_assert.default.equal(typeof entry.absolute, "string");
+        switch (entry.type) {
+          case "Directory":
+          case "GNUDumpDir":
+            if (entry.mode) {
+              entry.mode = entry.mode | 448;
             }
-            this.flush(flushFlag);
-            cb?.();
-          };
-          try {
-            ;
-            this.handle.params(level, strategy);
-          } finally {
-            this.handle.flush = origFlush;
-          }
-          if (this.handle) {
-            this.#level = level;
-            this.#strategy = strategy;
-          }
+          // eslint-disable-next-line no-fallthrough
+          case "File":
+          case "OldFile":
+          case "ContiguousFile":
+          case "Link":
+          case "SymbolicLink":
+            return this[CHECKFS](entry);
+          case "CharacterDevice":
+          case "BlockDevice":
+          case "FIFO":
+          default:
+            return this[UNSUPPORTED](entry);
         }
       }
-    };
-    Gzip = class extends Zlib {
-      #portable;
-      constructor(opts) {
-        super(opts, "Gzip");
-        this.#portable = opts && !!opts.portable;
+      [ONERROR](er, entry) {
+        if (er.name === "CwdError") {
+          this.emit("error", er);
+        } else {
+          this.warn("TAR_ENTRY_ERROR", er, { entry });
+          this[UNPEND]();
+          entry.resume();
+        }
       }
-      [_superWrite](data) {
-        if (!this.#portable)
-          return super[_superWrite](data);
-        this.#portable = false;
-        data[9] = 255;
-        return super[_superWrite](data);
+      [MKDIR](dir, mode, cb) {
+        mkdir(normalizeWindowsPath(dir), {
+          uid: this.uid,
+          gid: this.gid,
+          processUid: this.processUid,
+          processGid: this.processGid,
+          umask: this.processUmask,
+          preserve: this.preservePaths,
+          unlink: this.unlink,
+          cwd: this.cwd,
+          mode
+        }, cb);
       }
-    };
-    Unzip = class extends Zlib {
-      constructor(opts) {
-        super(opts, "Unzip");
+      [DOCHOWN](entry) {
+        return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid;
       }
-    };
-    Brotli = class extends ZlibBase {
-      constructor(opts, mode) {
-        opts = opts || {};
-        opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
-        opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
-        opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
-        super(opts, mode);
+      [UID](entry) {
+        return uint32(this.uid, entry.uid, this.processUid);
       }
-    };
-    BrotliCompress = class extends Brotli {
-      constructor(opts) {
-        super(opts, "BrotliCompress");
+      [GID](entry) {
+        return uint32(this.gid, entry.gid, this.processGid);
       }
-    };
-    BrotliDecompress = class extends Brotli {
-      constructor(opts) {
-        super(opts, "BrotliDecompress");
+      [FILE](entry, fullyDone) {
+        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+        const stream = new WriteStream(String(entry.absolute), {
+          // slight lie, but it can be numeric flags
+          flags: getWriteFlag(entry.size),
+          mode,
+          autoClose: false
+        });
+        stream.on("error", (er) => {
+          if (stream.fd) {
+            import_node_fs4.default.close(stream.fd, () => {
+            });
+          }
+          stream.write = () => true;
+          this[ONERROR](er, entry);
+          fullyDone();
+        });
+        let actions = 1;
+        const done = (er) => {
+          if (er) {
+            if (stream.fd) {
+              import_node_fs4.default.close(stream.fd, () => {
+              });
+            }
+            this[ONERROR](er, entry);
+            fullyDone();
+            return;
+          }
+          if (--actions === 0) {
+            if (stream.fd !== void 0) {
+              import_node_fs4.default.close(stream.fd, (er2) => {
+                if (er2) {
+                  this[ONERROR](er2, entry);
+                } else {
+                  this[UNPEND]();
+                }
+                fullyDone();
+              });
+            }
+          }
+        };
+        stream.on("finish", () => {
+          const abs = String(entry.absolute);
+          const fd = stream.fd;
+          if (typeof fd === "number" && entry.mtime && !this.noMtime) {
+            actions++;
+            const atime = entry.atime || /* @__PURE__ */ new Date();
+            const mtime = entry.mtime;
+            import_node_fs4.default.futimes(fd, atime, mtime, (er) => er ? import_node_fs4.default.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done());
+          }
+          if (typeof fd === "number" && this[DOCHOWN](entry)) {
+            actions++;
+            const uid = this[UID](entry);
+            const gid = this[GID](entry);
+            if (typeof uid === "number" && typeof gid === "number") {
+              import_node_fs4.default.fchown(fd, uid, gid, (er) => er ? import_node_fs4.default.chown(abs, uid, gid, (er2) => done(er2 && er)) : done());
+            }
+          }
+          done();
+        });
+        const tx = this.transform ? this.transform(entry) || entry : entry;
+        if (tx !== entry) {
+          tx.on("error", (er) => {
+            this[ONERROR](er, entry);
+            fullyDone();
+          });
+          entry.pipe(tx);
+        }
+        tx.pipe(stream);
       }
-    };
-    Zstd = class extends ZlibBase {
-      constructor(opts, mode) {
-        opts = opts || {};
-        opts.flush = opts.flush || constants.ZSTD_e_continue;
-        opts.finishFlush = opts.finishFlush || constants.ZSTD_e_end;
-        opts.fullFlushFlag = constants.ZSTD_e_flush;
-        super(opts, mode);
+      [DIRECTORY](entry, fullyDone) {
+        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+        this[MKDIR](String(entry.absolute), mode, (er) => {
+          if (er) {
+            this[ONERROR](er, entry);
+            fullyDone();
+            return;
+          }
+          let actions = 1;
+          const done = () => {
+            if (--actions === 0) {
+              fullyDone();
+              this[UNPEND]();
+              entry.resume();
+            }
+          };
+          if (entry.mtime && !this.noMtime) {
+            actions++;
+            import_node_fs4.default.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done);
+          }
+          if (this[DOCHOWN](entry)) {
+            actions++;
+            import_node_fs4.default.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
+          }
+          done();
+        });
       }
-    };
-    ZstdCompress = class extends Zstd {
-      constructor(opts) {
-        super(opts, "ZstdCompress");
+      [UNSUPPORTED](entry) {
+        entry.unsupported = true;
+        this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${entry.type}`, { entry });
+        entry.resume();
       }
-    };
-    ZstdDecompress = class extends Zstd {
-      constructor(opts) {
-        super(opts, "ZstdDecompress");
+      [SYMLINK](entry, done) {
+        const parts = normalizeWindowsPath(import_node_path7.default.relative(this.cwd, import_node_path7.default.resolve(import_node_path7.default.dirname(String(entry.absolute)), String(entry.linkpath)))).split("/");
+        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, String(entry.linkpath), "symlink", done), (er) => {
+          this[ONERROR](er, entry);
+          done();
+        });
       }
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/large-numbers.js
-var encode, encodePositive, encodeNegative, parse, twos, pos, onesComp, twosComp;
-var init_large_numbers = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/large-numbers.js"() {
-    encode = (num, buf) => {
-      if (!Number.isSafeInteger(num)) {
-        throw Error("cannot encode number outside of javascript safe integer range");
-      } else if (num < 0) {
-        encodeNegative(num, buf);
-      } else {
-        encodePositive(num, buf);
+      [HARDLINK](entry, done) {
+        const linkpath = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, String(entry.linkpath)));
+        const parts = normalizeWindowsPath(String(entry.linkpath)).split("/");
+        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, linkpath, "link", done), (er) => {
+          this[ONERROR](er, entry);
+          done();
+        });
       }
-      return buf;
-    };
-    encodePositive = (num, buf) => {
-      buf[0] = 128;
-      for (var i = buf.length; i > 1; i--) {
-        buf[i - 1] = num & 255;
-        num = Math.floor(num / 256);
+      [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) {
+        const p = parts.shift();
+        if (this.preservePaths || p === void 0)
+          return done();
+        const t = import_node_path7.default.resolve(cwd, p);
+        import_node_fs4.default.lstat(t, (er, st) => {
+          if (er)
+            return done();
+          if (st?.isSymbolicLink()) {
+            return onError(new SymlinkError(t, import_node_path7.default.resolve(t, parts.join("/"))));
+          }
+          this[ENSURE_NO_SYMLINK](entry, t, parts, done, onError);
+        });
       }
-    };
-    encodeNegative = (num, buf) => {
-      buf[0] = 255;
-      var flipped = false;
-      num = num * -1;
-      for (var i = buf.length; i > 1; i--) {
-        var byte = num & 255;
-        num = Math.floor(num / 256);
-        if (flipped) {
-          buf[i - 1] = onesComp(byte);
-        } else if (byte === 0) {
-          buf[i - 1] = 0;
-        } else {
-          flipped = true;
-          buf[i - 1] = twosComp(byte);
-        }
+      [PEND]() {
+        this[PENDING]++;
       }
-    };
-    parse = (buf) => {
-      const pre = buf[0];
-      const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null;
-      if (value === null) {
-        throw Error("invalid base256 encoding");
+      [UNPEND]() {
+        this[PENDING]--;
+        this[MAYBECLOSE]();
       }
-      if (!Number.isSafeInteger(value)) {
-        throw Error("parsed number outside of javascript safe integer range");
+      [SKIP](entry) {
+        this[UNPEND]();
+        entry.resume();
       }
-      return value;
-    };
-    twos = (buf) => {
-      var len = buf.length;
-      var sum = 0;
-      var flipped = false;
-      for (var i = len - 1; i > -1; i--) {
-        var byte = Number(buf[i]);
-        var f;
-        if (flipped) {
-          f = onesComp(byte);
-        } else if (byte === 0) {
-          f = byte;
-        } else {
-          flipped = true;
-          f = twosComp(byte);
-        }
-        if (f !== 0) {
-          sum -= f * Math.pow(256, len - i - 1);
-        }
+      // Check if we can reuse an existing filesystem entry safely and
+      // overwrite it, rather than unlinking and recreating
+      // Windows doesn't report a useful nlink, so we just never reuse entries
+      [ISREUSABLE](entry, st) {
+        return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows3;
       }
-      return sum;
-    };
-    pos = (buf) => {
-      var len = buf.length;
-      var sum = 0;
-      for (var i = len - 1; i > -1; i--) {
-        var byte = Number(buf[i]);
-        if (byte !== 0) {
-          sum += byte * Math.pow(256, len - i - 1);
+      // check if a thing is there, and if so, try to clobber it
+      [CHECKFS](entry) {
+        this[PEND]();
+        const paths = [entry.path];
+        if (entry.linkpath) {
+          paths.push(entry.linkpath);
         }
+        this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done));
       }
-      return sum;
-    };
-    onesComp = (byte) => (255 ^ byte) & 255;
-    twosComp = (byte) => (255 ^ byte) + 1 & 255;
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/types.js
-var isCode, name, code;
-var init_types = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/types.js"() {
-    isCode = (c) => name.has(c);
-    name = /* @__PURE__ */ new Map([
-      ["0", "File"],
-      // same as File
-      ["", "OldFile"],
-      ["1", "Link"],
-      ["2", "SymbolicLink"],
-      // Devices and FIFOs aren't fully supported
-      // they are parsed, but skipped when unpacking
-      ["3", "CharacterDevice"],
-      ["4", "BlockDevice"],
-      ["5", "Directory"],
-      ["6", "FIFO"],
-      // same as File
-      ["7", "ContiguousFile"],
-      // pax headers
-      ["g", "GlobalExtendedHeader"],
-      ["x", "ExtendedHeader"],
-      // vendor-specific stuff
-      // skip
-      ["A", "SolarisACL"],
-      // like 5, but with data, which should be skipped
-      ["D", "GNUDumpDir"],
-      // metadata only, skip
-      ["I", "Inode"],
-      // data = link path of next file
-      ["K", "NextFileHasLongLinkpath"],
-      // data = path of next file
-      ["L", "NextFileHasLongPath"],
-      // skip
-      ["M", "ContinuationFile"],
-      // like L
-      ["N", "OldGnuLongPath"],
-      // skip
-      ["S", "SparseFile"],
-      // skip
-      ["V", "TapeVolumeHeader"],
-      // like x
-      ["X", "OldExtendedHeader"]
-    ]);
-    code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]]));
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/header.js
-var import_node_path, Header, splitPrefix, decString, decDate, numToDate, decNumber, nanUndef, decSmallNumber, MAXNUM, encNumber, encSmallNumber, octalString, padOctal, encDate, NULLS, encString;
-var init_header = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/header.js"() {
-    import_node_path = require("node:path");
-    init_large_numbers();
-    init_types();
-    Header = class {
-      cksumValid = false;
-      needPax = false;
-      nullBlock = false;
-      block;
-      path;
-      mode;
-      uid;
-      gid;
-      size;
-      cksum;
-      #type = "Unsupported";
-      linkpath;
-      uname;
-      gname;
-      devmaj = 0;
-      devmin = 0;
-      atime;
-      ctime;
-      mtime;
-      charset;
-      comment;
-      constructor(data, off = 0, ex, gex) {
-        if (Buffer.isBuffer(data)) {
-          this.decode(data, off || 0, ex, gex);
-        } else if (data) {
-          this.#slurp(data);
+      [CHECKFS2](entry, fullyDone) {
+        const done = (er) => {
+          fullyDone(er);
+        };
+        const checkCwd2 = () => {
+          this[MKDIR](this.cwd, this.dmode, (er) => {
+            if (er) {
+              this[ONERROR](er, entry);
+              done();
+              return;
+            }
+            this[CHECKED_CWD] = true;
+            start();
+          });
+        };
+        const start = () => {
+          if (entry.absolute !== this.cwd) {
+            const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute)));
+            if (parent !== this.cwd) {
+              return this[MKDIR](parent, this.dmode, (er) => {
+                if (er) {
+                  this[ONERROR](er, entry);
+                  done();
+                  return;
+                }
+                afterMakeParent();
+              });
+            }
+          }
+          afterMakeParent();
+        };
+        const afterMakeParent = () => {
+          import_node_fs4.default.lstat(String(entry.absolute), (lstatEr, st) => {
+            if (st && (this.keep || /* c8 ignore next */
+            this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
+              this[SKIP](entry);
+              done();
+              return;
+            }
+            if (lstatEr || this[ISREUSABLE](entry, st)) {
+              return this[MAKEFS](null, entry, done);
+            }
+            if (st.isDirectory()) {
+              if (entry.type === "Directory") {
+                const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
+                const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
+                if (!needChmod) {
+                  return afterChmod();
+                }
+                return import_node_fs4.default.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
+              }
+              if (entry.absolute !== this.cwd) {
+                return import_node_fs4.default.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+              }
+            }
+            if (entry.absolute === this.cwd) {
+              return this[MAKEFS](null, entry, done);
+            }
+            unlinkFile(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
+          });
+        };
+        if (this[CHECKED_CWD]) {
+          start();
+        } else {
+          checkCwd2();
         }
       }
-      decode(buf, off, ex, gex) {
-        if (!off) {
-          off = 0;
-        }
-        if (!buf || !(buf.length >= off + 512)) {
-          throw new Error("need 512 bytes for header");
-        }
-        this.path = ex?.path ?? decString(buf, off, 100);
-        this.mode = ex?.mode ?? gex?.mode ?? decNumber(buf, off + 100, 8);
-        this.uid = ex?.uid ?? gex?.uid ?? decNumber(buf, off + 108, 8);
-        this.gid = ex?.gid ?? gex?.gid ?? decNumber(buf, off + 116, 8);
-        this.size = ex?.size ?? gex?.size ?? decNumber(buf, off + 124, 12);
-        this.mtime = ex?.mtime ?? gex?.mtime ?? decDate(buf, off + 136, 12);
-        this.cksum = decNumber(buf, off + 148, 12);
-        if (gex)
-          this.#slurp(gex, true);
-        if (ex)
-          this.#slurp(ex);
-        const t = decString(buf, off + 156, 1);
-        if (isCode(t)) {
-          this.#type = t || "0";
-        }
-        if (this.#type === "0" && this.path.slice(-1) === "/") {
-          this.#type = "5";
+      [MAKEFS](er, entry, done) {
+        if (er) {
+          this[ONERROR](er, entry);
+          done();
+          return;
         }
-        if (this.#type === "5") {
-          this.size = 0;
+        switch (entry.type) {
+          case "File":
+          case "OldFile":
+          case "ContiguousFile":
+            return this[FILE](entry, done);
+          case "Link":
+            return this[HARDLINK](entry, done);
+          case "SymbolicLink":
+            return this[SYMLINK](entry, done);
+          case "Directory":
+          case "GNUDumpDir":
+            return this[DIRECTORY](entry, done);
         }
-        this.linkpath = decString(buf, off + 157, 100);
-        if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") {
-          this.uname = ex?.uname ?? gex?.uname ?? decString(buf, off + 265, 32);
-          this.gname = ex?.gname ?? gex?.gname ?? decString(buf, off + 297, 32);
-          this.devmaj = ex?.devmaj ?? gex?.devmaj ?? decNumber(buf, off + 329, 8) ?? 0;
-          this.devmin = ex?.devmin ?? gex?.devmin ?? decNumber(buf, off + 337, 8) ?? 0;
-          if (buf[off + 475] !== 0) {
-            const prefix = decString(buf, off + 345, 155);
-            this.path = prefix + "/" + this.path;
+      }
+      [LINK](entry, linkpath, link, done) {
+        import_node_fs4.default[link](linkpath, String(entry.absolute), (er) => {
+          if (er) {
+            this[ONERROR](er, entry);
           } else {
-            const prefix = decString(buf, off + 345, 130);
-            if (prefix) {
-              this.path = prefix + "/" + this.path;
-            }
-            this.atime = ex?.atime ?? gex?.atime ?? decDate(buf, off + 476, 12);
-            this.ctime = ex?.ctime ?? gex?.ctime ?? decDate(buf, off + 488, 12);
+            this[UNPEND]();
+            entry.resume();
+          }
+          done();
+        });
+      }
+    };
+    callSync = (fn2) => {
+      try {
+        return [null, fn2()];
+      } catch (er) {
+        return [er, null];
+      }
+    };
+    UnpackSync = class extends Unpack {
+      sync = true;
+      [MAKEFS](er, entry) {
+        return super[MAKEFS](er, entry, () => {
+        });
+      }
+      [CHECKFS](entry) {
+        if (!this[CHECKED_CWD]) {
+          const er2 = this[MKDIR](this.cwd, this.dmode);
+          if (er2) {
+            return this[ONERROR](er2, entry);
           }
+          this[CHECKED_CWD] = true;
         }
-        let sum = 8 * 32;
-        for (let i = off; i < off + 148; i++) {
-          sum += buf[i];
+        if (entry.absolute !== this.cwd) {
+          const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute)));
+          if (parent !== this.cwd) {
+            const mkParent = this[MKDIR](parent, this.dmode);
+            if (mkParent) {
+              return this[ONERROR](mkParent, entry);
+            }
+          }
         }
-        for (let i = off + 156; i < off + 512; i++) {
-          sum += buf[i];
+        const [lstatEr, st] = callSync(() => import_node_fs4.default.lstatSync(String(entry.absolute)));
+        if (st && (this.keep || /* c8 ignore next */
+        this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
+          return this[SKIP](entry);
         }
-        this.cksumValid = sum === this.cksum;
-        if (this.cksum === void 0 && sum === 8 * 32) {
-          this.nullBlock = true;
+        if (lstatEr || this[ISREUSABLE](entry, st)) {
+          return this[MAKEFS](null, entry);
         }
-      }
-      #slurp(ex, gex = false) {
-        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
-          return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global");
-        })));
-      }
-      encode(buf, off = 0) {
-        if (!buf) {
-          buf = this.block = Buffer.alloc(512);
+        if (st.isDirectory()) {
+          if (entry.type === "Directory") {
+            const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
+            const [er3] = needChmod ? callSync(() => {
+              import_node_fs4.default.chmodSync(String(entry.absolute), Number(entry.mode));
+            }) : [];
+            return this[MAKEFS](er3, entry);
+          }
+          const [er2] = callSync(() => import_node_fs4.default.rmdirSync(String(entry.absolute)));
+          this[MAKEFS](er2, entry);
         }
-        if (this.#type === "Unsupported") {
-          this.#type = "0";
+        const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(String(entry.absolute)));
+        this[MAKEFS](er, entry);
+      }
+      [FILE](entry, done) {
+        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
+        const oner = (er) => {
+          let closeError;
+          try {
+            import_node_fs4.default.closeSync(fd);
+          } catch (e) {
+            closeError = e;
+          }
+          if (er || closeError) {
+            this[ONERROR](er || closeError, entry);
+          }
+          done();
+        };
+        let fd;
+        try {
+          fd = import_node_fs4.default.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
+        } catch (er) {
+          return oner(er);
         }
-        if (!(buf.length >= off + 512)) {
-          throw new Error("need 512 bytes for header");
+        const tx = this.transform ? this.transform(entry) || entry : entry;
+        if (tx !== entry) {
+          tx.on("error", (er) => this[ONERROR](er, entry));
+          entry.pipe(tx);
         }
-        const prefixSize = this.ctime || this.atime ? 130 : 155;
-        const split = splitPrefix(this.path || "", prefixSize);
-        const path16 = split[0];
-        const prefix = split[1];
-        this.needPax = !!split[2];
-        this.needPax = encString(buf, off, 100, path16) || this.needPax;
-        this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax;
-        this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax;
-        this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax;
-        this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax;
-        this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax;
-        buf[off + 156] = Number(this.#type.codePointAt(0));
-        this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax;
-        buf.write("ustar\x0000", off + 257, 8);
-        this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax;
-        this.needPax = encString(buf, off + 297, 32, this.gname) || this.needPax;
-        this.needPax = encNumber(buf, off + 329, 8, this.devmaj) || this.needPax;
-        this.needPax = encNumber(buf, off + 337, 8, this.devmin) || this.needPax;
-        this.needPax = encString(buf, off + 345, prefixSize, prefix) || this.needPax;
-        if (buf[off + 475] !== 0) {
-          this.needPax = encString(buf, off + 345, 155, prefix) || this.needPax;
-        } else {
-          this.needPax = encString(buf, off + 345, 130, prefix) || this.needPax;
-          this.needPax = encDate(buf, off + 476, 12, this.atime) || this.needPax;
-          this.needPax = encDate(buf, off + 488, 12, this.ctime) || this.needPax;
+        tx.on("data", (chunk) => {
+          try {
+            import_node_fs4.default.writeSync(fd, chunk, 0, chunk.length);
+          } catch (er) {
+            oner(er);
+          }
+        });
+        tx.on("end", () => {
+          let er = null;
+          if (entry.mtime && !this.noMtime) {
+            const atime = entry.atime || /* @__PURE__ */ new Date();
+            const mtime = entry.mtime;
+            try {
+              import_node_fs4.default.futimesSync(fd, atime, mtime);
+            } catch (futimeser) {
+              try {
+                import_node_fs4.default.utimesSync(String(entry.absolute), atime, mtime);
+              } catch {
+                er = futimeser;
+              }
+            }
+          }
+          if (this[DOCHOWN](entry)) {
+            const uid = this[UID](entry);
+            const gid = this[GID](entry);
+            try {
+              import_node_fs4.default.fchownSync(fd, Number(uid), Number(gid));
+            } catch (fchowner) {
+              try {
+                import_node_fs4.default.chownSync(String(entry.absolute), Number(uid), Number(gid));
+              } catch {
+                er = er || fchowner;
+              }
+            }
+          }
+          oner(er);
+        });
+      }
+      [DIRECTORY](entry, done) {
+        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
+        const er = this[MKDIR](String(entry.absolute), mode);
+        if (er) {
+          this[ONERROR](er, entry);
+          done();
+          return;
         }
-        let sum = 8 * 32;
-        for (let i = off; i < off + 148; i++) {
-          sum += buf[i];
+        if (entry.mtime && !this.noMtime) {
+          try {
+            import_node_fs4.default.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime);
+          } catch {
+          }
         }
-        for (let i = off + 156; i < off + 512; i++) {
-          sum += buf[i];
+        if (this[DOCHOWN](entry)) {
+          try {
+            import_node_fs4.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
+          } catch {
+          }
         }
-        this.cksum = sum;
-        encNumber(buf, off + 148, 8, this.cksum);
-        this.cksumValid = true;
-        return this.needPax;
-      }
-      get type() {
-        return this.#type === "Unsupported" ? this.#type : name.get(this.#type);
-      }
-      get typeKey() {
-        return this.#type;
+        done();
+        entry.resume();
       }
-      set type(type) {
-        const c = String(code.get(type));
-        if (isCode(c) || c === "Unsupported") {
-          this.#type = c;
-        } else if (isCode(type)) {
-          this.#type = type;
-        } else {
-          throw new TypeError("invalid entry type: " + type);
+      [MKDIR](dir, mode) {
+        try {
+          return mkdirSync2(normalizeWindowsPath(dir), {
+            uid: this.uid,
+            gid: this.gid,
+            processUid: this.processUid,
+            processGid: this.processGid,
+            umask: this.processUmask,
+            preserve: this.preservePaths,
+            unlink: this.unlink,
+            cwd: this.cwd,
+            mode
+          });
+        } catch (er) {
+          return er;
         }
       }
-    };
-    splitPrefix = (p, prefixSize) => {
-      const pathSize = 100;
-      let pp = p;
-      let prefix = "";
-      let ret = void 0;
-      const root = import_node_path.posix.parse(p).root || ".";
-      if (Buffer.byteLength(pp) < pathSize) {
-        ret = [pp, prefix, false];
-      } else {
-        prefix = import_node_path.posix.dirname(pp);
-        pp = import_node_path.posix.basename(pp);
-        do {
-          if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) {
-            ret = [pp, prefix, false];
-          } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) {
-            ret = [pp.slice(0, pathSize - 1), prefix, true];
-          } else {
-            pp = import_node_path.posix.join(import_node_path.posix.basename(prefix), pp);
-            prefix = import_node_path.posix.dirname(prefix);
+      [ENSURE_NO_SYMLINK](_entry, cwd, parts, done, onError) {
+        if (this.preservePaths || parts.length === 0)
+          return done();
+        let t = cwd;
+        for (const p of parts) {
+          t = import_node_path7.default.resolve(t, p);
+          const [er, st] = callSync(() => import_node_fs4.default.lstatSync(t));
+          if (er)
+            return done();
+          if (st.isSymbolicLink()) {
+            return onError(new SymlinkError(t, import_node_path7.default.resolve(cwd, parts.join("/"))));
           }
-        } while (prefix !== root && ret === void 0);
-        if (!ret) {
-          ret = [p.slice(0, pathSize - 1), "", true];
+        }
+        done();
+      }
+      [LINK](entry, linkpath, link, done) {
+        const linkSync = `${link}Sync`;
+        try {
+          import_node_fs4.default[linkSync](linkpath, String(entry.absolute));
+          done();
+          entry.resume();
+        } catch (er) {
+          return this[ONERROR](er, entry);
         }
       }
-      return ret;
-    };
-    decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, "");
-    decDate = (buf, off, size) => numToDate(decNumber(buf, off, size));
-    numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3);
-    decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size);
-    nanUndef = (value) => isNaN(value) ? void 0 : value;
-    decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8));
-    MAXNUM = {
-      12: 8589934591,
-      8: 2097151
     };
-    encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false);
-    encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii");
-    octalString = (num, size) => padOctal(Math.floor(num).toString(8), size);
-    padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0";
-    encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3);
-    NULLS = new Array(156).join("\0");
-    encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size);
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pax.js
-var import_node_path2, Pax, merge, parseKV, parseKVLine;
-var init_pax = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pax.js"() {
-    import_node_path2 = require("node:path");
-    init_header();
-    Pax = class _Pax {
-      atime;
-      mtime;
-      ctime;
-      charset;
-      comment;
-      gid;
-      uid;
-      gname;
-      uname;
-      linkpath;
-      dev;
-      ino;
-      nlink;
-      path;
-      size;
-      mode;
-      global;
-      constructor(obj, global2 = false) {
-        this.atime = obj.atime;
-        this.charset = obj.charset;
-        this.comment = obj.comment;
-        this.ctime = obj.ctime;
-        this.dev = obj.dev;
-        this.gid = obj.gid;
-        this.global = global2;
-        this.gname = obj.gname;
-        this.ino = obj.ino;
-        this.linkpath = obj.linkpath;
-        this.mtime = obj.mtime;
-        this.nlink = obj.nlink;
-        this.path = obj.path;
-        this.size = obj.size;
-        this.uid = obj.uid;
-        this.uname = obj.uname;
+// node_modules/tar/dist/esm/extract.js
+var extract_exports = {};
+__export(extract_exports, {
+  extract: () => extract
+});
+var import_node_fs5, extractFileSync, extractFile, extract;
+var init_extract = __esm({
+  "node_modules/tar/dist/esm/extract.js"() {
+    init_esm2();
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    init_list();
+    init_make_command();
+    init_unpack();
+    extractFileSync = (opt) => {
+      const u = new UnpackSync(opt);
+      const file = opt.file;
+      const stat = import_node_fs5.default.statSync(file);
+      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+      const stream = new ReadStreamSync(file, {
+        readSize,
+        size: stat.size
+      });
+      stream.pipe(u);
+    };
+    extractFile = (opt, _) => {
+      const u = new Unpack(opt);
+      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+      const file = opt.file;
+      const p = new Promise((resolve, reject) => {
+        u.on("error", reject);
+        u.on("close", resolve);
+        import_node_fs5.default.stat(file, (er, stat) => {
+          if (er) {
+            reject(er);
+          } else {
+            const stream = new ReadStream(file, {
+              readSize,
+              size: stat.size
+            });
+            stream.on("error", reject);
+            stream.pipe(u);
+          }
+        });
+      });
+      return p;
+    };
+    extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(opt), (opt) => new Unpack(opt), (opt, files) => {
+      if (files?.length)
+        filesFilter(opt, files);
+    });
+  }
+});
+
+// node_modules/v8-compile-cache/v8-compile-cache.js
+var require_v8_compile_cache = __commonJS({
+  "node_modules/v8-compile-cache/v8-compile-cache.js"(exports2, module2) {
+    "use strict";
+    var Module2 = require("module");
+    var crypto = require("crypto");
+    var fs17 = require("fs");
+    var path16 = require("path");
+    var vm = require("vm");
+    var os3 = require("os");
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var FileSystemBlobStore = class {
+      constructor(directory, prefix) {
+        const name2 = prefix ? slashEscape(prefix + ".") : "";
+        this._blobFilename = path16.join(directory, name2 + "BLOB");
+        this._mapFilename = path16.join(directory, name2 + "MAP");
+        this._lockFilename = path16.join(directory, name2 + "LOCK");
+        this._directory = directory;
+        this._load();
       }
-      encode() {
-        const body = this.encodeBody();
-        if (body === "") {
-          return Buffer.allocUnsafe(0);
+      has(key, invalidationKey) {
+        if (hasOwnProperty.call(this._memoryBlobs, key)) {
+          return this._invalidationKeys[key] === invalidationKey;
+        } else if (hasOwnProperty.call(this._storedMap, key)) {
+          return this._storedMap[key][0] === invalidationKey;
         }
-        const bodyLen = Buffer.byteLength(body);
-        const bufLen = 512 * Math.ceil(1 + bodyLen / 512);
-        const buf = Buffer.allocUnsafe(bufLen);
-        for (let i = 0; i < 512; i++) {
-          buf[i] = 0;
+        return false;
+      }
+      get(key, invalidationKey) {
+        if (hasOwnProperty.call(this._memoryBlobs, key)) {
+          if (this._invalidationKeys[key] === invalidationKey) {
+            return this._memoryBlobs[key];
+          }
+        } else if (hasOwnProperty.call(this._storedMap, key)) {
+          const mapping = this._storedMap[key];
+          if (mapping[0] === invalidationKey) {
+            return this._storedBlob.slice(mapping[1], mapping[2]);
+          }
         }
-        new Header({
-          // XXX split the path
-          // then the path should be PaxHeader + basename, but less than 99,
-          // prepend with the dirname
-          /* c8 ignore start */
-          path: ("PaxHeader/" + (0, import_node_path2.basename)(this.path ?? "")).slice(0, 99),
-          /* c8 ignore stop */
-          mode: this.mode || 420,
-          uid: this.uid,
-          gid: this.gid,
-          size: bodyLen,
-          mtime: this.mtime,
-          type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader",
-          linkpath: "",
-          uname: this.uname || "",
-          gname: this.gname || "",
-          devmaj: 0,
-          devmin: 0,
-          atime: this.atime,
-          ctime: this.ctime
-        }).encode(buf);
-        buf.write(body, 512, bodyLen, "utf8");
-        for (let i = bodyLen + 512; i < buf.length; i++) {
-          buf[i] = 0;
+      }
+      set(key, invalidationKey, buffer) {
+        this._invalidationKeys[key] = invalidationKey;
+        this._memoryBlobs[key] = buffer;
+        this._dirty = true;
+      }
+      delete(key) {
+        if (hasOwnProperty.call(this._memoryBlobs, key)) {
+          this._dirty = true;
+          delete this._memoryBlobs[key];
+        }
+        if (hasOwnProperty.call(this._invalidationKeys, key)) {
+          this._dirty = true;
+          delete this._invalidationKeys[key];
+        }
+        if (hasOwnProperty.call(this._storedMap, key)) {
+          this._dirty = true;
+          delete this._storedMap[key];
         }
-        return buf;
       }
-      encodeBody() {
-        return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname");
+      isDirty() {
+        return this._dirty;
       }
-      encodeField(field) {
-        if (this[field] === void 0) {
-          return "";
+      save() {
+        const dump = this._getDump();
+        const blobToStore = Buffer.concat(dump[0]);
+        const mapToStore = JSON.stringify(dump[1]);
+        try {
+          mkdirpSync(this._directory);
+          fs17.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
+        } catch (error) {
+          return false;
         }
-        const r = this[field];
-        const v = r instanceof Date ? r.getTime() / 1e3 : r;
-        const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n";
-        const byteLen = Buffer.byteLength(s);
-        let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1;
-        if (byteLen + digits >= Math.pow(10, digits)) {
-          digits += 1;
+        try {
+          fs17.writeFileSync(this._blobFilename, blobToStore);
+          fs17.writeFileSync(this._mapFilename, mapToStore);
+        } finally {
+          fs17.unlinkSync(this._lockFilename);
         }
-        const len = digits + byteLen;
-        return len + s;
+        return true;
       }
-      static parse(str, ex, g = false) {
-        return new _Pax(merge(parseKV(str), ex), g);
+      _load() {
+        try {
+          this._storedBlob = fs17.readFileSync(this._blobFilename);
+          this._storedMap = JSON.parse(fs17.readFileSync(this._mapFilename));
+        } catch (e) {
+          this._storedBlob = Buffer.alloc(0);
+          this._storedMap = {};
+        }
+        this._dirty = false;
+        this._memoryBlobs = {};
+        this._invalidationKeys = {};
+      }
+      _getDump() {
+        const buffers = [];
+        const newMap = {};
+        let offset = 0;
+        function push2(key, invalidationKey, buffer) {
+          buffers.push(buffer);
+          newMap[key] = [invalidationKey, offset, offset + buffer.length];
+          offset += buffer.length;
+        }
+        for (const key of Object.keys(this._memoryBlobs)) {
+          const buffer = this._memoryBlobs[key];
+          const invalidationKey = this._invalidationKeys[key];
+          push2(key, invalidationKey, buffer);
+        }
+        for (const key of Object.keys(this._storedMap)) {
+          if (hasOwnProperty.call(newMap, key)) continue;
+          const mapping = this._storedMap[key];
+          const buffer = this._storedBlob.slice(mapping[1], mapping[2]);
+          push2(key, mapping[0], buffer);
+        }
+        return [buffers, newMap];
       }
     };
-    merge = (a, b) => b ? Object.assign({}, b, a) : a;
-    parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null));
-    parseKVLine = (set, line) => {
-      const n = parseInt(line, 10);
-      if (n !== Buffer.byteLength(line) + 1) {
-        return set;
+    var NativeCompileCache = class {
+      constructor() {
+        this._cacheStore = null;
+        this._previousModuleCompile = null;
       }
-      line = line.slice((n + " ").length);
-      const kv = line.split("=");
-      const r = kv.shift();
-      if (!r) {
-        return set;
+      setCacheStore(cacheStore) {
+        this._cacheStore = cacheStore;
       }
-      const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1");
-      const v = kv.join("=");
-      set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v;
-      return set;
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-windows-path.js
-var platform, normalizeWindowsPath;
-var init_normalize_windows_path = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-windows-path.js"() {
-    platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-    normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.replaceAll(/\\/g, "/");
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/read-entry.js
-var ReadEntry;
-var init_read_entry = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/read-entry.js"() {
-    init_esm();
-    init_normalize_windows_path();
-    ReadEntry = class extends Minipass {
-      extended;
-      globalExtended;
-      header;
-      startBlockSize;
-      blockRemain;
-      remain;
-      type;
-      meta = false;
-      ignore = false;
-      path;
-      mode;
-      uid;
-      gid;
-      uname;
-      gname;
-      size = 0;
-      mtime;
-      atime;
-      ctime;
-      linkpath;
-      dev;
-      ino;
-      nlink;
-      invalid = false;
-      absolute;
-      unsupported = false;
-      constructor(header, ex, gex) {
-        super({});
-        this.pause();
-        this.extended = ex;
-        this.globalExtended = gex;
-        this.header = header;
-        this.remain = header.size ?? 0;
-        this.startBlockSize = 512 * Math.ceil(this.remain / 512);
-        this.blockRemain = this.startBlockSize;
-        this.type = header.type;
-        switch (this.type) {
-          case "File":
-          case "OldFile":
-          case "Link":
-          case "SymbolicLink":
-          case "CharacterDevice":
-          case "BlockDevice":
-          case "Directory":
-          case "FIFO":
-          case "ContiguousFile":
-          case "GNUDumpDir":
-            break;
-          case "NextFileHasLongLinkpath":
-          case "NextFileHasLongPath":
-          case "OldGnuLongPath":
-          case "GlobalExtendedHeader":
-          case "ExtendedHeader":
-          case "OldExtendedHeader":
-            this.meta = true;
-            break;
-          // NOTE: gnutar and bsdtar treat unrecognized types as 'File'
-          // it may be worth doing the same, but with a warning.
-          default:
-            this.ignore = true;
-        }
-        if (!header.path) {
-          throw new Error("no path provided for tar.ReadEntry");
-        }
-        this.path = normalizeWindowsPath(header.path);
-        this.mode = header.mode;
-        if (this.mode) {
-          this.mode = this.mode & 4095;
-        }
-        this.uid = header.uid;
-        this.gid = header.gid;
-        this.uname = header.uname;
-        this.gname = header.gname;
-        this.size = this.remain;
-        this.mtime = header.mtime;
-        this.atime = header.atime;
-        this.ctime = header.ctime;
-        this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0;
-        this.uname = header.uname;
-        this.gname = header.gname;
-        if (ex) {
-          this.#slurp(ex);
-        }
-        if (gex) {
-          this.#slurp(gex, true);
-        }
+      install() {
+        const self2 = this;
+        const hasRequireResolvePaths = typeof require.resolve.paths === "function";
+        this._previousModuleCompile = Module2.prototype._compile;
+        Module2.prototype._compile = function(content, filename) {
+          const mod = this;
+          function require2(id) {
+            return mod.require(id);
+          }
+          function resolve(request, options) {
+            return Module2._resolveFilename(request, mod, false, options);
+          }
+          require2.resolve = resolve;
+          if (hasRequireResolvePaths) {
+            resolve.paths = function paths(request) {
+              return Module2._resolveLookupPaths(request, mod, true);
+            };
+          }
+          require2.main = process.mainModule;
+          require2.extensions = Module2._extensions;
+          require2.cache = Module2._cache;
+          const dirname2 = path16.dirname(filename);
+          const compiledWrapper = self2._moduleCompile(filename, content);
+          const args = [mod.exports, require2, mod, filename, dirname2, process, global, Buffer];
+          return compiledWrapper.apply(mod.exports, args);
+        };
       }
-      write(data) {
-        const writeLen = data.length;
-        if (writeLen > this.blockRemain) {
-          throw new Error("writing more to entry than is appropriate");
+      uninstall() {
+        Module2.prototype._compile = this._previousModuleCompile;
+      }
+      _moduleCompile(filename, content) {
+        var contLen = content.length;
+        if (contLen >= 2) {
+          if (content.charCodeAt(0) === 35 && content.charCodeAt(1) === 33) {
+            if (contLen === 2) {
+              content = "";
+            } else {
+              var i = 2;
+              for (; i < contLen; ++i) {
+                var code2 = content.charCodeAt(i);
+                if (code2 === 10 || code2 === 13) break;
+              }
+              if (i === contLen) {
+                content = "";
+              } else {
+                content = content.slice(i);
+              }
+            }
+          }
         }
-        const r = this.remain;
-        const br = this.blockRemain;
-        this.remain = Math.max(0, r - writeLen);
-        this.blockRemain = Math.max(0, br - writeLen);
-        if (this.ignore) {
-          return true;
+        var wrapper = Module2.wrap(content);
+        var invalidationKey = crypto.createHash("sha1").update(content, "utf8").digest("hex");
+        var buffer = this._cacheStore.get(filename, invalidationKey);
+        var script = new vm.Script(wrapper, {
+          filename,
+          lineOffset: 0,
+          displayErrors: true,
+          cachedData: buffer,
+          produceCachedData: true
+        });
+        if (script.cachedDataProduced) {
+          this._cacheStore.set(filename, invalidationKey, script.cachedData);
+        } else if (script.cachedDataRejected) {
+          this._cacheStore.delete(filename);
         }
-        if (r >= writeLen) {
-          return super.write(data);
+        var compiledWrapper = script.runInThisContext({
+          filename,
+          lineOffset: 0,
+          columnOffset: 0,
+          displayErrors: true
+        });
+        return compiledWrapper;
+      }
+    };
+    function mkdirpSync(p_) {
+      _mkdirpSync(path16.resolve(p_), 511);
+    }
+    function _mkdirpSync(p, mode) {
+      try {
+        fs17.mkdirSync(p, mode);
+      } catch (err0) {
+        if (err0.code === "ENOENT") {
+          _mkdirpSync(path16.dirname(p));
+          _mkdirpSync(p);
+        } else {
+          try {
+            const stat = fs17.statSync(p);
+            if (!stat.isDirectory()) {
+              throw err0;
+            }
+          } catch (err1) {
+            throw err0;
+          }
         }
-        return super.write(data.subarray(0, r));
       }
-      #slurp(ex, gex = false) {
-        if (ex.path)
-          ex.path = normalizeWindowsPath(ex.path);
-        if (ex.linkpath)
-          ex.linkpath = normalizeWindowsPath(ex.linkpath);
-        Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => {
-          return !(v === null || v === void 0 || k === "path" && gex);
-        })));
+    }
+    function slashEscape(str) {
+      const ESCAPE_LOOKUP = {
+        "\\": "zB",
+        ":": "zC",
+        "/": "zS",
+        "\0": "z0",
+        "z": "zZ"
+      };
+      const ESCAPE_REGEX = /[\\:/\x00z]/g;
+      return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+    }
+    function supportsCachedData() {
+      const script = new vm.Script('""', { produceCachedData: true });
+      return script.cachedDataProduced === true;
+    }
+    function getCacheDir() {
+      const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR;
+      if (v8_compile_cache_cache_dir) {
+        return v8_compile_cache_cache_dir;
       }
+      const dirname2 = typeof process.getuid === "function" ? "v8-compile-cache-" + process.getuid() : "v8-compile-cache";
+      const arch = process.arch;
+      const version2 = typeof process.versions.v8 === "string" ? process.versions.v8 : typeof process.versions.chakracore === "string" ? "chakracore-" + process.versions.chakracore : "node-" + process.version;
+      const cacheDir = path16.join(os3.tmpdir(), dirname2, arch, version2);
+      return cacheDir;
+    }
+    function getMainName() {
+      const mainName = require.main && typeof require.main.filename === "string" ? require.main.filename : process.cwd();
+      return mainName;
+    }
+    if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) {
+      const cacheDir = getCacheDir();
+      const prefix = getMainName();
+      const blobStore = new FileSystemBlobStore(cacheDir, prefix);
+      const nativeCompileCache = new NativeCompileCache();
+      nativeCompileCache.setCacheStore(blobStore);
+      nativeCompileCache.install();
+      process.once("exit", () => {
+        if (blobStore.isDirty()) {
+          blobStore.save();
+        }
+        nativeCompileCache.uninstall();
+      });
+    }
+    module2.exports.__TEST__ = {
+      FileSystemBlobStore,
+      NativeCompileCache,
+      mkdirpSync,
+      slashEscape,
+      supportsCachedData,
+      getCacheDir,
+      getMainName
     };
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/warn-method.js
-var warnMethod;
-var init_warn_method = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/warn-method.js"() {
-    warnMethod = (self2, code2, message, data = {}) => {
-      if (self2.file) {
-        data.file = self2.file;
-      }
-      if (self2.cwd) {
-        data.cwd = self2.cwd;
-      }
-      data.code = message instanceof Error && message.code || code2;
-      data.tarCode = code2;
-      if (!self2.strict && data.recoverable !== false) {
-        if (message instanceof Error) {
-          data = Object.assign(message, data);
-          message = message.message;
-        }
-        self2.emit("warn", code2, message, data);
-      } else if (message instanceof Error) {
-        self2.emit("error", Object.assign(message, data));
-      } else {
-        self2.emit("error", Object.assign(new Error(`${code2}: ${message}`), data));
+// node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "node_modules/semver/functions/satisfies.js"(exports2, module2) {
+    "use strict";
+    var Range3 = require_range();
+    var satisfies = (version2, range, options) => {
+      try {
+        range = new Range3(range, options);
+      } catch (er) {
+        return false;
       }
+      return range.test(version2);
     };
+    module2.exports = satisfies;
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/parse.js
-var import_events3, maxMetaEntrySize, gzipHeader, zstdHeader, ZIP_HEADER_LEN, STATE, WRITEENTRY, READENTRY, NEXTENTRY, PROCESSENTRY, EX, GEX, META, EMITMETA, BUFFER2, QUEUE, ENDED, EMITTEDEND, EMIT, UNZIP, CONSUMECHUNK, CONSUMECHUNKSUB, CONSUMEBODY, CONSUMEMETA, CONSUMEHEADER, CONSUMING, BUFFERCONCAT, MAYBEEND, WRITING, ABORTED2, DONE, SAW_VALID_ENTRY, SAW_NULL_BLOCK, SAW_EOF, CLOSESTREAM, noop2, Parser;
-var init_parse = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/parse.js"() {
-    import_events3 = require("events");
-    init_esm3();
-    init_header();
-    init_pax();
-    init_read_entry();
-    init_warn_method();
-    maxMetaEntrySize = 1024 * 1024;
-    gzipHeader = Buffer.from([31, 139]);
-    zstdHeader = Buffer.from([40, 181, 47, 253]);
-    ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length);
-    STATE = /* @__PURE__ */ Symbol("state");
-    WRITEENTRY = /* @__PURE__ */ Symbol("writeEntry");
-    READENTRY = /* @__PURE__ */ Symbol("readEntry");
-    NEXTENTRY = /* @__PURE__ */ Symbol("nextEntry");
-    PROCESSENTRY = /* @__PURE__ */ Symbol("processEntry");
-    EX = /* @__PURE__ */ Symbol("extendedHeader");
-    GEX = /* @__PURE__ */ Symbol("globalExtendedHeader");
-    META = /* @__PURE__ */ Symbol("meta");
-    EMITMETA = /* @__PURE__ */ Symbol("emitMeta");
-    BUFFER2 = /* @__PURE__ */ Symbol("buffer");
-    QUEUE = /* @__PURE__ */ Symbol("queue");
-    ENDED = /* @__PURE__ */ Symbol("ended");
-    EMITTEDEND = /* @__PURE__ */ Symbol("emittedEnd");
-    EMIT = /* @__PURE__ */ Symbol("emit");
-    UNZIP = /* @__PURE__ */ Symbol("unzip");
-    CONSUMECHUNK = /* @__PURE__ */ Symbol("consumeChunk");
-    CONSUMECHUNKSUB = /* @__PURE__ */ Symbol("consumeChunkSub");
-    CONSUMEBODY = /* @__PURE__ */ Symbol("consumeBody");
-    CONSUMEMETA = /* @__PURE__ */ Symbol("consumeMeta");
-    CONSUMEHEADER = /* @__PURE__ */ Symbol("consumeHeader");
-    CONSUMING = /* @__PURE__ */ Symbol("consuming");
-    BUFFERCONCAT = /* @__PURE__ */ Symbol("bufferConcat");
-    MAYBEEND = /* @__PURE__ */ Symbol("maybeEnd");
-    WRITING = /* @__PURE__ */ Symbol("writing");
-    ABORTED2 = /* @__PURE__ */ Symbol("aborted");
-    DONE = /* @__PURE__ */ Symbol("onDone");
-    SAW_VALID_ENTRY = /* @__PURE__ */ Symbol("sawValidEntry");
-    SAW_NULL_BLOCK = /* @__PURE__ */ Symbol("sawNullBlock");
-    SAW_EOF = /* @__PURE__ */ Symbol("sawEOF");
-    CLOSESTREAM = /* @__PURE__ */ Symbol("closeStream");
-    noop2 = () => true;
-    Parser = class extends import_events3.EventEmitter {
-      file;
-      strict;
-      maxMetaEntrySize;
-      filter;
-      brotli;
-      zstd;
-      writable = true;
-      readable = false;
-      [QUEUE] = [];
-      [BUFFER2];
-      [READENTRY];
-      [WRITEENTRY];
-      [STATE] = "begin";
-      [META] = "";
-      [EX];
-      [GEX];
-      [ENDED] = false;
-      [UNZIP];
-      [ABORTED2] = false;
-      [SAW_VALID_ENTRY];
-      [SAW_NULL_BLOCK] = false;
-      [SAW_EOF] = false;
-      [WRITING] = false;
-      [CONSUMING] = false;
-      [EMITTEDEND] = false;
-      constructor(opt = {}) {
-        super();
-        this.file = opt.file || "";
-        this.on(DONE, () => {
-          if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) {
-            this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format");
-          }
-        });
-        if (opt.ondone) {
-          this.on(DONE, opt.ondone);
-        } else {
-          this.on(DONE, () => {
-            this.emit("prefinish");
-            this.emit("finish");
-            this.emit("end");
-          });
-        }
-        this.strict = !!opt.strict;
-        this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize;
-        this.filter = typeof opt.filter === "function" ? opt.filter : noop2;
-        const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr"));
-        this.brotli = !(opt.gzip || opt.zstd) && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false;
-        const isTZST = opt.file && (opt.file.endsWith(".tar.zst") || opt.file.endsWith(".tzst"));
-        this.zstd = !(opt.gzip || opt.brotli) && opt.zstd !== void 0 ? opt.zstd : isTZST ? true : void 0;
-        this.on("end", () => this[CLOSESTREAM]());
-        if (typeof opt.onwarn === "function") {
-          this.on("warn", opt.onwarn);
+// node_modules/which/node_modules/isexe/dist/commonjs/index.min.js
+var require_index_min = __commonJS({
+  "node_modules/which/node_modules/isexe/dist/commonjs/index.min.js"(exports2) {
+    "use strict";
+    var a = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports);
+    var _ = a((i) => {
+      "use strict";
+      Object.defineProperty(i, "__esModule", { value: true });
+      i.sync = i.isexe = void 0;
+      var M = require("node:fs"), x = require("node:fs/promises"), q = async (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return d(await (0, x.stat)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
         }
-        if (typeof opt.onReadEntry === "function") {
-          this.on("entry", opt.onReadEntry);
+      };
+      i.isexe = q;
+      var m = (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return d((0, M.statSync)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
         }
-      }
-      warn(code2, message, data = {}) {
-        warnMethod(this, code2, message, data);
-      }
-      [CONSUMEHEADER](chunk, position) {
-        if (this[SAW_VALID_ENTRY] === void 0) {
-          this[SAW_VALID_ENTRY] = false;
+      };
+      i.sync = m;
+      var d = (t, e) => t.isFile() && A(t, e), A = (t, e) => {
+        let r = e.uid ?? process.getuid?.(), s = e.groups ?? process.getgroups?.() ?? [], n = e.gid ?? process.getgid?.() ?? s[0];
+        if (r === void 0 || n === void 0) throw new Error("cannot get uid or gid");
+        let u = /* @__PURE__ */ new Set([n, ...s]), c = t.mode, S = t.uid, P = t.gid, f = parseInt("100", 8), l = parseInt("010", 8), j = parseInt("001", 8), C = f | l;
+        return !!(c & j || c & l && u.has(P) || c & f && S === r || c & C && r === 0);
+      };
+    });
+    var g = a((o) => {
+      "use strict";
+      Object.defineProperty(o, "__esModule", { value: true });
+      o.sync = o.isexe = void 0;
+      var T = require("node:fs"), I = require("node:fs/promises"), D = require("node:path"), F = async (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return y(await (0, I.stat)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
         }
-        let header;
+      };
+      o.isexe = F;
+      var L = (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
         try {
-          header = new Header(chunk, position, this[EX], this[GEX]);
-        } catch (er) {
-          return this.warn("TAR_ENTRY_INVALID", er);
+          return y((0, T.statSync)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
         }
-        if (header.nullBlock) {
-          if (this[SAW_NULL_BLOCK]) {
-            this[SAW_EOF] = true;
-            if (this[STATE] === "begin") {
-              this[STATE] = "header";
-            }
-            this[EMIT]("eof");
-          } else {
-            this[SAW_NULL_BLOCK] = true;
-            this[EMIT]("nullBlock");
-          }
-        } else {
-          this[SAW_NULL_BLOCK] = false;
-          if (!header.cksumValid) {
-            this.warn("TAR_ENTRY_INVALID", "checksum failure", { header });
-          } else if (!header.path) {
-            this.warn("TAR_ENTRY_INVALID", "path is required", { header });
-          } else {
-            const type = header.type;
-            if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) {
-              this.warn("TAR_ENTRY_INVALID", "linkpath required", {
-                header
-              });
-            } else if (!/^(Symbolic)?Link$/.test(type) && !/^(Global)?ExtendedHeader$/.test(type) && header.linkpath) {
-              this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", {
-                header
-              });
-            } else {
-              const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]);
-              if (!this[SAW_VALID_ENTRY]) {
-                if (entry.remain) {
-                  const onend = () => {
-                    if (!entry.invalid) {
-                      this[SAW_VALID_ENTRY] = true;
-                    }
-                  };
-                  entry.on("end", onend);
-                } else {
-                  this[SAW_VALID_ENTRY] = true;
-                }
-              }
-              if (entry.meta) {
-                if (entry.size > this.maxMetaEntrySize) {
-                  entry.ignore = true;
-                  this[EMIT]("ignoredEntry", entry);
-                  this[STATE] = "ignore";
-                  entry.resume();
-                } else if (entry.size > 0) {
-                  this[META] = "";
-                  entry.on("data", (c) => this[META] += c);
-                  this[STATE] = "meta";
-                }
-              } else {
-                this[EX] = void 0;
-                entry.ignore = entry.ignore || !this.filter(entry.path, entry);
-                if (entry.ignore) {
-                  this[EMIT]("ignoredEntry", entry);
-                  this[STATE] = entry.remain ? "ignore" : "header";
-                  entry.resume();
-                } else {
-                  if (entry.remain) {
-                    this[STATE] = "body";
-                  } else {
-                    this[STATE] = "header";
-                    entry.end();
-                  }
-                  if (!this[READENTRY]) {
-                    this[QUEUE].push(entry);
-                    this[NEXTENTRY]();
-                  } else {
-                    this[QUEUE].push(entry);
-                  }
-                }
-              }
-            }
-          }
+      };
+      o.sync = L;
+      var B = (t, e) => {
+        let { pathExt: r = process.env.PATHEXT || "" } = e, s = r.split(D.delimiter);
+        if (s.indexOf("") !== -1) return true;
+        for (let n of s) {
+          let u = n.toLowerCase(), c = t.substring(t.length - u.length).toLowerCase();
+          if (u && c === u) return true;
+        }
+        return false;
+      }, y = (t, e, r) => t.isFile() && B(e, r);
+    });
+    var p = a((h) => {
+      "use strict";
+      Object.defineProperty(h, "__esModule", { value: true });
+    });
+    var v = exports2 && exports2.__createBinding || (Object.create ? (function(t, e, r, s) {
+      s === void 0 && (s = r);
+      var n = Object.getOwnPropertyDescriptor(e, r);
+      (!n || ("get" in n ? !e.__esModule : n.writable || n.configurable)) && (n = { enumerable: true, get: function() {
+        return e[r];
+      } }), Object.defineProperty(t, s, n);
+    }) : (function(t, e, r, s) {
+      s === void 0 && (s = r), t[s] = e[r];
+    }));
+    var G = exports2 && exports2.__setModuleDefault || (Object.create ? (function(t, e) {
+      Object.defineProperty(t, "default", { enumerable: true, value: e });
+    }) : function(t, e) {
+      t.default = e;
+    });
+    var w = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var t = function(e) {
+        return t = Object.getOwnPropertyNames || function(r) {
+          var s = [];
+          for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && (s[s.length] = n);
+          return s;
+        }, t(e);
+      };
+      return function(e) {
+        if (e && e.__esModule) return e;
+        var r = {};
+        if (e != null) for (var s = t(e), n = 0; n < s.length; n++) s[n] !== "default" && v(r, e, s[n]);
+        return G(r, e), r;
+      };
+    })();
+    var X = exports2 && exports2.__exportStar || function(t, e) {
+      for (var r in t) r !== "default" && !Object.prototype.hasOwnProperty.call(e, r) && v(e, t, r);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
+    var E = w(_());
+    exports2.posix = E;
+    var O = w(g());
+    exports2.win32 = O;
+    X(p(), exports2);
+    var H = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+    var b = H === "win32" ? O : E;
+    exports2.isexe = b.isexe;
+    exports2.sync = b.sync;
+  }
+});
+
+// node_modules/which/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/which/lib/index.js"(exports2, module2) {
+    var { isexe, sync: isexeSync } = require_index_min();
+    var { join: join3, delimiter, sep, posix } = require("path");
+    var isWindows4 = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows4 ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows4) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
         }
+        return { pathEnv, pathExt, pathExtExe };
       }
-      [CLOSESTREAM]() {
-        queueMicrotask(() => this.emit("close"));
-      }
-      [PROCESSENTRY](entry) {
-        let go = true;
-        if (!entry) {
-          this[READENTRY] = void 0;
-          go = false;
-        } else if (Array.isArray(entry)) {
-          const [ev, ...args] = entry;
-          this.emit(ev, ...args);
-        } else {
-          this[READENTRY] = entry;
-          this.emit("entry", entry);
-          if (!entry.emittedEnd) {
-            entry.on("end", () => this[NEXTENTRY]());
-            go = false;
-          }
-        }
-        return go;
-      }
-      [NEXTENTRY]() {
-        do {
-        } while (this[PROCESSENTRY](this[QUEUE].shift()));
-        if (this[QUEUE].length === 0) {
-          const re = this[READENTRY];
-          const drainNow = !re || re.flowing || re.size === re.remain;
-          if (drainNow) {
-            if (!this[WRITING]) {
-              this.emit("drain");
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw2, cmd) => {
+      const pathPart = /^".*"$/.test(raw2) ? raw2.slice(1, -1) : raw2;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join3(pathPart, cmd);
+    };
+    var which3 = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
             }
-          } else {
-            re.once("drain", () => this.emit("drain"));
+            found.push(withExt);
           }
         }
       }
-      [CONSUMEBODY](chunk, position) {
-        const entry = this[WRITEENTRY];
-        if (!entry) {
-          throw new Error("attempt to consume body without entry??");
-        }
-        const br = entry.blockRemain ?? 0;
-        const c = br >= chunk.length && position === 0 ? chunk : chunk.subarray(position, position + br);
-        entry.write(c);
-        if (!entry.blockRemain) {
-          this[STATE] = "header";
-          this[WRITEENTRY] = void 0;
-          entry.end();
-        }
-        return c.length;
-      }
-      [CONSUMEMETA](chunk, position) {
-        const entry = this[WRITEENTRY];
-        const ret = this[CONSUMEBODY](chunk, position);
-        if (!this[WRITEENTRY] && entry) {
-          this[EMITMETA](entry);
-        }
-        return ret;
-      }
-      [EMIT](ev, data, extra) {
-        if (this[QUEUE].length === 0 && !this[READENTRY]) {
-          this.emit(ev, data, extra);
-        } else {
-          this[QUEUE].push([ev, data, extra]);
-        }
-      }
-      [EMITMETA](entry) {
-        this[EMIT]("meta", this[META]);
-        switch (entry.type) {
-          case "ExtendedHeader":
-          case "OldExtendedHeader":
-            this[EX] = Pax.parse(this[META], this[EX], false);
-            break;
-          case "GlobalExtendedHeader":
-            this[GEX] = Pax.parse(this[META], this[GEX], true);
-            break;
-          case "NextFileHasLongPath":
-          case "OldGnuLongPath": {
-            const ex = this[EX] ?? /* @__PURE__ */ Object.create(null);
-            this[EX] = ex;
-            ex.path = this[META].replace(/\0.*/, "");
-            break;
-          }
-          case "NextFileHasLongLinkpath": {
-            const ex = this[EX] || /* @__PURE__ */ Object.create(null);
-            this[EX] = ex;
-            ex.linkpath = this[META].replace(/\0.*/, "");
-            break;
-          }
-          /* c8 ignore start */
-          default:
-            throw new Error("unknown meta: " + entry.type);
-        }
+      if (opt.all && found.length) {
+        return found;
       }
-      abort(error) {
-        this[ABORTED2] = true;
-        this.emit("abort", error);
-        this.warn("TAR_ABORT", error, { recoverable: false });
+      if (opt.nothrow) {
+        return null;
       }
-      write(chunk, encoding, cb) {
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
-        }
-        if (typeof chunk === "string") {
-          chunk = Buffer.from(
-            chunk,
-            /* c8 ignore next */
-            typeof encoding === "string" ? encoding : "utf8"
-          );
-        }
-        if (this[ABORTED2]) {
-          cb?.();
-          return false;
-        }
-        const needSniff = this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false;
-        if (needSniff && chunk) {
-          if (this[BUFFER2]) {
-            chunk = Buffer.concat([this[BUFFER2], chunk]);
-            this[BUFFER2] = void 0;
-          }
-          if (chunk.length < ZIP_HEADER_LEN) {
-            this[BUFFER2] = chunk;
-            cb?.();
-            return true;
-          }
-          for (let i = 0; this[UNZIP] === void 0 && i < gzipHeader.length; i++) {
-            if (chunk[i] !== gzipHeader[i]) {
-              this[UNZIP] = false;
-            }
-          }
-          let isZstd = false;
-          if (this[UNZIP] === false && this.zstd !== false) {
-            isZstd = true;
-            for (let i = 0; i < zstdHeader.length; i++) {
-              if (chunk[i] !== zstdHeader[i]) {
-                isZstd = false;
-                break;
-              }
-            }
-          }
-          const maybeBrotli = this.brotli === void 0 && !isZstd;
-          if (this[UNZIP] === false && maybeBrotli) {
-            if (chunk.length < 512) {
-              if (this[ENDED]) {
-                this.brotli = true;
-              } else {
-                this[BUFFER2] = chunk;
-                cb?.();
-                return true;
-              }
-            } else {
-              try {
-                new Header(chunk.subarray(0, 512));
-                this.brotli = false;
-              } catch (_) {
-                this.brotli = true;
-              }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
             }
+            found.push(withExt);
           }
-          if (this[UNZIP] === void 0 || this[UNZIP] === false && (this.brotli || isZstd)) {
-            const ended = this[ENDED];
-            this[ENDED] = false;
-            this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : isZstd ? new ZstdDecompress({}) : new BrotliDecompress({});
-            this[UNZIP].on("data", (chunk2) => this[CONSUMECHUNK](chunk2));
-            this[UNZIP].on("error", (er) => this.abort(er));
-            this[UNZIP].on("end", () => {
-              this[ENDED] = true;
-              this[CONSUMECHUNK]();
-            });
-            this[WRITING] = true;
-            const ret2 = !!this[UNZIP][ended ? "end" : "write"](chunk);
-            this[WRITING] = false;
-            cb?.();
-            return ret2;
-          }
-        }
-        this[WRITING] = true;
-        if (this[UNZIP]) {
-          this[UNZIP].write(chunk);
-        } else {
-          this[CONSUMECHUNK](chunk);
-        }
-        this[WRITING] = false;
-        const ret = this[QUEUE].length > 0 ? false : this[READENTRY] ? this[READENTRY].flowing : true;
-        if (!ret && this[QUEUE].length === 0) {
-          this[READENTRY]?.once("drain", () => this.emit("drain"));
         }
-        cb?.();
-        return ret;
       }
-      [BUFFERCONCAT](c) {
-        if (c && !this[ABORTED2]) {
-          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([this[BUFFER2], c]) : c;
-        }
+      if (opt.all && found.length) {
+        return found;
       }
-      [MAYBEEND]() {
-        if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED2] && !this[CONSUMING]) {
-          this[EMITTEDEND] = true;
-          const entry = this[WRITEENTRY];
-          if (entry && entry.blockRemain) {
-            const have = this[BUFFER2] ? this[BUFFER2].length : 0;
-            this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry });
-            if (this[BUFFER2]) {
-              entry.write(this[BUFFER2]);
-            }
-            entry.end();
-          }
-          this[EMIT](DONE);
-        }
-      }
-      [CONSUMECHUNK](chunk) {
-        if (this[CONSUMING] && chunk) {
-          this[BUFFERCONCAT](chunk);
-        } else if (!chunk && !this[BUFFER2]) {
-          this[MAYBEEND]();
-        } else if (chunk) {
-          this[CONSUMING] = true;
-          if (this[BUFFER2]) {
-            this[BUFFERCONCAT](chunk);
-            const c = this[BUFFER2];
-            this[BUFFER2] = void 0;
-            this[CONSUMECHUNKSUB](c);
-          } else {
-            this[CONSUMECHUNKSUB](chunk);
-          }
-          while (this[BUFFER2] && this[BUFFER2]?.length >= 512 && !this[ABORTED2] && !this[SAW_EOF]) {
-            const c = this[BUFFER2];
-            this[BUFFER2] = void 0;
-            this[CONSUMECHUNKSUB](c);
-          }
-          this[CONSUMING] = false;
-        }
-        if (!this[BUFFER2] || this[ENDED]) {
-          this[MAYBEEND]();
-        }
-      }
-      [CONSUMECHUNKSUB](chunk) {
-        let position = 0;
-        const length = chunk.length;
-        while (position + 512 <= length && !this[ABORTED2] && !this[SAW_EOF]) {
-          switch (this[STATE]) {
-            case "begin":
-            case "header":
-              this[CONSUMEHEADER](chunk, position);
-              position += 512;
-              break;
-            case "ignore":
-            case "body":
-              position += this[CONSUMEBODY](chunk, position);
-              break;
-            case "meta":
-              position += this[CONSUMEMETA](chunk, position);
-              break;
-            /* c8 ignore start */
-            default:
-              throw new Error("invalid state: " + this[STATE]);
-          }
-        }
-        if (position < length) {
-          this[BUFFER2] = this[BUFFER2] ? Buffer.concat([chunk.subarray(position), this[BUFFER2]]) : chunk.subarray(position);
-        }
-      }
-      end(chunk, encoding, cb) {
-        if (typeof chunk === "function") {
-          cb = chunk;
-          encoding = void 0;
-          chunk = void 0;
-        }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
-        }
-        if (typeof chunk === "string") {
-          chunk = Buffer.from(chunk, encoding);
-        }
-        if (cb)
-          this.once("finish", cb);
-        if (!this[ABORTED2]) {
-          if (this[UNZIP]) {
-            if (chunk)
-              this[UNZIP].write(chunk);
-            this[UNZIP].end();
-          } else {
-            this[ENDED] = true;
-            if (this.brotli === void 0 || this.zstd === void 0)
-              chunk = chunk || Buffer.alloc(0);
-            if (chunk)
-              this.write(chunk);
-            this[MAYBEEND]();
-          }
-        }
-        return this;
+      if (opt.nothrow) {
+        return null;
       }
+      throw getNotFoundError(cmd);
     };
+    module2.exports = which3;
+    which3.sync = whichSync;
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js
-var stripTrailingSlashes;
-var init_strip_trailing_slashes = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js"() {
-    stripTrailingSlashes = (str) => {
-      let i = str.length - 1;
-      let slashesStart = -1;
-      while (i > -1 && str.charAt(i) === "/") {
-        slashesStart = i;
-        i--;
+// node_modules/is-windows/index.js
+var require_is_windows = __commonJS({
+  "node_modules/is-windows/index.js"(exports2, module2) {
+    (function(factory) {
+      if (exports2 && typeof exports2 === "object" && typeof module2 !== "undefined") {
+        module2.exports = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else if (typeof window !== "undefined") {
+        window.isWindows = factory();
+      } else if (typeof global !== "undefined") {
+        global.isWindows = factory();
+      } else if (typeof self !== "undefined") {
+        self.isWindows = factory();
+      } else {
+        this.isWindows = factory();
       }
-      return slashesStart === -1 ? str : str.slice(0, slashesStart);
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/list.js
-var list_exports = {};
-__export(list_exports, {
-  filesFilter: () => filesFilter,
-  list: () => list
-});
-var import_node_fs, import_path2, onReadEntryFunction, filesFilter, listFileSync, listFile, list;
-var init_list = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/list.js"() {
-    init_esm2();
-    import_node_fs = __toESM(require("node:fs"), 1);
-    import_path2 = require("path");
-    init_make_command();
-    init_parse();
-    init_strip_trailing_slashes();
-    onReadEntryFunction = (opt) => {
-      const onReadEntry = opt.onReadEntry;
-      opt.onReadEntry = onReadEntry ? (e) => {
-        onReadEntry(e);
-        e.resume();
-      } : (e) => e.resume();
-    };
-    filesFilter = (opt, files) => {
-      const map = new Map(files.map((f) => [stripTrailingSlashes(f), true]));
-      const filter = opt.filter;
-      const mapHas = (file, r = "") => {
-        const root = r || (0, import_path2.parse)(file).root || ".";
-        let ret;
-        if (file === root)
-          ret = false;
-        else {
-          const m = map.get(file);
-          ret = m !== void 0 ? m : mapHas((0, import_path2.dirname)(file), root);
-        }
-        map.set(file, ret);
-        return ret;
+    })(function() {
+      "use strict";
+      return function isWindows4() {
+        return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE));
       };
-      opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file)) : (file) => mapHas(stripTrailingSlashes(file));
-    };
-    listFileSync = (opt) => {
-      const p = new Parser(opt);
-      const file = opt.file;
-      let fd;
-      try {
-        fd = import_node_fs.default.openSync(file, "r");
-        const stat = import_node_fs.default.fstatSync(fd);
-        const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-        if (stat.size < readSize) {
-          const buf = Buffer.allocUnsafe(stat.size);
-          const read = import_node_fs.default.readSync(fd, buf, 0, stat.size, 0);
-          p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
-        } else {
-          let pos2 = 0;
-          const buf = Buffer.allocUnsafe(readSize);
-          while (pos2 < stat.size) {
-            const bytesRead = import_node_fs.default.readSync(fd, buf, 0, readSize, pos2);
-            if (bytesRead === 0)
-              break;
-            pos2 += bytesRead;
-            p.write(buf.subarray(0, bytesRead));
-          }
-          p.end();
-        }
-      } finally {
-        if (typeof fd === "number") {
-          try {
-            import_node_fs.default.closeSync(fd);
-          } catch {
-          }
-        }
-      }
-    };
-    listFile = (opt, _files) => {
-      const parse4 = new Parser(opt);
-      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-      const file = opt.file;
-      const p = new Promise((resolve, reject) => {
-        parse4.on("error", reject);
-        parse4.on("end", resolve);
-        import_node_fs.default.stat(file, (er, stat) => {
-          if (er) {
-            reject(er);
-          } else {
-            const stream = new ReadStream(file, {
-              readSize,
-              size: stat.size
-            });
-            stream.on("error", reject);
-            stream.pipe(parse4);
-          }
-        });
-      });
-      return p;
-    };
-    list = makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => {
-      if (files?.length)
-        filesFilter(opt, files);
-      if (!opt.noResume)
-        onReadEntryFunction(opt);
     });
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/get-write-flag.js
-var import_fs3, platform2, isWindows, O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, noFollowFlag, getWriteFlag;
-var init_get_write_flag = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/get-write-flag.js"() {
-    import_fs3 = __toESM(require("fs"), 1);
-    platform2 = process.env.__FAKE_PLATFORM__ || process.platform;
-    isWindows = platform2 === "win32";
-    ({ O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = import_fs3.default.constants);
-    UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs3.default.constants.UV_FS_O_FILEMAP || 0;
-    fMapEnabled = isWindows && !!UV_FS_O_FILEMAP;
-    fMapLimit = 512 * 1024;
-    fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY;
-    noFollowFlag = !isWindows && typeof O_NOFOLLOW === "number" ? O_NOFOLLOW | O_TRUNC | O_CREAT | O_WRONLY : null;
-    getWriteFlag = noFollowFlag !== null ? () => noFollowFlag : !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w";
+// node_modules/cmd-extension/index.js
+var require_cmd_extension = __commonJS({
+  "node_modules/cmd-extension/index.js"(exports2, module2) {
+    "use strict";
+    var path16 = require("path");
+    var cmdExtension;
+    if (process.env.PATHEXT) {
+      cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toUpperCase() === ".CMD");
+    }
+    module2.exports = cmdExtension || ".cmd";
   }
 });
 
-// .yarn/cache/chownr-npm-3.0.0-5275e85d25-43925b8770.zip/node_modules/chownr/dist/esm/index.js
-var import_node_fs2, import_node_path3, lchownSync, chown, chownrKid, chownr, chownrKidSync, chownrSync;
-var init_esm4 = __esm({
-  ".yarn/cache/chownr-npm-3.0.0-5275e85d25-43925b8770.zip/node_modules/chownr/dist/esm/index.js"() {
-    import_node_fs2 = __toESM(require("node:fs"), 1);
-    import_node_path3 = __toESM(require("node:path"), 1);
-    lchownSync = (path16, uid, gid) => {
-      try {
-        return import_node_fs2.default.lchownSync(path16, uid, gid);
-      } catch (er) {
-        if (er?.code !== "ENOENT")
-          throw er;
-      }
-    };
-    chown = (cpath, uid, gid, cb) => {
-      import_node_fs2.default.lchown(cpath, uid, gid, (er) => {
-        cb(er && er?.code !== "ENOENT" ? er : null);
-      });
-    };
-    chownrKid = (p, child, uid, gid, cb) => {
-      if (child.isDirectory()) {
-        chownr(import_node_path3.default.resolve(p, child.name), uid, gid, (er) => {
-          if (er)
-            return cb(er);
-          const cpath = import_node_path3.default.resolve(p, child.name);
-          chown(cpath, uid, gid, cb);
-        });
-      } else {
-        const cpath = import_node_path3.default.resolve(p, child.name);
-        chown(cpath, uid, gid, cb);
-      }
+// node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "node_modules/graceful-fs/polyfills.js"(exports2, module2) {
+    var constants2 = require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform5 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
     };
-    chownr = (p, uid, gid, cb) => {
-      import_node_fs2.default.readdir(p, { withFileTypes: true }, (er, children) => {
-        if (er) {
-          if (er.code === "ENOENT")
-            return cb();
-          else if (er.code !== "ENOTDIR" && er.code !== "ENOTSUP")
-            return cb(er);
-        }
-        if (er || !children.length)
-          return chown(p, uid, gid, cb);
-        let len = children.length;
-        let errState = null;
-        const then = (er2) => {
-          if (errState)
-            return;
-          if (er2)
-            return cb(errState = er2);
-          if (--len === 0)
-            return chown(p, uid, gid, cb);
-        };
-        for (const child of children) {
-          chownrKid(p, child, uid, gid, then);
-        }
-      });
-    };
-    chownrKidSync = (p, child, uid, gid) => {
-      if (child.isDirectory())
-        chownrSync(import_node_path3.default.resolve(p, child.name), uid, gid);
-      lchownSync(import_node_path3.default.resolve(p, child.name), uid, gid);
-    };
-    chownrSync = (p, uid, gid) => {
-      let children;
-      try {
-        children = import_node_fs2.default.readdirSync(p, { withFileTypes: true });
-      } catch (er) {
-        const e = er;
-        if (e?.code === "ENOENT")
-          return;
-        else if (e?.code === "ENOTDIR" || e?.code === "ENOTSUP")
-          return lchownSync(p, uid, gid);
-        else
-          throw e;
-      }
-      for (const child of children) {
-        chownrKidSync(p, child, uid, gid);
-      }
-      return lchownSync(p, uid, gid);
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/cwd-error.js
-var CwdError;
-var init_cwd_error = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/cwd-error.js"() {
-    CwdError = class extends Error {
-      path;
-      code;
-      syscall = "chdir";
-      constructor(path16, code2) {
-        super(`${code2}: Cannot cd into '${path16}'`);
-        this.path = path16;
-        this.code = code2;
-      }
-      get name() {
-        return "CwdError";
-      }
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/symlink-error.js
-var SymlinkError;
-var init_symlink_error = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/symlink-error.js"() {
-    SymlinkError = class extends Error {
-      path;
-      symlink;
-      syscall = "symlink";
-      code = "TAR_SYMLINK_ERROR";
-      constructor(symlink, path16) {
-        super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link");
-        this.symlink = symlink;
-        this.path = path16;
-      }
-      get name() {
-        return "SymlinkError";
-      }
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mkdir.js
-var import_node_fs3, import_promises, import_node_path4, checkCwd, mkdir, mkdir_, onmkdir, checkCwdSync, mkdirSync2;
-var init_mkdir = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mkdir.js"() {
-    init_esm4();
-    import_node_fs3 = __toESM(require("node:fs"), 1);
-    import_promises = __toESM(require("node:fs/promises"), 1);
-    import_node_path4 = __toESM(require("node:path"), 1);
-    init_cwd_error();
-    init_normalize_windows_path();
-    init_symlink_error();
-    checkCwd = (dir, cb) => {
-      import_node_fs3.default.stat(dir, (er, st) => {
-        if (er || !st.isDirectory()) {
-          er = new CwdError(dir, er?.code || "ENOTDIR");
-        }
-        cb(er);
-      });
-    };
-    mkdir = (dir, opt, cb) => {
-      dir = normalizeWindowsPath(dir);
-      const umask2 = opt.umask ?? 18;
-      const mode = opt.mode | 448;
-      const needChmod = (mode & umask2) !== 0;
-      const uid = opt.uid;
-      const gid = opt.gid;
-      const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
-      const preserve = opt.preserve;
-      const unlink = opt.unlink;
-      const cwd = normalizeWindowsPath(opt.cwd);
-      const done = (er, created) => {
-        if (er) {
-          cb(er);
-        } else {
-          if (created && doChown) {
-            chownr(created, uid, gid, (er2) => done(er2));
-          } else if (needChmod) {
-            import_node_fs3.default.chmod(dir, mode, cb);
-          } else {
-            cb();
-          }
-        }
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
       };
-      if (dir === cwd) {
-        return checkCwd(dir, done);
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs17) {
+      if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs17);
       }
-      if (preserve) {
-        return import_promises.default.mkdir(dir, { mode, recursive: true }).then(
-          (made) => done(null, made ?? void 0),
-          // oh, ts
-          done
-        );
+      if (!fs17.lutimes) {
+        patchLutimes(fs17);
       }
-      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
-      const parts = sub.split("/");
-      mkdir_(cwd, parts, mode, unlink, cwd, void 0, done);
-    };
-    mkdir_ = (base, parts, mode, unlink, cwd, created, cb) => {
-      if (parts.length === 0) {
-        return cb(null, created);
+      fs17.chown = chownFix(fs17.chown);
+      fs17.fchown = chownFix(fs17.fchown);
+      fs17.lchown = chownFix(fs17.lchown);
+      fs17.chmod = chmodFix(fs17.chmod);
+      fs17.fchmod = chmodFix(fs17.fchmod);
+      fs17.lchmod = chmodFix(fs17.lchmod);
+      fs17.chownSync = chownFixSync(fs17.chownSync);
+      fs17.fchownSync = chownFixSync(fs17.fchownSync);
+      fs17.lchownSync = chownFixSync(fs17.lchownSync);
+      fs17.chmodSync = chmodFixSync(fs17.chmodSync);
+      fs17.fchmodSync = chmodFixSync(fs17.fchmodSync);
+      fs17.lchmodSync = chmodFixSync(fs17.lchmodSync);
+      fs17.stat = statFix(fs17.stat);
+      fs17.fstat = statFix(fs17.fstat);
+      fs17.lstat = statFix(fs17.lstat);
+      fs17.statSync = statFixSync(fs17.statSync);
+      fs17.fstatSync = statFixSync(fs17.fstatSync);
+      fs17.lstatSync = statFixSync(fs17.lstatSync);
+      if (fs17.chmod && !fs17.lchmod) {
+        fs17.lchmod = function(path16, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs17.lchmodSync = function() {
+        };
       }
-      const p = parts.shift();
-      const part = normalizeWindowsPath(import_node_path4.default.resolve(base + "/" + p));
-      import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
-    };
-    onmkdir = (part, parts, mode, unlink, cwd, created, cb) => (er) => {
-      if (er) {
-        import_node_fs3.default.lstat(part, (statEr, st) => {
-          if (statEr) {
-            statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
-            cb(statEr);
-          } else if (st.isDirectory()) {
-            mkdir_(part, parts, mode, unlink, cwd, created, cb);
-          } else if (unlink) {
-            import_node_fs3.default.unlink(part, (er2) => {
-              if (er2) {
-                return cb(er2);
+      if (fs17.chown && !fs17.lchown) {
+        fs17.lchown = function(path16, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs17.lchownSync = function() {
+        };
+      }
+      if (platform5 === "win32") {
+        fs17.rename = typeof fs17.rename !== "function" ? fs17.rename : (function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs17.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
               }
-              import_node_fs3.default.mkdir(part, mode, onmkdir(part, parts, mode, unlink, cwd, created, cb));
+              if (cb) cb(er);
             });
-          } else if (st.isSymbolicLink()) {
-            return cb(new SymlinkError(part, part + "/" + parts.join("/")));
-          } else {
-            cb(er);
           }
-        });
-      } else {
-        created = created || part;
-        mkdir_(part, parts, mode, unlink, cwd, created, cb);
-      }
-    };
-    checkCwdSync = (dir) => {
-      let ok = false;
-      let code2;
-      try {
-        ok = import_node_fs3.default.statSync(dir).isDirectory();
-      } catch (er) {
-        code2 = er?.code;
-      } finally {
-        if (!ok) {
-          throw new CwdError(dir, code2 ?? "ENOTDIR");
-        }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        })(fs17.rename);
       }
-    };
-    mkdirSync2 = (dir, opt) => {
-      dir = normalizeWindowsPath(dir);
-      const umask2 = opt.umask ?? 18;
-      const mode = opt.mode | 448;
-      const needChmod = (mode & umask2) !== 0;
-      const uid = opt.uid;
-      const gid = opt.gid;
-      const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
-      const preserve = opt.preserve;
-      const unlink = opt.unlink;
-      const cwd = normalizeWindowsPath(opt.cwd);
-      const done = (created2) => {
-        if (created2 && doChown) {
-          chownrSync(created2, uid, gid);
+      fs17.read = typeof fs17.read !== "function" ? fs17.read : (function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
         }
-        if (needChmod) {
-          import_node_fs3.default.chmodSync(dir, mode);
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      })(fs17.read);
+      fs17.readSync = typeof fs17.readSync !== "function" ? fs17.readSync : /* @__PURE__ */ (function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs17, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      })(fs17.readSync);
+      function patchLchmod(fs18) {
+        fs18.lchmod = function(path16, mode, callback) {
+          fs18.open(
+            path16,
+            constants2.O_WRONLY | constants2.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs18.fchmod(fd, mode, function(err2) {
+                fs18.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs18.lchmodSync = function(path16, mode) {
+          var fd = fs18.openSync(path16, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs18.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs18.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs18.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs18) {
+        if (constants2.hasOwnProperty("O_SYMLINK") && fs18.futimes) {
+          fs18.lutimes = function(path16, at, mt, cb) {
+            fs18.open(path16, constants2.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs18.futimes(fd, at, mt, function(er2) {
+                fs18.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs18.lutimesSync = function(path16, at, mt) {
+            var fd = fs18.openSync(path16, constants2.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs18.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs18.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs18.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs18.futimes) {
+          fs18.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs18.lutimesSync = function() {
+          };
         }
-      };
-      if (dir === cwd) {
-        checkCwdSync(cwd);
-        return done();
       }
-      if (preserve) {
-        return done(import_node_fs3.default.mkdirSync(dir, { mode, recursive: true }) ?? void 0);
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs17, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
       }
-      const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir));
-      const parts = sub.split("/");
-      let created;
-      for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) {
-        part = normalizeWindowsPath(import_node_path4.default.resolve(part));
-        try {
-          import_node_fs3.default.mkdirSync(part, mode);
-          created = created || part;
-        } catch {
-          const st = import_node_fs3.default.lstatSync(part);
-          if (st.isDirectory()) {
-            continue;
-          } else if (unlink) {
-            import_node_fs3.default.unlinkSync(part);
-            import_node_fs3.default.mkdirSync(part, mode);
-            created = created || part;
-            continue;
-          } else if (st.isSymbolicLink()) {
-            return new SymlinkError(part, part + "/" + parts.join("/"));
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs17, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
           }
-        }
+        };
       }
-      return done(created);
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-absolute-path.js
-var import_node_path5, isAbsolute, parse3, stripAbsolutePath;
-var init_strip_absolute_path = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-absolute-path.js"() {
-    import_node_path5 = require("node:path");
-    ({ isAbsolute, parse: parse3 } = import_node_path5.win32);
-    stripAbsolutePath = (path16) => {
-      let r = "";
-      let parsed = parse3(path16);
-      while (isAbsolute(path16) || parsed.root) {
-        const root = path16.charAt(0) === "/" && path16.slice(0, 4) !== "//?/" ? "/" : parsed.root;
-        path16 = path16.slice(root.length);
-        r += root;
-        parsed = parse3(path16);
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs17, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
       }
-      return [r, path16];
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/winchars.js
-var raw, win, toWin, toRaw, encode2, decode;
-var init_winchars = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/winchars.js"() {
-    raw = ["|", "<", ">", "?", ":"];
-    win = raw.map((char) => String.fromCodePoint(61440 + Number(char.codePointAt(0))));
-    toWin = new Map(raw.map((char, i) => [char, win[i]]));
-    toRaw = new Map(win.map((char, i) => [char, raw[i]]));
-    encode2 = (s) => raw.reduce((s2, c) => s2.split(c).join(toWin.get(c)), s);
-    decode = (s) => win.reduce((s2, c) => s2.split(c).join(toRaw.get(c)), s);
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs17, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-unicode.js
-var normalizeCache, MAX, cache, normalizeUnicode;
-var init_normalize_unicode = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-unicode.js"() {
-    normalizeCache = /* @__PURE__ */ Object.create(null);
-    MAX = 1e4;
-    cache = /* @__PURE__ */ new Set();
-    normalizeUnicode = (s) => {
-      if (!cache.has(s)) {
-        normalizeCache[s] = s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en");
-      } else {
-        cache.delete(s);
-      }
-      cache.add(s);
-      const ret = normalizeCache[s];
-      let i = cache.size - MAX;
-      if (i > MAX / 10) {
-        for (const s2 of cache) {
-          cache.delete(s2);
-          delete normalizeCache[s2];
-          if (--i <= 0)
-            break;
-        }
-      }
-      return ret;
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/path-reservations.js
-var import_node_path6, platform3, isWindows2, getDirs, PathReservations;
-var init_path_reservations = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/path-reservations.js"() {
-    import_node_path6 = require("node:path");
-    init_normalize_unicode();
-    init_strip_trailing_slashes();
-    platform3 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-    isWindows2 = platform3 === "win32";
-    getDirs = (path16) => {
-      const dirs = path16.split("/").slice(0, -1).reduce((set, path17) => {
-        const s = set.at(-1);
-        if (s !== void 0) {
-          path17 = (0, import_node_path6.join)(s, path17);
+// node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
+    var Stream2 = require("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs17) {
+      return {
+        ReadStream: ReadStream2,
+        WriteStream: WriteStream2
+      };
+      function ReadStream2(path16, options) {
+        if (!(this instanceof ReadStream2)) return new ReadStream2(path16, options);
+        Stream2.call(this);
+        var self2 = this;
+        this.path = path16;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
         }
-        set.push(path17 || "/");
-        return set;
-      }, []);
-      return dirs;
-    };
-    PathReservations = class {
-      // path => [function or Set]
-      // A Set object means a directory reservation
-      // A fn is a direct reservation on that path
-      #queues = /* @__PURE__ */ new Map();
-      // fn => {paths:[path,...], dirs:[path, ...]}
-      #reservations = /* @__PURE__ */ new Map();
-      // functions currently running
-      #running = /* @__PURE__ */ new Set();
-      reserve(paths, fn2) {
-        paths = isWindows2 ? ["win32 parallelization disabled"] : paths.map((p) => {
-          return stripTrailingSlashes((0, import_node_path6.join)(normalizeUnicode(p)));
-        });
-        const dirs = new Set(paths.map((path16) => getDirs(path16)).reduce((a, b) => a.concat(b)));
-        this.#reservations.set(fn2, { dirs, paths });
-        for (const p of paths) {
-          const q = this.#queues.get(p);
-          if (!q) {
-            this.#queues.set(p, [fn2]);
-          } else {
-            q.push(fn2);
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
           }
-        }
-        for (const dir of dirs) {
-          const q = this.#queues.get(dir);
-          if (!q) {
-            this.#queues.set(dir, [/* @__PURE__ */ new Set([fn2])]);
-          } else {
-            const l = q.at(-1);
-            if (l instanceof Set) {
-              l.add(fn2);
-            } else {
-              q.push(/* @__PURE__ */ new Set([fn2]));
-            }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
           }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
         }
-        return this.#run(fn2);
-      }
-      // return the queues for each path the function cares about
-      // fn => {paths, dirs}
-      #getQueues(fn2) {
-        const res = this.#reservations.get(fn2);
-        if (!res) {
-          throw new Error("function does not have any path reservations");
-        }
-        return {
-          paths: res.paths.map((path16) => this.#queues.get(path16)),
-          dirs: [...res.dirs].map((path16) => this.#queues.get(path16))
-        };
-      }
-      // check if fn is first in line for all its paths, and is
-      // included in the first set for all its dir queues
-      check(fn2) {
-        const { paths, dirs } = this.#getQueues(fn2);
-        return paths.every((q) => q && q[0] === fn2) && dirs.every((q) => q && q[0] instanceof Set && q[0].has(fn2));
-      }
-      // run the function if it's first in line and not already running
-      #run(fn2) {
-        if (this.#running.has(fn2) || !this.check(fn2)) {
-          return false;
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self2._read();
+          });
+          return;
         }
-        this.#running.add(fn2);
-        fn2(() => this.#clear(fn2));
-        return true;
+        fs17.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self2.emit("error", err);
+            self2.readable = false;
+            return;
+          }
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2._read();
+        });
       }
-      #clear(fn2) {
-        if (!this.#running.has(fn2)) {
-          return false;
-        }
-        const res = this.#reservations.get(fn2);
-        if (!res) {
-          throw new Error("invalid reservation");
+      function WriteStream2(path16, options) {
+        if (!(this instanceof WriteStream2)) return new WriteStream2(path16, options);
+        Stream2.call(this);
+        this.path = path16;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
         }
-        const { paths, dirs } = res;
-        const next = /* @__PURE__ */ new Set();
-        for (const path16 of paths) {
-          const q = this.#queues.get(path16);
-          if (!q || q?.[0] !== fn2) {
-            continue;
-          }
-          const q0 = q[1];
-          if (!q0) {
-            this.#queues.delete(path16);
-            continue;
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
           }
-          q.shift();
-          if (typeof q0 === "function") {
-            next.add(q0);
-          } else {
-            for (const f of q0) {
-              next.add(f);
-            }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
           }
+          this.pos = this.start;
         }
-        for (const dir of dirs) {
-          const q = this.#queues.get(dir);
-          const q0 = q?.[0];
-          if (!q || !(q0 instanceof Set))
-            continue;
-          if (q0.size === 1 && q.length === 1) {
-            this.#queues.delete(dir);
-            continue;
-          } else if (q0.size === 1) {
-            q.shift();
-            const n = q[0];
-            if (typeof n === "function") {
-              next.add(n);
-            }
-          } else {
-            q0.delete(fn2);
-          }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs17.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
         }
-        this.#running.delete(fn2);
-        next.forEach((fn3) => this.#run(fn3));
-        return true;
       }
-    };
+    }
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/process-umask.js
-var umask;
-var init_process_umask = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/process-umask.js"() {
-    umask = () => process.umask();
+// node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "node_modules/graceful-fs/clone.js"(exports2, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/unpack.js
-var import_node_assert, import_node_crypto, import_node_fs4, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, ENSURE_NO_SYMLINK, UNSUPPORTED, CHECKPATH, STRIPABSOLUTEPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform4, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, Unpack, callSync, UnpackSync;
-var init_unpack = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/unpack.js"() {
-    init_esm2();
-    import_node_assert = __toESM(require("node:assert"), 1);
-    import_node_crypto = require("node:crypto");
-    import_node_fs4 = __toESM(require("node:fs"), 1);
-    import_node_path7 = __toESM(require("node:path"), 1);
-    init_get_write_flag();
-    init_mkdir();
-    init_normalize_windows_path();
-    init_parse();
-    init_strip_absolute_path();
-    init_winchars();
-    init_path_reservations();
-    init_symlink_error();
-    init_process_umask();
-    ONENTRY = /* @__PURE__ */ Symbol("onEntry");
-    CHECKFS = /* @__PURE__ */ Symbol("checkFs");
-    CHECKFS2 = /* @__PURE__ */ Symbol("checkFs2");
-    ISREUSABLE = /* @__PURE__ */ Symbol("isReusable");
-    MAKEFS = /* @__PURE__ */ Symbol("makeFs");
-    FILE = /* @__PURE__ */ Symbol("file");
-    DIRECTORY = /* @__PURE__ */ Symbol("directory");
-    LINK = /* @__PURE__ */ Symbol("link");
-    SYMLINK = /* @__PURE__ */ Symbol("symlink");
-    HARDLINK = /* @__PURE__ */ Symbol("hardlink");
-    ENSURE_NO_SYMLINK = /* @__PURE__ */ Symbol("ensureNoSymlink");
-    UNSUPPORTED = /* @__PURE__ */ Symbol("unsupported");
-    CHECKPATH = /* @__PURE__ */ Symbol("checkPath");
-    STRIPABSOLUTEPATH = /* @__PURE__ */ Symbol("stripAbsolutePath");
-    MKDIR = /* @__PURE__ */ Symbol("mkdir");
-    ONERROR = /* @__PURE__ */ Symbol("onError");
-    PENDING = /* @__PURE__ */ Symbol("pending");
-    PEND = /* @__PURE__ */ Symbol("pend");
-    UNPEND = /* @__PURE__ */ Symbol("unpend");
-    ENDED2 = /* @__PURE__ */ Symbol("ended");
-    MAYBECLOSE = /* @__PURE__ */ Symbol("maybeClose");
-    SKIP = /* @__PURE__ */ Symbol("skip");
-    DOCHOWN = /* @__PURE__ */ Symbol("doChown");
-    UID = /* @__PURE__ */ Symbol("uid");
-    GID = /* @__PURE__ */ Symbol("gid");
-    CHECKED_CWD = /* @__PURE__ */ Symbol("checkedCwd");
-    platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-    isWindows3 = platform4 === "win32";
-    DEFAULT_MAX_DEPTH = 1024;
-    unlinkFile = (path16, cb) => {
-      if (!isWindows3) {
-        return import_node_fs4.default.unlink(path16, cb);
-      }
-      const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex");
-      import_node_fs4.default.rename(path16, name2, (er) => {
-        if (er) {
-          return cb(er);
+// node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
+    var fs17 = require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
+      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop3() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
         }
-        import_node_fs4.default.unlink(name2, cb);
       });
-    };
-    unlinkFileSync = (path16) => {
-      if (!isWindows3) {
-        return import_node_fs4.default.unlinkSync(path16);
-      }
-      const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex");
-      import_node_fs4.default.renameSync(path16, name2);
-      import_node_fs4.default.unlinkSync(name2);
-    };
-    uint32 = (a, b, c) => a !== void 0 && a === a >>> 0 ? a : b !== void 0 && b === b >>> 0 ? b : c;
-    Unpack = class extends Parser {
-      [ENDED2] = false;
-      [CHECKED_CWD] = false;
-      [PENDING] = 0;
-      reservations = new PathReservations();
-      transform;
-      writable = true;
-      readable = false;
-      uid;
-      gid;
-      setOwner;
-      preserveOwner;
-      processGid;
-      processUid;
-      maxDepth;
-      forceChown;
-      win32;
-      newer;
-      keep;
-      noMtime;
-      preservePaths;
-      unlink;
-      cwd;
-      strip;
-      processUmask;
-      umask;
-      dmode;
-      fmode;
-      chmod;
-      constructor(opt = {}) {
-        opt.ondone = () => {
-          this[ENDED2] = true;
-          this[MAYBECLOSE]();
-        };
-        super(opt);
-        this.transform = opt.transform;
-        this.chmod = !!opt.chmod;
-        if (typeof opt.uid === "number" || typeof opt.gid === "number") {
-          if (typeof opt.uid !== "number" || typeof opt.gid !== "number") {
-            throw new TypeError("cannot set owner without number uid and gid");
-          }
-          if (opt.preserveOwner) {
-            throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
-          }
-          this.uid = opt.uid;
-          this.gid = opt.gid;
-          this.setOwner = true;
-        } else {
-          this.uid = void 0;
-          this.gid = void 0;
-          this.setOwner = false;
+    }
+    var debug = noop3;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs17[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs17, queue);
+      fs17.close = (function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs17, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
         }
-        this.preserveOwner = opt.preserveOwner === void 0 && typeof opt.uid !== "number" ? !!(process.getuid && process.getuid() === 0) : !!opt.preserveOwner;
-        this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0;
-        this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0;
-        this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH;
-        this.forceChown = opt.forceChown === true;
-        this.win32 = !!opt.win32 || isWindows3;
-        this.newer = !!opt.newer;
-        this.keep = !!opt.keep;
-        this.noMtime = !!opt.noMtime;
-        this.preservePaths = !!opt.preservePaths;
-        this.unlink = !!opt.unlink;
-        this.cwd = normalizeWindowsPath(import_node_path7.default.resolve(opt.cwd || process.cwd()));
-        this.strip = Number(opt.strip) || 0;
-        this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : umask();
-        this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask;
-        this.dmode = opt.dmode || 511 & ~this.umask;
-        this.fmode = opt.fmode || 438 & ~this.umask;
-        this.on("entry", (entry) => this[ONENTRY](entry));
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      })(fs17.close);
+      fs17.closeSync = (function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs17, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      })(fs17.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs17[gracefulQueue]);
+          require("assert").equal(fs17[gracefulQueue].length, 0);
+        });
       }
-      // a bad or damaged archive is a warning for Parser, but an error
-      // when extracting.  Mark those errors as unrecoverable, because
-      // the Unpack contract cannot be met.
-      warn(code2, msg, data = {}) {
-        if (code2 === "TAR_BAD_ARCHIVE" || code2 === "TAR_ABORT") {
-          data.recoverable = false;
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs17[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs17));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs17.__patched) {
+      module2.exports = patch(fs17);
+      fs17.__patched = true;
+    }
+    function patch(fs18) {
+      polyfills(fs18);
+      fs18.gracefulify = patch;
+      fs18.createReadStream = createReadStream;
+      fs18.createWriteStream = createWriteStream;
+      var fs$readFile = fs18.readFile;
+      fs18.readFile = readFile;
+      function readFile(path16, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path16, options, cb);
+        function go$readFile(path17, options2, cb2, startTime) {
+          return fs$readFile(path17, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
         }
-        return super.warn(code2, msg, data);
       }
-      [MAYBECLOSE]() {
-        if (this[ENDED2] && this[PENDING] === 0) {
-          this.emit("prefinish");
-          this.emit("finish");
-          this.emit("end");
+      var fs$writeFile = fs18.writeFile;
+      fs18.writeFile = writeFile;
+      function writeFile(path16, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path16, data, options, cb);
+        function go$writeFile(path17, data2, options2, cb2, startTime) {
+          return fs$writeFile(path17, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
         }
       }
-      // return false if we need to skip this file
-      // return true if the field was successfully sanitized
-      [STRIPABSOLUTEPATH](entry, field) {
-        const p = entry[field];
-        const { type } = entry;
-        if (!p || this.preservePaths)
-          return true;
-        const [root, stripped] = stripAbsolutePath(p);
-        const parts = stripped.replaceAll(/\\/g, "/").split("/");
-        if (parts.includes("..") || /* c8 ignore next */
-        isWindows3 && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) {
-          if (field === "path" || type === "Link") {
-            this.warn("TAR_ENTRY_ERROR", `${field} contains '..'`, {
-              entry,
-              [field]: p
-            });
-            return false;
-          }
-          const entryDir = import_node_path7.default.posix.dirname(entry.path);
-          const resolved = import_node_path7.default.posix.normalize(import_node_path7.default.posix.join(entryDir, parts.join("/")));
-          if (resolved.startsWith("../") || resolved === "..") {
-            this.warn("TAR_ENTRY_ERROR", `${field} escapes extraction directory`, {
-              entry,
-              [field]: p
-            });
-            return false;
-          }
-        }
-        if (root) {
-          entry[field] = String(stripped);
-          this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute ${field}`, {
-            entry,
-            [field]: p
-          });
-        }
-        return true;
-      }
-      // no IO, just string checking for absolute indicators
-      [CHECKPATH](entry) {
-        const p = normalizeWindowsPath(entry.path);
-        const parts = p.split("/");
-        if (this.strip) {
-          if (parts.length < this.strip) {
-            return false;
-          }
-          if (entry.type === "Link") {
-            const linkparts = normalizeWindowsPath(String(entry.linkpath)).split("/");
-            if (linkparts.length >= this.strip) {
-              entry.linkpath = linkparts.slice(this.strip).join("/");
-            } else {
-              return false;
+      var fs$appendFile = fs18.appendFile;
+      if (fs$appendFile)
+        fs18.appendFile = appendFile;
+      function appendFile(path16, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path16, data, options, cb);
+        function go$appendFile(path17, data2, options2, cb2, startTime) {
+          return fs$appendFile(path17, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
             }
-          }
-          parts.splice(0, this.strip);
-          entry.path = parts.join("/");
-        }
-        if (isFinite(this.maxDepth) && parts.length > this.maxDepth) {
-          this.warn("TAR_ENTRY_ERROR", "path excessively deep", {
-            entry,
-            path: p,
-            depth: parts.length,
-            maxDepth: this.maxDepth
-          });
-          return false;
-        }
-        if (!this[STRIPABSOLUTEPATH](entry, "path") || !this[STRIPABSOLUTEPATH](entry, "linkpath")) {
-          return false;
-        }
-        entry.absolute = import_node_path7.default.isAbsolute(entry.path) ? normalizeWindowsPath(import_node_path7.default.resolve(entry.path)) : normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path));
-        if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) {
-          this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", {
-            entry,
-            path: normalizeWindowsPath(entry.path),
-            resolvedPath: entry.absolute,
-            cwd: this.cwd
           });
-          return false;
-        }
-        if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") {
-          return false;
-        }
-        if (this.win32) {
-          const { root: aRoot } = import_node_path7.default.win32.parse(String(entry.absolute));
-          entry.absolute = aRoot + encode2(String(entry.absolute).slice(aRoot.length));
-          const { root: pRoot } = import_node_path7.default.win32.parse(entry.path);
-          entry.path = pRoot + encode2(entry.path.slice(pRoot.length));
         }
-        return true;
       }
-      [ONENTRY](entry) {
-        if (!this[CHECKPATH](entry)) {
-          return entry.resume();
+      var fs$copyFile = fs18.copyFile;
+      if (fs$copyFile)
+        fs18.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
         }
-        import_node_assert.default.equal(typeof entry.absolute, "string");
-        switch (entry.type) {
-          case "Directory":
-          case "GNUDumpDir":
-            if (entry.mode) {
-              entry.mode = entry.mode | 448;
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
             }
-          // eslint-disable-next-line no-fallthrough
-          case "File":
-          case "OldFile":
-          case "ContiguousFile":
-          case "Link":
-          case "SymbolicLink":
-            return this[CHECKFS](entry);
-          case "CharacterDevice":
-          case "BlockDevice":
-          case "FIFO":
-          default:
-            return this[UNSUPPORTED](entry);
-        }
-      }
-      [ONERROR](er, entry) {
-        if (er.name === "CwdError") {
-          this.emit("error", er);
-        } else {
-          this.warn("TAR_ENTRY_ERROR", er, { entry });
-          this[UNPEND]();
-          entry.resume();
+          });
         }
       }
-      [MKDIR](dir, mode, cb) {
-        mkdir(normalizeWindowsPath(dir), {
-          uid: this.uid,
-          gid: this.gid,
-          processUid: this.processUid,
-          processGid: this.processGid,
-          umask: this.processUmask,
-          preserve: this.preservePaths,
-          unlink: this.unlink,
-          cwd: this.cwd,
-          mode
-        }, cb);
-      }
-      [DOCHOWN](entry) {
-        return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid;
-      }
-      [UID](entry) {
-        return uint32(this.uid, entry.uid, this.processUid);
-      }
-      [GID](entry) {
-        return uint32(this.gid, entry.gid, this.processGid);
-      }
-      [FILE](entry, fullyDone) {
-        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
-        const stream = new WriteStream(String(entry.absolute), {
-          // slight lie, but it can be numeric flags
-          flags: getWriteFlag(entry.size),
-          mode,
-          autoClose: false
-        });
-        stream.on("error", (er) => {
-          if (stream.fd) {
-            import_node_fs4.default.close(stream.fd, () => {
-            });
-          }
-          stream.write = () => true;
-          this[ONERROR](er, entry);
-          fullyDone();
-        });
-        let actions = 1;
-        const done = (er) => {
-          if (er) {
-            if (stream.fd) {
-              import_node_fs4.default.close(stream.fd, () => {
-              });
-            }
-            this[ONERROR](er, entry);
-            fullyDone();
-            return;
-          }
-          if (--actions === 0) {
-            if (stream.fd !== void 0) {
-              import_node_fs4.default.close(stream.fd, (er2) => {
-                if (er2) {
-                  this[ONERROR](er2, entry);
-                } else {
-                  this[UNPEND]();
-                }
-                fullyDone();
-              });
-            }
-          }
+      var fs$readdir = fs18.readdir;
+      fs18.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path16, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, fs$readdirCallback(
+            path17,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path17, options2, cb2, startTime) {
+          return fs$readdir(path17, options2, fs$readdirCallback(
+            path17,
+            options2,
+            cb2,
+            startTime
+          ));
         };
-        stream.on("finish", () => {
-          const abs = String(entry.absolute);
-          const fd = stream.fd;
-          if (typeof fd === "number" && entry.mtime && !this.noMtime) {
-            actions++;
-            const atime = entry.atime || /* @__PURE__ */ new Date();
-            const mtime = entry.mtime;
-            import_node_fs4.default.futimes(fd, atime, mtime, (er) => er ? import_node_fs4.default.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done());
-          }
-          if (typeof fd === "number" && this[DOCHOWN](entry)) {
-            actions++;
-            const uid = this[UID](entry);
-            const gid = this[GID](entry);
-            if (typeof uid === "number" && typeof gid === "number") {
-              import_node_fs4.default.fchown(fd, uid, gid, (er) => er ? import_node_fs4.default.chown(abs, uid, gid, (er2) => done(er2 && er)) : done());
+        return go$readdir(path16, options, cb);
+        function fs$readdirCallback(path17, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path17, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
             }
-          }
-          done();
-        });
-        const tx = this.transform ? this.transform(entry) || entry : entry;
-        if (tx !== entry) {
-          tx.on("error", (er) => {
-            this[ONERROR](er, entry);
-            fullyDone();
-          });
-          entry.pipe(tx);
+          };
         }
-        tx.pipe(stream);
       }
-      [DIRECTORY](entry, fullyDone) {
-        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
-        this[MKDIR](String(entry.absolute), mode, (er) => {
-          if (er) {
-            this[ONERROR](er, entry);
-            fullyDone();
-            return;
-          }
-          let actions = 1;
-          const done = () => {
-            if (--actions === 0) {
-              fullyDone();
-              this[UNPEND]();
-              entry.resume();
-            }
-          };
-          if (entry.mtime && !this.noMtime) {
-            actions++;
-            import_node_fs4.default.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done);
-          }
-          if (this[DOCHOWN](entry)) {
-            actions++;
-            import_node_fs4.default.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done);
-          }
-          done();
-        });
-      }
-      [UNSUPPORTED](entry) {
-        entry.unsupported = true;
-        this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${entry.type}`, { entry });
-        entry.resume();
-      }
-      [SYMLINK](entry, done) {
-        const parts = normalizeWindowsPath(import_node_path7.default.relative(this.cwd, import_node_path7.default.resolve(import_node_path7.default.dirname(String(entry.absolute)), String(entry.linkpath)))).split("/");
-        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, String(entry.linkpath), "symlink", done), (er) => {
-          this[ONERROR](er, entry);
-          done();
-        });
-      }
-      [HARDLINK](entry, done) {
-        const linkpath = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, String(entry.linkpath)));
-        const parts = normalizeWindowsPath(String(entry.linkpath)).split("/");
-        this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, linkpath, "link", done), (er) => {
-          this[ONERROR](er, entry);
-          done();
-        });
-      }
-      [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) {
-        const p = parts.shift();
-        if (this.preservePaths || p === void 0)
-          return done();
-        const t = import_node_path7.default.resolve(cwd, p);
-        import_node_fs4.default.lstat(t, (er, st) => {
-          if (er)
-            return done();
-          if (st?.isSymbolicLink()) {
-            return onError(new SymlinkError(t, import_node_path7.default.resolve(t, parts.join("/"))));
-          }
-          this[ENSURE_NO_SYMLINK](entry, t, parts, done, onError);
-        });
-      }
-      [PEND]() {
-        this[PENDING]++;
-      }
-      [UNPEND]() {
-        this[PENDING]--;
-        this[MAYBECLOSE]();
-      }
-      [SKIP](entry) {
-        this[UNPEND]();
-        entry.resume();
-      }
-      // Check if we can reuse an existing filesystem entry safely and
-      // overwrite it, rather than unlinking and recreating
-      // Windows doesn't report a useful nlink, so we just never reuse entries
-      [ISREUSABLE](entry, st) {
-        return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows3;
-      }
-      // check if a thing is there, and if so, try to clobber it
-      [CHECKFS](entry) {
-        this[PEND]();
-        const paths = [entry.path];
-        if (entry.linkpath) {
-          paths.push(entry.linkpath);
-        }
-        this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done));
-      }
-      [CHECKFS2](entry, fullyDone) {
-        const done = (er) => {
-          fullyDone(er);
-        };
-        const checkCwd2 = () => {
-          this[MKDIR](this.cwd, this.dmode, (er) => {
-            if (er) {
-              this[ONERROR](er, entry);
-              done();
-              return;
-            }
-            this[CHECKED_CWD] = true;
-            start();
-          });
-        };
-        const start = () => {
-          if (entry.absolute !== this.cwd) {
-            const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute)));
-            if (parent !== this.cwd) {
-              return this[MKDIR](parent, this.dmode, (er) => {
-                if (er) {
-                  this[ONERROR](er, entry);
-                  done();
-                  return;
-                }
-                afterMakeParent();
-              });
-            }
-          }
-          afterMakeParent();
-        };
-        const afterMakeParent = () => {
-          import_node_fs4.default.lstat(String(entry.absolute), (lstatEr, st) => {
-            if (st && (this.keep || /* c8 ignore next */
-            this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
-              this[SKIP](entry);
-              done();
-              return;
-            }
-            if (lstatEr || this[ISREUSABLE](entry, st)) {
-              return this[MAKEFS](null, entry, done);
-            }
-            if (st.isDirectory()) {
-              if (entry.type === "Directory") {
-                const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
-                const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done);
-                if (!needChmod) {
-                  return afterChmod();
-                }
-                return import_node_fs4.default.chmod(String(entry.absolute), Number(entry.mode), afterChmod);
-              }
-              if (entry.absolute !== this.cwd) {
-                return import_node_fs4.default.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
-              }
-            }
-            if (entry.absolute === this.cwd) {
-              return this[MAKEFS](null, entry, done);
-            }
-            unlinkFile(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done));
-          });
-        };
-        if (this[CHECKED_CWD]) {
-          start();
-        } else {
-          checkCwd2();
-        }
-      }
-      [MAKEFS](er, entry, done) {
-        if (er) {
-          this[ONERROR](er, entry);
-          done();
-          return;
-        }
-        switch (entry.type) {
-          case "File":
-          case "OldFile":
-          case "ContiguousFile":
-            return this[FILE](entry, done);
-          case "Link":
-            return this[HARDLINK](entry, done);
-          case "SymbolicLink":
-            return this[SYMLINK](entry, done);
-          case "Directory":
-          case "GNUDumpDir":
-            return this[DIRECTORY](entry, done);
-        }
-      }
-      [LINK](entry, linkpath, link, done) {
-        import_node_fs4.default[link](linkpath, String(entry.absolute), (er) => {
-          if (er) {
-            this[ONERROR](er, entry);
-          } else {
-            this[UNPEND]();
-            entry.resume();
-          }
-          done();
-        });
-      }
-    };
-    callSync = (fn2) => {
-      try {
-        return [null, fn2()];
-      } catch (er) {
-        return [er, null];
-      }
-    };
-    UnpackSync = class extends Unpack {
-      sync = true;
-      [MAKEFS](er, entry) {
-        return super[MAKEFS](er, entry, () => {
-        });
-      }
-      [CHECKFS](entry) {
-        if (!this[CHECKED_CWD]) {
-          const er2 = this[MKDIR](this.cwd, this.dmode);
-          if (er2) {
-            return this[ONERROR](er2, entry);
-          }
-          this[CHECKED_CWD] = true;
-        }
-        if (entry.absolute !== this.cwd) {
-          const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute)));
-          if (parent !== this.cwd) {
-            const mkParent = this[MKDIR](parent, this.dmode);
-            if (mkParent) {
-              return this[ONERROR](mkParent, entry);
-            }
-          }
-        }
-        const [lstatEr, st] = callSync(() => import_node_fs4.default.lstatSync(String(entry.absolute)));
-        if (st && (this.keep || /* c8 ignore next */
-        this.newer && st.mtime > (entry.mtime ?? st.mtime))) {
-          return this[SKIP](entry);
-        }
-        if (lstatEr || this[ISREUSABLE](entry, st)) {
-          return this[MAKEFS](null, entry);
-        }
-        if (st.isDirectory()) {
-          if (entry.type === "Directory") {
-            const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode;
-            const [er3] = needChmod ? callSync(() => {
-              import_node_fs4.default.chmodSync(String(entry.absolute), Number(entry.mode));
-            }) : [];
-            return this[MAKEFS](er3, entry);
-          }
-          const [er2] = callSync(() => import_node_fs4.default.rmdirSync(String(entry.absolute)));
-          this[MAKEFS](er2, entry);
-        }
-        const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(String(entry.absolute)));
-        this[MAKEFS](er, entry);
-      }
-      [FILE](entry, done) {
-        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode;
-        const oner = (er) => {
-          let closeError;
-          try {
-            import_node_fs4.default.closeSync(fd);
-          } catch (e) {
-            closeError = e;
-          }
-          if (er || closeError) {
-            this[ONERROR](er || closeError, entry);
-          }
-          done();
-        };
-        let fd;
-        try {
-          fd = import_node_fs4.default.openSync(String(entry.absolute), getWriteFlag(entry.size), mode);
-        } catch (er) {
-          return oner(er);
-        }
-        const tx = this.transform ? this.transform(entry) || entry : entry;
-        if (tx !== entry) {
-          tx.on("error", (er) => this[ONERROR](er, entry));
-          entry.pipe(tx);
-        }
-        tx.on("data", (chunk) => {
-          try {
-            import_node_fs4.default.writeSync(fd, chunk, 0, chunk.length);
-          } catch (er) {
-            oner(er);
-          }
-        });
-        tx.on("end", () => {
-          let er = null;
-          if (entry.mtime && !this.noMtime) {
-            const atime = entry.atime || /* @__PURE__ */ new Date();
-            const mtime = entry.mtime;
-            try {
-              import_node_fs4.default.futimesSync(fd, atime, mtime);
-            } catch (futimeser) {
-              try {
-                import_node_fs4.default.utimesSync(String(entry.absolute), atime, mtime);
-              } catch {
-                er = futimeser;
-              }
-            }
-          }
-          if (this[DOCHOWN](entry)) {
-            const uid = this[UID](entry);
-            const gid = this[GID](entry);
-            try {
-              import_node_fs4.default.fchownSync(fd, Number(uid), Number(gid));
-            } catch (fchowner) {
-              try {
-                import_node_fs4.default.chownSync(String(entry.absolute), Number(uid), Number(gid));
-              } catch {
-                er = er || fchowner;
-              }
-            }
-          }
-          oner(er);
-        });
-      }
-      [DIRECTORY](entry, done) {
-        const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode;
-        const er = this[MKDIR](String(entry.absolute), mode);
-        if (er) {
-          this[ONERROR](er, entry);
-          done();
-          return;
-        }
-        if (entry.mtime && !this.noMtime) {
-          try {
-            import_node_fs4.default.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime);
-          } catch {
-          }
-        }
-        if (this[DOCHOWN](entry)) {
-          try {
-            import_node_fs4.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)));
-          } catch {
-          }
-        }
-        done();
-        entry.resume();
-      }
-      [MKDIR](dir, mode) {
-        try {
-          return mkdirSync2(normalizeWindowsPath(dir), {
-            uid: this.uid,
-            gid: this.gid,
-            processUid: this.processUid,
-            processGid: this.processGid,
-            umask: this.processUmask,
-            preserve: this.preservePaths,
-            unlink: this.unlink,
-            cwd: this.cwd,
-            mode
-          });
-        } catch (er) {
-          return er;
-        }
-      }
-      [ENSURE_NO_SYMLINK](_entry, cwd, parts, done, onError) {
-        if (this.preservePaths || parts.length === 0)
-          return done();
-        let t = cwd;
-        for (const p of parts) {
-          t = import_node_path7.default.resolve(t, p);
-          const [er, st] = callSync(() => import_node_fs4.default.lstatSync(t));
-          if (er)
-            return done();
-          if (st.isSymbolicLink()) {
-            return onError(new SymlinkError(t, import_node_path7.default.resolve(cwd, parts.join("/"))));
-          }
-        }
-        done();
-      }
-      [LINK](entry, linkpath, link, done) {
-        const linkSync = `${link}Sync`;
-        try {
-          import_node_fs4.default[linkSync](linkpath, String(entry.absolute));
-          done();
-          entry.resume();
-        } catch (er) {
-          return this[ONERROR](er, entry);
-        }
-      }
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/extract.js
-var extract_exports = {};
-__export(extract_exports, {
-  extract: () => extract
-});
-var import_node_fs5, extractFileSync, extractFile, extract;
-var init_extract = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/extract.js"() {
-    init_esm2();
-    import_node_fs5 = __toESM(require("node:fs"), 1);
-    init_list();
-    init_make_command();
-    init_unpack();
-    extractFileSync = (opt) => {
-      const u = new UnpackSync(opt);
-      const file = opt.file;
-      const stat = import_node_fs5.default.statSync(file);
-      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-      const stream = new ReadStreamSync(file, {
-        readSize,
-        size: stat.size
-      });
-      stream.pipe(u);
-    };
-    extractFile = (opt, _) => {
-      const u = new Unpack(opt);
-      const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-      const file = opt.file;
-      const p = new Promise((resolve, reject) => {
-        u.on("error", reject);
-        u.on("close", resolve);
-        import_node_fs5.default.stat(file, (er, stat) => {
-          if (er) {
-            reject(er);
-          } else {
-            const stream = new ReadStream(file, {
-              readSize,
-              size: stat.size
-            });
-            stream.on("error", reject);
-            stream.pipe(u);
-          }
-        });
-      });
-      return p;
-    };
-    extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(opt), (opt) => new Unpack(opt), (opt, files) => {
-      if (files?.length)
-        filesFilter(opt, files);
-    });
-  }
-});
-
-// .yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js
-var require_v8_compile_cache = __commonJS({
-  ".yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js"(exports2, module2) {
-    "use strict";
-    var Module2 = require("module");
-    var crypto = require("crypto");
-    var fs17 = require("fs");
-    var path16 = require("path");
-    var vm = require("vm");
-    var os3 = require("os");
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-    var FileSystemBlobStore = class {
-      constructor(directory, prefix) {
-        const name2 = prefix ? slashEscape(prefix + ".") : "";
-        this._blobFilename = path16.join(directory, name2 + "BLOB");
-        this._mapFilename = path16.join(directory, name2 + "MAP");
-        this._lockFilename = path16.join(directory, name2 + "LOCK");
-        this._directory = directory;
-        this._load();
-      }
-      has(key, invalidationKey) {
-        if (hasOwnProperty.call(this._memoryBlobs, key)) {
-          return this._invalidationKeys[key] === invalidationKey;
-        } else if (hasOwnProperty.call(this._storedMap, key)) {
-          return this._storedMap[key][0] === invalidationKey;
-        }
-        return false;
-      }
-      get(key, invalidationKey) {
-        if (hasOwnProperty.call(this._memoryBlobs, key)) {
-          if (this._invalidationKeys[key] === invalidationKey) {
-            return this._memoryBlobs[key];
-          }
-        } else if (hasOwnProperty.call(this._storedMap, key)) {
-          const mapping = this._storedMap[key];
-          if (mapping[0] === invalidationKey) {
-            return this._storedBlob.slice(mapping[1], mapping[2]);
-          }
-        }
-      }
-      set(key, invalidationKey, buffer) {
-        this._invalidationKeys[key] = invalidationKey;
-        this._memoryBlobs[key] = buffer;
-        this._dirty = true;
-      }
-      delete(key) {
-        if (hasOwnProperty.call(this._memoryBlobs, key)) {
-          this._dirty = true;
-          delete this._memoryBlobs[key];
-        }
-        if (hasOwnProperty.call(this._invalidationKeys, key)) {
-          this._dirty = true;
-          delete this._invalidationKeys[key];
-        }
-        if (hasOwnProperty.call(this._storedMap, key)) {
-          this._dirty = true;
-          delete this._storedMap[key];
-        }
-      }
-      isDirty() {
-        return this._dirty;
-      }
-      save() {
-        const dump = this._getDump();
-        const blobToStore = Buffer.concat(dump[0]);
-        const mapToStore = JSON.stringify(dump[1]);
-        try {
-          mkdirpSync(this._directory);
-          fs17.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" });
-        } catch (error) {
-          return false;
-        }
-        try {
-          fs17.writeFileSync(this._blobFilename, blobToStore);
-          fs17.writeFileSync(this._mapFilename, mapToStore);
-        } finally {
-          fs17.unlinkSync(this._lockFilename);
-        }
-        return true;
-      }
-      _load() {
-        try {
-          this._storedBlob = fs17.readFileSync(this._blobFilename);
-          this._storedMap = JSON.parse(fs17.readFileSync(this._mapFilename));
-        } catch (e) {
-          this._storedBlob = Buffer.alloc(0);
-          this._storedMap = {};
-        }
-        this._dirty = false;
-        this._memoryBlobs = {};
-        this._invalidationKeys = {};
-      }
-      _getDump() {
-        const buffers = [];
-        const newMap = {};
-        let offset = 0;
-        function push2(key, invalidationKey, buffer) {
-          buffers.push(buffer);
-          newMap[key] = [invalidationKey, offset, offset + buffer.length];
-          offset += buffer.length;
-        }
-        for (const key of Object.keys(this._memoryBlobs)) {
-          const buffer = this._memoryBlobs[key];
-          const invalidationKey = this._invalidationKeys[key];
-          push2(key, invalidationKey, buffer);
-        }
-        for (const key of Object.keys(this._storedMap)) {
-          if (hasOwnProperty.call(newMap, key)) continue;
-          const mapping = this._storedMap[key];
-          const buffer = this._storedBlob.slice(mapping[1], mapping[2]);
-          push2(key, mapping[0], buffer);
-        }
-        return [buffers, newMap];
-      }
-    };
-    var NativeCompileCache = class {
-      constructor() {
-        this._cacheStore = null;
-        this._previousModuleCompile = null;
-      }
-      setCacheStore(cacheStore) {
-        this._cacheStore = cacheStore;
-      }
-      install() {
-        const self2 = this;
-        const hasRequireResolvePaths = typeof require.resolve.paths === "function";
-        this._previousModuleCompile = Module2.prototype._compile;
-        Module2.prototype._compile = function(content, filename) {
-          const mod = this;
-          function require2(id) {
-            return mod.require(id);
-          }
-          function resolve(request, options) {
-            return Module2._resolveFilename(request, mod, false, options);
-          }
-          require2.resolve = resolve;
-          if (hasRequireResolvePaths) {
-            resolve.paths = function paths(request) {
-              return Module2._resolveLookupPaths(request, mod, true);
-            };
-          }
-          require2.main = process.mainModule;
-          require2.extensions = Module2._extensions;
-          require2.cache = Module2._cache;
-          const dirname2 = path16.dirname(filename);
-          const compiledWrapper = self2._moduleCompile(filename, content);
-          const args = [mod.exports, require2, mod, filename, dirname2, process, global, Buffer];
-          return compiledWrapper.apply(mod.exports, args);
-        };
-      }
-      uninstall() {
-        Module2.prototype._compile = this._previousModuleCompile;
-      }
-      _moduleCompile(filename, content) {
-        var contLen = content.length;
-        if (contLen >= 2) {
-          if (content.charCodeAt(0) === 35 && content.charCodeAt(1) === 33) {
-            if (contLen === 2) {
-              content = "";
-            } else {
-              var i = 2;
-              for (; i < contLen; ++i) {
-                var code2 = content.charCodeAt(i);
-                if (code2 === 10 || code2 === 13) break;
-              }
-              if (i === contLen) {
-                content = "";
-              } else {
-                content = content.slice(i);
-              }
-            }
-          }
-        }
-        var wrapper = Module2.wrap(content);
-        var invalidationKey = crypto.createHash("sha1").update(content, "utf8").digest("hex");
-        var buffer = this._cacheStore.get(filename, invalidationKey);
-        var script = new vm.Script(wrapper, {
-          filename,
-          lineOffset: 0,
-          displayErrors: true,
-          cachedData: buffer,
-          produceCachedData: true
-        });
-        if (script.cachedDataProduced) {
-          this._cacheStore.set(filename, invalidationKey, script.cachedData);
-        } else if (script.cachedDataRejected) {
-          this._cacheStore.delete(filename);
-        }
-        var compiledWrapper = script.runInThisContext({
-          filename,
-          lineOffset: 0,
-          columnOffset: 0,
-          displayErrors: true
-        });
-        return compiledWrapper;
-      }
-    };
-    function mkdirpSync(p_) {
-      _mkdirpSync(path16.resolve(p_), 511);
-    }
-    function _mkdirpSync(p, mode) {
-      try {
-        fs17.mkdirSync(p, mode);
-      } catch (err0) {
-        if (err0.code === "ENOENT") {
-          _mkdirpSync(path16.dirname(p));
-          _mkdirpSync(p);
-        } else {
-          try {
-            const stat = fs17.statSync(p);
-            if (!stat.isDirectory()) {
-              throw err0;
-            }
-          } catch (err1) {
-            throw err0;
-          }
-        }
-      }
-    }
-    function slashEscape(str) {
-      const ESCAPE_LOOKUP = {
-        "\\": "zB",
-        ":": "zC",
-        "/": "zS",
-        "\0": "z0",
-        "z": "zZ"
-      };
-      const ESCAPE_REGEX = /[\\:/\x00z]/g;
-      return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
-    }
-    function supportsCachedData() {
-      const script = new vm.Script('""', { produceCachedData: true });
-      return script.cachedDataProduced === true;
-    }
-    function getCacheDir() {
-      const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR;
-      if (v8_compile_cache_cache_dir) {
-        return v8_compile_cache_cache_dir;
-      }
-      const dirname2 = typeof process.getuid === "function" ? "v8-compile-cache-" + process.getuid() : "v8-compile-cache";
-      const arch = process.arch;
-      const version2 = typeof process.versions.v8 === "string" ? process.versions.v8 : typeof process.versions.chakracore === "string" ? "chakracore-" + process.versions.chakracore : "node-" + process.version;
-      const cacheDir = path16.join(os3.tmpdir(), dirname2, arch, version2);
-      return cacheDir;
-    }
-    function getMainName() {
-      const mainName = require.main && typeof require.main.filename === "string" ? require.main.filename : process.cwd();
-      return mainName;
-    }
-    if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) {
-      const cacheDir = getCacheDir();
-      const prefix = getMainName();
-      const blobStore = new FileSystemBlobStore(cacheDir, prefix);
-      const nativeCompileCache = new NativeCompileCache();
-      nativeCompileCache.setCacheStore(blobStore);
-      nativeCompileCache.install();
-      process.once("exit", () => {
-        if (blobStore.isDirty()) {
-          blobStore.save();
-        }
-        nativeCompileCache.uninstall();
-      });
-    }
-    module2.exports.__TEST__ = {
-      FileSystemBlobStore,
-      NativeCompileCache,
-      mkdirpSync,
-      slashEscape,
-      supportsCachedData,
-      getCacheDir,
-      getMainName
-    };
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/satisfies.js
-var require_satisfies = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/satisfies.js"(exports2, module2) {
-    "use strict";
-    var Range3 = require_range();
-    var satisfies = (version2, range, options) => {
-      try {
-        range = new Range3(range, options);
-      } catch (er) {
-        return false;
-      }
-      return range.test(version2);
-    };
-    module2.exports = satisfies;
-  }
-});
-
-// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js
-var require_posix = __commonJS({
-  ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.sync = exports2.isexe = void 0;
-    var fs_1 = require("fs");
-    var promises_1 = require("fs/promises");
-    var isexe = async (path16, options = {}) => {
-      const { ignoreErrors = false } = options;
-      try {
-        return checkStat(await (0, promises_1.stat)(path16), options);
-      } catch (e) {
-        const er = e;
-        if (ignoreErrors || er.code === "EACCES")
-          return false;
-        throw er;
-      }
-    };
-    exports2.isexe = isexe;
-    var sync = (path16, options = {}) => {
-      const { ignoreErrors = false } = options;
-      try {
-        return checkStat((0, fs_1.statSync)(path16), options);
-      } catch (e) {
-        const er = e;
-        if (ignoreErrors || er.code === "EACCES")
-          return false;
-        throw er;
-      }
-    };
-    exports2.sync = sync;
-    var checkStat = (stat, options) => stat.isFile() && checkMode(stat, options);
-    var checkMode = (stat, options) => {
-      const myUid = options.uid ?? process.getuid?.();
-      const myGroups = options.groups ?? process.getgroups?.() ?? [];
-      const myGid = options.gid ?? process.getgid?.() ?? myGroups[0];
-      if (myUid === void 0 || myGid === void 0) {
-        throw new Error("cannot get uid or gid");
-      }
-      const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
-      const mod = stat.mode;
-      const uid = stat.uid;
-      const gid = stat.gid;
-      const u = parseInt("100", 8);
-      const g = parseInt("010", 8);
-      const o = parseInt("001", 8);
-      const ug = u | g;
-      return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
-    };
-  }
-});
-
-// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js
-var require_win32 = __commonJS({
-  ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.sync = exports2.isexe = void 0;
-    var fs_1 = require("fs");
-    var promises_1 = require("fs/promises");
-    var isexe = async (path16, options = {}) => {
-      const { ignoreErrors = false } = options;
-      try {
-        return checkStat(await (0, promises_1.stat)(path16), path16, options);
-      } catch (e) {
-        const er = e;
-        if (ignoreErrors || er.code === "EACCES")
-          return false;
-        throw er;
-      }
-    };
-    exports2.isexe = isexe;
-    var sync = (path16, options = {}) => {
-      const { ignoreErrors = false } = options;
-      try {
-        return checkStat((0, fs_1.statSync)(path16), path16, options);
-      } catch (e) {
-        const er = e;
-        if (ignoreErrors || er.code === "EACCES")
-          return false;
-        throw er;
-      }
-    };
-    exports2.sync = sync;
-    var checkPathExt = (path16, options) => {
-      const { pathExt = process.env.PATHEXT || "" } = options;
-      const peSplit = pathExt.split(";");
-      if (peSplit.indexOf("") !== -1) {
-        return true;
-      }
-      for (let i = 0; i < peSplit.length; i++) {
-        const p = peSplit[i].toLowerCase();
-        const ext = path16.substring(path16.length - p.length).toLowerCase();
-        if (p && ext === p) {
-          return true;
-        }
-      }
-      return false;
-    };
-    var checkStat = (stat, path16, options) => stat.isFile() && checkPathExt(path16, options);
-  }
-});
-
-// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js
-var require_options = __commonJS({
-  ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-  }
-});
-
-// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js
-var require_cjs = __commonJS({
-  ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc2 = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc2 || ("get" in desc2 ? !m.__esModule : desc2.writable || desc2.configurable)) {
-        desc2 = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc2);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || function(mod) {
-      if (mod && mod.__esModule) return mod;
-      var result = {};
-      if (mod != null) {
-        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-      }
-      __setModuleDefault(result, mod);
-      return result;
-    };
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0;
-    var posix = __importStar(require_posix());
-    exports2.posix = posix;
-    var win322 = __importStar(require_win32());
-    exports2.win32 = win322;
-    __exportStar(require_options(), exports2);
-    var platform5 = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
-    var impl = platform5 === "win32" ? win322 : posix;
-    exports2.isexe = impl.isexe;
-    exports2.sync = impl.sync;
-  }
-});
-
-// .yarn/cache/which-npm-5.0.0-15aa39eb60-e556e4cd8b.zip/node_modules/which/lib/index.js
-var require_lib = __commonJS({
-  ".yarn/cache/which-npm-5.0.0-15aa39eb60-e556e4cd8b.zip/node_modules/which/lib/index.js"(exports2, module2) {
-    var { isexe, sync: isexeSync } = require_cjs();
-    var { join: join3, delimiter, sep, posix } = require("path");
-    var isWindows4 = process.platform === "win32";
-    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
-    var rRel = new RegExp(`^\\.${rSlash.source}`);
-    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-    var getPathInfo = (cmd, {
-      path: optPath = process.env.PATH,
-      pathExt: optPathExt = process.env.PATHEXT,
-      delimiter: optDelimiter = delimiter
-    }) => {
-      const pathEnv = cmd.match(rSlash) ? [""] : [
-        // windows always checks the cwd first
-        ...isWindows4 ? [process.cwd()] : [],
-        ...(optPath || /* istanbul ignore next: very unusual */
-        "").split(optDelimiter)
-      ];
-      if (isWindows4) {
-        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
-        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
-        if (cmd.includes(".") && pathExt[0] !== "") {
-          pathExt.unshift("");
-        }
-        return { pathEnv, pathExt, pathExtExe };
-      }
-      return { pathEnv, pathExt: [""] };
-    };
-    var getPathPart = (raw2, cmd) => {
-      const pathPart = /^".*"$/.test(raw2) ? raw2.slice(1, -1) : raw2;
-      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join3(pathPart, cmd);
-    };
-    var which3 = async (cmd, opt = {}) => {
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (const envPart of pathEnv) {
-        const p = getPathPart(envPart, cmd);
-        for (const ext of pathExt) {
-          const withExt = p + ext;
-          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is) {
-            if (!opt.all) {
-              return withExt;
-            }
-            found.push(withExt);
-          }
-        }
-      }
-      if (opt.all && found.length) {
-        return found;
-      }
-      if (opt.nothrow) {
-        return null;
-      }
-      throw getNotFoundError(cmd);
-    };
-    var whichSync = (cmd, opt = {}) => {
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (const pathEnvPart of pathEnv) {
-        const p = getPathPart(pathEnvPart, cmd);
-        for (const ext of pathExt) {
-          const withExt = p + ext;
-          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is) {
-            if (!opt.all) {
-              return withExt;
-            }
-            found.push(withExt);
-          }
-        }
-      }
-      if (opt.all && found.length) {
-        return found;
-      }
-      if (opt.nothrow) {
-        return null;
-      }
-      throw getNotFoundError(cmd);
-    };
-    module2.exports = which3;
-    which3.sync = whichSync;
-  }
-});
-
-// .yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js
-var require_is_windows = __commonJS({
-  ".yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js"(exports2, module2) {
-    (function(factory) {
-      if (exports2 && typeof exports2 === "object" && typeof module2 !== "undefined") {
-        module2.exports = factory();
-      } else if (typeof define === "function" && define.amd) {
-        define([], factory);
-      } else if (typeof window !== "undefined") {
-        window.isWindows = factory();
-      } else if (typeof global !== "undefined") {
-        global.isWindows = factory();
-      } else if (typeof self !== "undefined") {
-        self.isWindows = factory();
-      } else {
-        this.isWindows = factory();
-      }
-    })(function() {
-      "use strict";
-      return function isWindows4() {
-        return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE));
-      };
-    });
-  }
-});
-
-// .yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js
-var require_cmd_extension = __commonJS({
-  ".yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js"(exports2, module2) {
-    "use strict";
-    var path16 = require("path");
-    var cmdExtension;
-    if (process.env.PATHEXT) {
-      cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toUpperCase() === ".CMD");
-    }
-    module2.exports = cmdExtension || ".cmd";
-  }
-});
-
-// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js
-var require_polyfills = __commonJS({
-  ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
-    var constants2 = require("constants");
-    var origCwd = process.cwd;
-    var cwd = null;
-    var platform5 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-    process.cwd = function() {
-      if (!cwd)
-        cwd = origCwd.call(process);
-      return cwd;
-    };
-    try {
-      process.cwd();
-    } catch (er) {
-    }
-    if (typeof process.chdir === "function") {
-      chdir = process.chdir;
-      process.chdir = function(d) {
-        cwd = null;
-        chdir.call(process, d);
-      };
-      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
-    }
-    var chdir;
-    module2.exports = patch;
-    function patch(fs17) {
-      if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs17);
-      }
-      if (!fs17.lutimes) {
-        patchLutimes(fs17);
-      }
-      fs17.chown = chownFix(fs17.chown);
-      fs17.fchown = chownFix(fs17.fchown);
-      fs17.lchown = chownFix(fs17.lchown);
-      fs17.chmod = chmodFix(fs17.chmod);
-      fs17.fchmod = chmodFix(fs17.fchmod);
-      fs17.lchmod = chmodFix(fs17.lchmod);
-      fs17.chownSync = chownFixSync(fs17.chownSync);
-      fs17.fchownSync = chownFixSync(fs17.fchownSync);
-      fs17.lchownSync = chownFixSync(fs17.lchownSync);
-      fs17.chmodSync = chmodFixSync(fs17.chmodSync);
-      fs17.fchmodSync = chmodFixSync(fs17.fchmodSync);
-      fs17.lchmodSync = chmodFixSync(fs17.lchmodSync);
-      fs17.stat = statFix(fs17.stat);
-      fs17.fstat = statFix(fs17.fstat);
-      fs17.lstat = statFix(fs17.lstat);
-      fs17.statSync = statFixSync(fs17.statSync);
-      fs17.fstatSync = statFixSync(fs17.fstatSync);
-      fs17.lstatSync = statFixSync(fs17.lstatSync);
-      if (fs17.chmod && !fs17.lchmod) {
-        fs17.lchmod = function(path16, mode, cb) {
-          if (cb) process.nextTick(cb);
-        };
-        fs17.lchmodSync = function() {
-        };
-      }
-      if (fs17.chown && !fs17.lchown) {
-        fs17.lchown = function(path16, uid, gid, cb) {
-          if (cb) process.nextTick(cb);
-        };
-        fs17.lchownSync = function() {
-        };
-      }
-      if (platform5 === "win32") {
-        fs17.rename = typeof fs17.rename !== "function" ? fs17.rename : (function(fs$rename) {
-          function rename(from, to, cb) {
-            var start = Date.now();
-            var backoff = 0;
-            fs$rename(from, to, function CB(er) {
-              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
-                setTimeout(function() {
-                  fs17.stat(to, function(stater, st) {
-                    if (stater && stater.code === "ENOENT")
-                      fs$rename(from, to, CB);
-                    else
-                      cb(er);
-                  });
-                }, backoff);
-                if (backoff < 100)
-                  backoff += 10;
-                return;
-              }
-              if (cb) cb(er);
-            });
-          }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-          return rename;
-        })(fs17.rename);
-      }
-      fs17.read = typeof fs17.read !== "function" ? fs17.read : (function(fs$read) {
-        function read(fd, buffer, offset, length, position, callback_) {
-          var callback;
-          if (callback_ && typeof callback_ === "function") {
-            var eagCounter = 0;
-            callback = function(er, _, __) {
-              if (er && er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
-              }
-              callback_.apply(this, arguments);
-            };
-          }
-          return fs$read.call(fs17, fd, buffer, offset, length, position, callback);
-        }
-        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-        return read;
-      })(fs17.read);
-      fs17.readSync = typeof fs17.readSync !== "function" ? fs17.readSync : /* @__PURE__ */ (function(fs$readSync) {
-        return function(fd, buffer, offset, length, position) {
-          var eagCounter = 0;
-          while (true) {
-            try {
-              return fs$readSync.call(fs17, fd, buffer, offset, length, position);
-            } catch (er) {
-              if (er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                continue;
-              }
-              throw er;
-            }
-          }
-        };
-      })(fs17.readSync);
-      function patchLchmod(fs18) {
-        fs18.lchmod = function(path16, mode, callback) {
-          fs18.open(
-            path16,
-            constants2.O_WRONLY | constants2.O_SYMLINK,
-            mode,
-            function(err, fd) {
-              if (err) {
-                if (callback) callback(err);
-                return;
-              }
-              fs18.fchmod(fd, mode, function(err2) {
-                fs18.close(fd, function(err22) {
-                  if (callback) callback(err2 || err22);
-                });
-              });
-            }
-          );
-        };
-        fs18.lchmodSync = function(path16, mode) {
-          var fd = fs18.openSync(path16, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
-          var threw = true;
-          var ret;
-          try {
-            ret = fs18.fchmodSync(fd, mode);
-            threw = false;
-          } finally {
-            if (threw) {
-              try {
-                fs18.closeSync(fd);
-              } catch (er) {
-              }
-            } else {
-              fs18.closeSync(fd);
-            }
-          }
-          return ret;
-        };
-      }
-      function patchLutimes(fs18) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs18.futimes) {
-          fs18.lutimes = function(path16, at, mt, cb) {
-            fs18.open(path16, constants2.O_SYMLINK, function(er, fd) {
-              if (er) {
-                if (cb) cb(er);
-                return;
-              }
-              fs18.futimes(fd, at, mt, function(er2) {
-                fs18.close(fd, function(er22) {
-                  if (cb) cb(er2 || er22);
-                });
-              });
-            });
-          };
-          fs18.lutimesSync = function(path16, at, mt) {
-            var fd = fs18.openSync(path16, constants2.O_SYMLINK);
-            var ret;
-            var threw = true;
-            try {
-              ret = fs18.futimesSync(fd, at, mt);
-              threw = false;
-            } finally {
-              if (threw) {
-                try {
-                  fs18.closeSync(fd);
-                } catch (er) {
-                }
-              } else {
-                fs18.closeSync(fd);
-              }
-            }
-            return ret;
-          };
-        } else if (fs18.futimes) {
-          fs18.lutimes = function(_a, _b, _c, cb) {
-            if (cb) process.nextTick(cb);
-          };
-          fs18.lutimesSync = function() {
-          };
-        }
-      }
-      function chmodFix(orig) {
-        if (!orig) return orig;
-        return function(target, mode, cb) {
-          return orig.call(fs17, target, mode, function(er) {
-            if (chownErOk(er)) er = null;
-            if (cb) cb.apply(this, arguments);
-          });
-        };
-      }
-      function chmodFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, mode) {
-          try {
-            return orig.call(fs17, target, mode);
-          } catch (er) {
-            if (!chownErOk(er)) throw er;
-          }
-        };
-      }
-      function chownFix(orig) {
-        if (!orig) return orig;
-        return function(target, uid, gid, cb) {
-          return orig.call(fs17, target, uid, gid, function(er) {
-            if (chownErOk(er)) er = null;
-            if (cb) cb.apply(this, arguments);
-          });
-        };
-      }
-      function chownFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, uid, gid) {
-          try {
-            return orig.call(fs17, target, uid, gid);
-          } catch (er) {
-            if (!chownErOk(er)) throw er;
-          }
-        };
-      }
-      function statFix(orig) {
-        if (!orig) return orig;
-        return function(target, options, cb) {
-          if (typeof options === "function") {
-            cb = options;
-            options = null;
-          }
-          function callback(er, stats) {
-            if (stats) {
-              if (stats.uid < 0) stats.uid += 4294967296;
-              if (stats.gid < 0) stats.gid += 4294967296;
-            }
-            if (cb) cb.apply(this, arguments);
-          }
-          return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback);
-        };
-      }
-      function statFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, options) {
-          var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target);
-          if (stats) {
-            if (stats.uid < 0) stats.uid += 4294967296;
-            if (stats.gid < 0) stats.gid += 4294967296;
-          }
-          return stats;
-        };
-      }
-      function chownErOk(er) {
-        if (!er)
-          return true;
-        if (er.code === "ENOSYS")
-          return true;
-        var nonroot = !process.getuid || process.getuid() !== 0;
-        if (nonroot) {
-          if (er.code === "EINVAL" || er.code === "EPERM")
-            return true;
-        }
-        return false;
-      }
-    }
-  }
-});
-
-// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams = __commonJS({
-  ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
-    var Stream2 = require("stream").Stream;
-    module2.exports = legacy;
-    function legacy(fs17) {
-      return {
-        ReadStream: ReadStream2,
-        WriteStream: WriteStream2
-      };
-      function ReadStream2(path16, options) {
-        if (!(this instanceof ReadStream2)) return new ReadStream2(path16, options);
-        Stream2.call(this);
-        var self2 = this;
-        this.path = path16;
-        this.fd = null;
-        this.readable = true;
-        this.paused = false;
-        this.flags = "r";
-        this.mode = 438;
-        this.bufferSize = 64 * 1024;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.encoding) this.setEncoding(this.encoding);
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.end === void 0) {
-            this.end = Infinity;
-          } else if ("number" !== typeof this.end) {
-            throw TypeError("end must be a Number");
-          }
-          if (this.start > this.end) {
-            throw new Error("start must be <= end");
-          }
-          this.pos = this.start;
-        }
-        if (this.fd !== null) {
-          process.nextTick(function() {
-            self2._read();
-          });
-          return;
-        }
-        fs17.open(this.path, this.flags, this.mode, function(err, fd) {
-          if (err) {
-            self2.emit("error", err);
-            self2.readable = false;
-            return;
-          }
-          self2.fd = fd;
-          self2.emit("open", fd);
-          self2._read();
-        });
-      }
-      function WriteStream2(path16, options) {
-        if (!(this instanceof WriteStream2)) return new WriteStream2(path16, options);
-        Stream2.call(this);
-        this.path = path16;
-        this.fd = null;
-        this.writable = true;
-        this.flags = "w";
-        this.encoding = "binary";
-        this.mode = 438;
-        this.bytesWritten = 0;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.start < 0) {
-            throw new Error("start must be >= zero");
-          }
-          this.pos = this.start;
-        }
-        this.busy = false;
-        this._queue = [];
-        if (this.fd === null) {
-          this._open = fs17.open;
-          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
-          this.flush();
-        }
-      }
-    }
-  }
-});
-
-// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js
-var require_clone = __commonJS({
-  ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js"(exports2, module2) {
-    "use strict";
-    module2.exports = clone;
-    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
-      return obj.__proto__;
-    };
-    function clone(obj) {
-      if (obj === null || typeof obj !== "object")
-        return obj;
-      if (obj instanceof Object)
-        var copy = { __proto__: getPrototypeOf(obj) };
-      else
-        var copy = /* @__PURE__ */ Object.create(null);
-      Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-      });
-      return copy;
-    }
-  }
-});
-
-// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js
-var require_graceful_fs = __commonJS({
-  ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs17 = require("fs");
-    var polyfills = require_polyfills();
-    var legacy = require_legacy_streams();
-    var clone = require_clone();
-    var util = require("util");
-    var gracefulQueue;
-    var previousSymbol;
-    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
-      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
-      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
-    } else {
-      gracefulQueue = "___graceful-fs.queue";
-      previousSymbol = "___graceful-fs.previous";
-    }
-    function noop3() {
-    }
-    function publishQueue(context, queue2) {
-      Object.defineProperty(context, gracefulQueue, {
-        get: function() {
-          return queue2;
-        }
-      });
-    }
-    var debug2 = noop3;
-    if (util.debuglog)
-      debug2 = util.debuglog("gfs4");
-    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug2 = function() {
-        var m = util.format.apply(util, arguments);
-        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
-        console.error(m);
-      };
-    if (!fs17[gracefulQueue]) {
-      queue = global[gracefulQueue] || [];
-      publishQueue(fs17, queue);
-      fs17.close = (function(fs$close) {
-        function close(fd, cb) {
-          return fs$close.call(fs17, fd, function(err) {
-            if (!err) {
-              resetQueue();
-            }
-            if (typeof cb === "function")
-              cb.apply(this, arguments);
-          });
-        }
-        Object.defineProperty(close, previousSymbol, {
-          value: fs$close
-        });
-        return close;
-      })(fs17.close);
-      fs17.closeSync = (function(fs$closeSync) {
-        function closeSync(fd) {
-          fs$closeSync.apply(fs17, arguments);
-          resetQueue();
-        }
-        Object.defineProperty(closeSync, previousSymbol, {
-          value: fs$closeSync
-        });
-        return closeSync;
-      })(fs17.closeSync);
-      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
-        process.on("exit", function() {
-          debug2(fs17[gracefulQueue]);
-          require("assert").equal(fs17[gracefulQueue].length, 0);
-        });
-      }
-    }
-    var queue;
-    if (!global[gracefulQueue]) {
-      publishQueue(global, fs17[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs17));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs17.__patched) {
-      module2.exports = patch(fs17);
-      fs17.__patched = true;
-    }
-    function patch(fs18) {
-      polyfills(fs18);
-      fs18.gracefulify = patch;
-      fs18.createReadStream = createReadStream;
-      fs18.createWriteStream = createWriteStream;
-      var fs$readFile = fs18.readFile;
-      fs18.readFile = readFile;
-      function readFile(path16, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$readFile(path16, options, cb);
-        function go$readFile(path17, options2, cb2, startTime) {
-          return fs$readFile(path17, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$writeFile = fs18.writeFile;
-      fs18.writeFile = writeFile;
-      function writeFile(path16, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$writeFile(path16, data, options, cb);
-        function go$writeFile(path17, data2, options2, cb2, startTime) {
-          return fs$writeFile(path17, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$appendFile = fs18.appendFile;
-      if (fs$appendFile)
-        fs18.appendFile = appendFile;
-      function appendFile(path16, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$appendFile(path16, data, options, cb);
-        function go$appendFile(path17, data2, options2, cb2, startTime) {
-          return fs$appendFile(path17, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$copyFile = fs18.copyFile;
-      if (fs$copyFile)
-        fs18.copyFile = copyFile;
-      function copyFile(src, dest, flags, cb) {
-        if (typeof flags === "function") {
-          cb = flags;
-          flags = 0;
-        }
-        return go$copyFile(src, dest, flags, cb);
-        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
-          return fs$copyFile(src2, dest2, flags2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$readdir = fs18.readdir;
-      fs18.readdir = readdir;
-      var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path16, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, fs$readdirCallback(
-            path17,
-            options2,
-            cb2,
-            startTime
-          ));
-        } : function go$readdir2(path17, options2, cb2, startTime) {
-          return fs$readdir(path17, options2, fs$readdirCallback(
-            path17,
-            options2,
-            cb2,
-            startTime
-          ));
-        };
-        return go$readdir(path16, options, cb);
-        function fs$readdirCallback(path17, options2, cb2, startTime) {
-          return function(err, files) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([
-                go$readdir,
-                [path17, options2, cb2],
-                err,
-                startTime || Date.now(),
-                Date.now()
-              ]);
-            else {
-              if (files && files.sort)
-                files.sort();
-              if (typeof cb2 === "function")
-                cb2.call(this, err, files);
-            }
-          };
-        }
-      }
-      if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs18);
-        ReadStream2 = legStreams.ReadStream;
-        WriteStream2 = legStreams.WriteStream;
-      }
-      var fs$ReadStream = fs18.ReadStream;
-      if (fs$ReadStream) {
-        ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
-        ReadStream2.prototype.open = ReadStream$open;
-      }
-      var fs$WriteStream = fs18.WriteStream;
-      if (fs$WriteStream) {
-        WriteStream2.prototype = Object.create(fs$WriteStream.prototype);
-        WriteStream2.prototype.open = WriteStream$open;
-      }
-      Object.defineProperty(fs18, "ReadStream", {
-        get: function() {
-          return ReadStream2;
-        },
-        set: function(val) {
-          ReadStream2 = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      Object.defineProperty(fs18, "WriteStream", {
-        get: function() {
-          return WriteStream2;
-        },
-        set: function(val) {
-          WriteStream2 = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileReadStream = ReadStream2;
-      Object.defineProperty(fs18, "FileReadStream", {
-        get: function() {
-          return FileReadStream;
-        },
-        set: function(val) {
-          FileReadStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileWriteStream = WriteStream2;
-      Object.defineProperty(fs18, "FileWriteStream", {
-        get: function() {
-          return FileWriteStream;
-        },
-        set: function(val) {
-          FileWriteStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      function ReadStream2(path16, options) {
-        if (this instanceof ReadStream2)
-          return fs$ReadStream.apply(this, arguments), this;
-        else
-          return ReadStream2.apply(Object.create(ReadStream2.prototype), arguments);
-      }
-      function ReadStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            if (that.autoClose)
-              that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-            that.read();
-          }
-        });
-      }
-      function WriteStream2(path16, options) {
-        if (this instanceof WriteStream2)
-          return fs$WriteStream.apply(this, arguments), this;
-        else
-          return WriteStream2.apply(Object.create(WriteStream2.prototype), arguments);
-      }
-      function WriteStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-          }
-        });
-      }
-      function createReadStream(path16, options) {
-        return new fs18.ReadStream(path16, options);
-      }
-      function createWriteStream(path16, options) {
-        return new fs18.WriteStream(path16, options);
-      }
-      var fs$open = fs18.open;
-      fs18.open = open;
-      function open(path16, flags, mode, cb) {
-        if (typeof mode === "function")
-          cb = mode, mode = null;
-        return go$open(path16, flags, mode, cb);
-        function go$open(path17, flags2, mode2, cb2, startTime) {
-          return fs$open(path17, flags2, mode2, function(err, fd) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      return fs18;
-    }
-    function enqueue(elem) {
-      debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs17[gracefulQueue].push(elem);
-      retry();
-    }
-    var retryTimer;
-    function resetQueue() {
-      var now = Date.now();
-      for (var i = 0; i < fs17[gracefulQueue].length; ++i) {
-        if (fs17[gracefulQueue][i].length > 2) {
-          fs17[gracefulQueue][i][3] = now;
-          fs17[gracefulQueue][i][4] = now;
-        }
-      }
-      retry();
-    }
-    function retry() {
-      clearTimeout(retryTimer);
-      retryTimer = void 0;
-      if (fs17[gracefulQueue].length === 0)
-        return;
-      var elem = fs17[gracefulQueue].shift();
-      var fn2 = elem[0];
-      var args = elem[1];
-      var err = elem[2];
-      var startTime = elem[3];
-      var lastTime = elem[4];
-      if (startTime === void 0) {
-        debug2("RETRY", fn2.name, args);
-        fn2.apply(null, args);
-      } else if (Date.now() - startTime >= 6e4) {
-        debug2("TIMEOUT", fn2.name, args);
-        var cb = args.pop();
-        if (typeof cb === "function")
-          cb.call(null, err);
-      } else {
-        var sinceAttempt = Date.now() - lastTime;
-        var sinceStart = Math.max(lastTime - startTime, 1);
-        var desiredDelay = Math.min(sinceStart * 1.2, 100);
-        if (sinceAttempt >= desiredDelay) {
-          debug2("RETRY", fn2.name, args);
-          fn2.apply(null, args.concat([startTime]));
-        } else {
-          fs17[gracefulQueue].push(elem);
-        }
-      }
-      if (retryTimer === void 0) {
-        retryTimer = setTimeout(retry, 0);
-      }
-    }
-  }
-});
-
-// .yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js
-var require_cmd_shim = __commonJS({
-  ".yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js"(exports2, module2) {
-    "use strict";
-    cmdShim2.ifExists = cmdShimIfExists;
-    var util_1 = require("util");
-    var path16 = require("path");
-    var isWindows4 = require_is_windows();
-    var CMD_EXTENSION = require_cmd_extension();
-    var shebangExpr = /^#!\s*(?:\/usr\/bin\/env(?:\s+-S\s*)?)?\s*([^ \t]+)(.*)$/;
-    var DEFAULT_OPTIONS = {
-      // Create PowerShell file by default if the option hasn't been specified
-      createPwshFile: true,
-      createCmdFile: isWindows4(),
-      fs: require_graceful_fs()
-    };
-    var extensionToProgramMap = /* @__PURE__ */ new Map([
-      [".js", "node"],
-      [".cjs", "node"],
-      [".mjs", "node"],
-      [".cmd", "cmd"],
-      [".bat", "cmd"],
-      [".ps1", "pwsh"],
-      [".sh", "sh"]
-    ]);
-    function ingestOptions(opts) {
-      const opts_ = { ...DEFAULT_OPTIONS, ...opts };
-      const fs17 = opts_.fs;
-      opts_.fs_ = {
-        chmod: fs17.chmod ? (0, util_1.promisify)(fs17.chmod) : (async () => {
-        }),
-        mkdir: (0, util_1.promisify)(fs17.mkdir),
-        readFile: (0, util_1.promisify)(fs17.readFile),
-        stat: (0, util_1.promisify)(fs17.stat),
-        unlink: (0, util_1.promisify)(fs17.unlink),
-        writeFile: (0, util_1.promisify)(fs17.writeFile)
-      };
-      return opts_;
-    }
-    async function cmdShim2(src, to, opts) {
-      const opts_ = ingestOptions(opts);
-      await cmdShim_(src, to, opts_);
-    }
-    function cmdShimIfExists(src, to, opts) {
-      return cmdShim2(src, to, opts).catch(() => {
-      });
-    }
-    function rm(path17, opts) {
-      return opts.fs_.unlink(path17).catch(() => {
-      });
-    }
-    async function cmdShim_(src, to, opts) {
-      const srcRuntimeInfo = await searchScriptRuntime(src, opts);
-      await writeShimsPreCommon(to, opts);
-      return writeAllShims(src, to, srcRuntimeInfo, opts);
-    }
-    function writeShimsPreCommon(target, opts) {
-      return opts.fs_.mkdir(path16.dirname(target), { recursive: true });
-    }
-    function writeAllShims(src, to, srcRuntimeInfo, opts) {
-      const opts_ = ingestOptions(opts);
-      const generatorAndExts = [{ generator: generateShShim, extension: "" }];
-      if (opts_.createCmdFile) {
-        generatorAndExts.push({ generator: generateCmdShim, extension: CMD_EXTENSION });
-      }
-      if (opts_.createPwshFile) {
-        generatorAndExts.push({ generator: generatePwshShim, extension: ".ps1" });
-      }
-      return Promise.all(generatorAndExts.map((generatorAndExt) => writeShim(src, to + generatorAndExt.extension, srcRuntimeInfo, generatorAndExt.generator, opts_)));
-    }
-    function writeShimPre(target, opts) {
-      return rm(target, opts);
-    }
-    function writeShimPost(target, opts) {
-      return chmodShim(target, opts);
-    }
-    async function searchScriptRuntime(target, opts) {
-      try {
-        const data = await opts.fs_.readFile(target, "utf8");
-        const firstLine = data.trim().split(/\r*\n/)[0];
-        const shebang = firstLine.match(shebangExpr);
-        if (!shebang) {
-          const targetExtension = path16.extname(target).toLowerCase();
-          return {
-            // undefined if extension is unknown but it's converted to null.
-            program: extensionToProgramMap.get(targetExtension) || null,
-            additionalArgs: ""
-          };
-        }
-        return {
-          program: shebang[1],
-          additionalArgs: shebang[2]
-        };
-      } catch (err) {
-        if (!isWindows4() || err.code !== "ENOENT")
-          throw err;
-        if (await opts.fs_.stat(`${target}${getExeExtension()}`)) {
-          return {
-            program: null,
-            additionalArgs: ""
-          };
-        }
-        throw err;
-      }
-    }
-    function getExeExtension() {
-      let cmdExtension;
-      if (process.env.PATHEXT) {
-        cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toLowerCase() === ".exe");
-      }
-      return cmdExtension || ".exe";
-    }
-    async function writeShim(src, to, srcRuntimeInfo, generateShimScript, opts) {
-      const defaultArgs = opts.preserveSymlinks ? "--preserve-symlinks" : "";
-      const args = [srcRuntimeInfo.additionalArgs, defaultArgs].filter((arg) => arg).join(" ");
-      opts = Object.assign({}, opts, {
-        prog: srcRuntimeInfo.program,
-        args
-      });
-      await writeShimPre(to, opts);
-      await opts.fs_.writeFile(to, generateShimScript(src, to, opts), "utf8");
-      return writeShimPost(to, opts);
-    }
-    function generateCmdShim(src, to, opts) {
-      const shTarget = path16.relative(path16.dirname(to), src);
-      let target = shTarget.split("/").join("\\");
-      const quotedPathToTarget = path16.isAbsolute(target) ? `"${target}"` : `"%~dp0\\${target}"`;
-      let longProg;
-      let prog = opts.prog;
-      let args = opts.args || "";
-      const nodePath = normalizePathEnvVar(opts.nodePath).win32;
-      const prependToPath = normalizePathEnvVar(opts.prependToPath).win32;
-      if (!prog) {
-        prog = quotedPathToTarget;
-        args = "";
-        target = "";
-      } else if (prog === "node" && opts.nodeExecPath) {
-        prog = `"${opts.nodeExecPath}"`;
-        target = quotedPathToTarget;
-      } else {
-        longProg = `"%~dp0\\${prog}.exe"`;
-        target = quotedPathToTarget;
-      }
-      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
-      let cmd = "@SETLOCAL\r\n";
-      if (prependToPath) {
-        cmd += `@SET "PATH=${prependToPath}:%PATH%"\r
-`;
-      }
-      if (nodePath) {
-        cmd += `@IF NOT DEFINED NODE_PATH (\r
-  @SET "NODE_PATH=${nodePath}"\r
-) ELSE (\r
-  @SET "NODE_PATH=${nodePath};%NODE_PATH%"\r
-)\r
-`;
-      }
-      if (longProg) {
-        cmd += `@IF EXIST ${longProg} (\r
-  ${longProg} ${args} ${target} ${progArgs}%*\r
-) ELSE (\r
-  @SET PATHEXT=%PATHEXT:;.JS;=;%\r
-  ${prog} ${args} ${target} ${progArgs}%*\r
-)\r
-`;
-      } else {
-        cmd += `@${prog} ${args} ${target} ${progArgs}%*\r
-`;
-      }
-      return cmd;
-    }
-    function generateShShim(src, to, opts) {
-      let shTarget = path16.relative(path16.dirname(to), src);
-      let shProg = opts.prog && opts.prog.split("\\").join("/");
-      let shLongProg;
-      shTarget = shTarget.split("\\").join("/");
-      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`;
-      let args = opts.args || "";
-      const shNodePath = normalizePathEnvVar(opts.nodePath).posix;
-      if (!shProg) {
-        shProg = quotedPathToTarget;
-        args = "";
-        shTarget = "";
-      } else if (opts.prog === "node" && opts.nodeExecPath) {
-        shProg = `"${opts.nodeExecPath}"`;
-        shTarget = quotedPathToTarget;
-      } else {
-        shLongProg = `"$basedir/${opts.prog}"`;
-        shTarget = quotedPathToTarget;
-      }
-      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
-      let sh = `#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')")
-
-case \`uname\` in
-    *CYGWIN*) basedir=\`cygpath -w "$basedir"\`;;
-esac
-
-`;
-      if (opts.prependToPath) {
-        sh += `export PATH="${opts.prependToPath}:$PATH"
-`;
-      }
-      if (shNodePath) {
-        sh += `if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="${shNodePath}"
-else
-  export NODE_PATH="${shNodePath}:$NODE_PATH"
-fi
-`;
-      }
-      if (shLongProg) {
-        sh += `if [ -x ${shLongProg} ]; then
-  exec ${shLongProg} ${args} ${shTarget} ${progArgs}"$@"
-else
-  exec ${shProg} ${args} ${shTarget} ${progArgs}"$@"
-fi
-`;
-      } else {
-        sh += `${shProg} ${args} ${shTarget} ${progArgs}"$@"
-exit $?
-`;
-      }
-      return sh;
-    }
-    function generatePwshShim(src, to, opts) {
-      let shTarget = path16.relative(path16.dirname(to), src);
-      const shProg = opts.prog && opts.prog.split("\\").join("/");
-      let pwshProg = shProg && `"${shProg}$exe"`;
-      let pwshLongProg;
-      shTarget = shTarget.split("\\").join("/");
-      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`;
-      let args = opts.args || "";
-      let normalizedNodePathEnvVar = normalizePathEnvVar(opts.nodePath);
-      const nodePath = normalizedNodePathEnvVar.win32;
-      const shNodePath = normalizedNodePathEnvVar.posix;
-      let normalizedPrependPathEnvVar = normalizePathEnvVar(opts.prependToPath);
-      const prependPath = normalizedPrependPathEnvVar.win32;
-      const shPrependPath = normalizedPrependPathEnvVar.posix;
-      if (!pwshProg) {
-        pwshProg = quotedPathToTarget;
-        args = "";
-        shTarget = "";
-      } else if (opts.prog === "node" && opts.nodeExecPath) {
-        pwshProg = `"${opts.nodeExecPath}"`;
-        shTarget = quotedPathToTarget;
-      } else {
-        pwshLongProg = `"$basedir/${opts.prog}$exe"`;
-        shTarget = quotedPathToTarget;
-      }
-      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
-      let pwsh = `#!/usr/bin/env pwsh
-$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
-
-$exe=""
-${nodePath || prependPath ? '$pathsep=":"\n' : ""}${nodePath ? `$env_node_path=$env:NODE_PATH
-$new_node_path="${nodePath}"
-` : ""}${prependPath ? `$env_path=$env:PATH
-$prepend_path="${prependPath}"
-` : ""}if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
-  # Fix case when both the Windows and Linux builds of Node
-  # are installed in the same directory
-  $exe=".exe"
-${nodePath || prependPath ? '  $pathsep=";"\n' : ""}}`;
-      if (shNodePath || shPrependPath) {
-        pwsh += ` else {
-${shNodePath ? `  $new_node_path="${shNodePath}"
-` : ""}${shPrependPath ? `  $prepend_path="${shPrependPath}"
-` : ""}}
-`;
-      }
-      if (shNodePath) {
-        pwsh += `if ([string]::IsNullOrEmpty($env_node_path)) {
-  $env:NODE_PATH=$new_node_path
-} else {
-  $env:NODE_PATH="$new_node_path$pathsep$env_node_path"
-}
-`;
-      }
-      if (opts.prependToPath) {
-        pwsh += `
-$env:PATH="$prepend_path$pathsep$env:PATH"
-`;
-      }
-      if (pwshLongProg) {
-        pwsh += `
-$ret=0
-if (Test-Path ${pwshLongProg}) {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
-  } else {
-    & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
-  } else {
-    & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
-  }
-  $ret=$LASTEXITCODE
-}
-${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $ret
-`;
-      } else {
-        pwsh += `
-# Support pipeline input
-if ($MyInvocation.ExpectingInput) {
-  $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
-} else {
-  & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
-}
-${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $LASTEXITCODE
-`;
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs18);
+        ReadStream2 = legStreams.ReadStream;
+        WriteStream2 = legStreams.WriteStream;
       }
-      return pwsh;
-    }
-    function chmodShim(to, opts) {
-      return opts.fs_.chmod(to, 493);
-    }
-    function normalizePathEnvVar(nodePath) {
-      if (!nodePath || !nodePath.length) {
-        return {
-          win32: "",
-          posix: ""
-        };
+      var fs$ReadStream = fs18.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream2.prototype.open = ReadStream$open;
       }
-      let split = typeof nodePath === "string" ? nodePath.split(path16.delimiter) : Array.from(nodePath);
-      let result = {};
-      for (let i = 0; i < split.length; i++) {
-        const win322 = split[i].split("/").join("\\");
-        const posix = isWindows4() ? split[i].split("\\").join("/").replace(/^([^:\\/]*):/, (_, $1) => `/mnt/${$1.toLowerCase()}`) : split[i];
-        result.win32 = result.win32 ? `${result.win32};${win322}` : win322;
-        result.posix = result.posix ? `${result.posix}:${posix}` : posix;
-        result[i] = { win32: win322, posix };
+      var fs$WriteStream = fs18.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream2.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream2.prototype.open = WriteStream$open;
       }
-      return result;
-    }
-    module2.exports = cmdShim2;
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mode-fix.js
-var modeFix;
-var init_mode_fix = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mode-fix.js"() {
-    modeFix = (mode, isDir, portable) => {
-      mode &= 4095;
-      if (portable) {
-        mode = (mode | 384) & ~18;
+      Object.defineProperty(fs18, "ReadStream", {
+        get: function() {
+          return ReadStream2;
+        },
+        set: function(val) {
+          ReadStream2 = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs18, "WriteStream", {
+        get: function() {
+          return WriteStream2;
+        },
+        set: function(val) {
+          WriteStream2 = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream2;
+      Object.defineProperty(fs18, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream2;
+      Object.defineProperty(fs18, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream2(path16, options) {
+        if (this instanceof ReadStream2)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream2.apply(Object.create(ReadStream2.prototype), arguments);
       }
-      if (isDir) {
-        if (mode & 256) {
-          mode |= 64;
-        }
-        if (mode & 32) {
-          mode |= 8;
-        }
-        if (mode & 4) {
-          mode |= 1;
-        }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
       }
-      return mode;
-    };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/write-entry.js
-var import_fs11, import_path9, prefixPath, maxReadSize, PROCESS, FILE2, DIRECTORY2, SYMLINK2, HARDLINK2, HEADER, READ2, LSTAT, ONLSTAT, ONREAD, ONREADLINK, OPENFILE, ONOPENFILE, CLOSE, MODE, AWAITDRAIN, ONDRAIN, PREFIX, WriteEntry, WriteEntrySync, WriteEntryTar, getType;
-var init_write_entry = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/write-entry.js"() {
-    import_fs11 = __toESM(require("fs"), 1);
-    init_esm();
-    import_path9 = __toESM(require("path"), 1);
-    init_header();
-    init_mode_fix();
-    init_normalize_windows_path();
-    init_options();
-    init_pax();
-    init_strip_absolute_path();
-    init_strip_trailing_slashes();
-    init_warn_method();
-    init_winchars();
-    prefixPath = (path16, prefix) => {
-      if (!prefix) {
-        return normalizeWindowsPath(path16);
+      function WriteStream2(path16, options) {
+        if (this instanceof WriteStream2)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream2.apply(Object.create(WriteStream2.prototype), arguments);
       }
-      path16 = normalizeWindowsPath(path16).replace(/^\.(\/|$)/, "");
-      return stripTrailingSlashes(prefix) + "/" + path16;
-    };
-    maxReadSize = 16 * 1024 * 1024;
-    PROCESS = /* @__PURE__ */ Symbol("process");
-    FILE2 = /* @__PURE__ */ Symbol("file");
-    DIRECTORY2 = /* @__PURE__ */ Symbol("directory");
-    SYMLINK2 = /* @__PURE__ */ Symbol("symlink");
-    HARDLINK2 = /* @__PURE__ */ Symbol("hardlink");
-    HEADER = /* @__PURE__ */ Symbol("header");
-    READ2 = /* @__PURE__ */ Symbol("read");
-    LSTAT = /* @__PURE__ */ Symbol("lstat");
-    ONLSTAT = /* @__PURE__ */ Symbol("onlstat");
-    ONREAD = /* @__PURE__ */ Symbol("onread");
-    ONREADLINK = /* @__PURE__ */ Symbol("onreadlink");
-    OPENFILE = /* @__PURE__ */ Symbol("openfile");
-    ONOPENFILE = /* @__PURE__ */ Symbol("onopenfile");
-    CLOSE = /* @__PURE__ */ Symbol("close");
-    MODE = /* @__PURE__ */ Symbol("mode");
-    AWAITDRAIN = /* @__PURE__ */ Symbol("awaitDrain");
-    ONDRAIN = /* @__PURE__ */ Symbol("ondrain");
-    PREFIX = /* @__PURE__ */ Symbol("prefix");
-    WriteEntry = class extends Minipass {
-      path;
-      portable;
-      myuid = process.getuid && process.getuid() || 0;
-      // until node has builtin pwnam functions, this'll have to do
-      myuser = process.env.USER || "";
-      maxReadSize;
-      linkCache;
-      statCache;
-      preservePaths;
-      cwd;
-      strict;
-      mtime;
-      noPax;
-      noMtime;
-      prefix;
-      fd;
-      blockLen = 0;
-      blockRemain = 0;
-      buf;
-      pos = 0;
-      remain = 0;
-      length = 0;
-      offset = 0;
-      win32;
-      absolute;
-      header;
-      type;
-      linkpath;
-      stat;
-      onWriteEntry;
-      #hadError = false;
-      constructor(p, opt_ = {}) {
-        const opt = dealias(opt_);
-        super();
-        this.path = normalizeWindowsPath(p);
-        this.portable = !!opt.portable;
-        this.maxReadSize = opt.maxReadSize || maxReadSize;
-        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
-        this.statCache = opt.statCache || /* @__PURE__ */ new Map();
-        this.preservePaths = !!opt.preservePaths;
-        this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
-        this.strict = !!opt.strict;
-        this.noPax = !!opt.noPax;
-        this.noMtime = !!opt.noMtime;
-        this.mtime = opt.mtime;
-        this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : void 0;
-        this.onWriteEntry = opt.onWriteEntry;
-        if (typeof opt.onwarn === "function") {
-          this.on("warn", opt.onwarn);
-        }
-        let pathWarn = false;
-        if (!this.preservePaths) {
-          const [root, stripped] = stripAbsolutePath(this.path);
-          if (root && typeof stripped === "string") {
-            this.path = stripped;
-            pathWarn = root;
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
           }
-        }
-        this.win32 = !!opt.win32 || process.platform === "win32";
-        if (this.win32) {
-          this.path = decode(this.path.replaceAll(/\\/g, "/"));
-          p = p.replaceAll(/\\/g, "/");
-        }
-        this.absolute = normalizeWindowsPath(opt.absolute || import_path9.default.resolve(this.cwd, p));
-        if (this.path === "") {
-          this.path = "./";
-        }
-        if (pathWarn) {
-          this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
-            entry: this,
-            path: pathWarn + this.path
+        });
+      }
+      function createReadStream(path16, options) {
+        return new fs18.ReadStream(path16, options);
+      }
+      function createWriteStream(path16, options) {
+        return new fs18.WriteStream(path16, options);
+      }
+      var fs$open = fs18.open;
+      fs18.open = open;
+      function open(path16, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path16, flags, mode, cb);
+        function go$open(path17, flags2, mode2, cb2, startTime) {
+          return fs$open(path17, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
           });
         }
-        const cs = this.statCache.get(this.absolute);
-        if (cs) {
-          this[ONLSTAT](cs);
-        } else {
-          this[LSTAT]();
-        }
-      }
-      warn(code2, message, data = {}) {
-        return warnMethod(this, code2, message, data);
       }
-      emit(ev, ...data) {
-        if (ev === "error") {
-          this.#hadError = true;
+      return fs18;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs17[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs17[gracefulQueue].length; ++i) {
+        if (fs17[gracefulQueue][i].length > 2) {
+          fs17[gracefulQueue][i][3] = now;
+          fs17[gracefulQueue][i][4] = now;
         }
-        return super.emit(ev, ...data);
-      }
-      [LSTAT]() {
-        import_fs11.default.lstat(this.absolute, (er, stat) => {
-          if (er) {
-            return this.emit("error", er);
-          }
-          this[ONLSTAT](stat);
-        });
       }
-      [ONLSTAT](stat) {
-        this.statCache.set(this.absolute, stat);
-        this.stat = stat;
-        if (!stat.isFile()) {
-          stat.size = 0;
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs17[gracefulQueue].length === 0)
+        return;
+      var elem = fs17[gracefulQueue].shift();
+      var fn2 = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn2.name, args);
+        fn2.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn2.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn2.name, args);
+          fn2.apply(null, args.concat([startTime]));
+        } else {
+          fs17[gracefulQueue].push(elem);
         }
-        this.type = getType(stat);
-        this.emit("stat", stat);
-        this[PROCESS]();
       }
-      [PROCESS]() {
-        switch (this.type) {
-          case "File":
-            return this[FILE2]();
-          case "Directory":
-            return this[DIRECTORY2]();
-          case "SymbolicLink":
-            return this[SYMLINK2]();
-          // unsupported types are ignored.
-          default:
-            return this.end();
-        }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
       }
-      [MODE](mode) {
-        return modeFix(mode, this.type === "Directory", this.portable);
+    }
+  }
+});
+
+// node_modules/@zkochan/cmd-shim/index.js
+var require_cmd_shim = __commonJS({
+  "node_modules/@zkochan/cmd-shim/index.js"(exports2, module2) {
+    "use strict";
+    cmdShim2.ifExists = cmdShimIfExists;
+    var util_1 = require("util");
+    var path16 = require("path");
+    var isWindows4 = require_is_windows();
+    var CMD_EXTENSION = require_cmd_extension();
+    var shebangExpr = /^#!\s*(?:\/usr\/bin\/env(?:\s+-S\s*)?)?\s*([^ \t]+)(.*)$/;
+    var DEFAULT_OPTIONS = {
+      // Create PowerShell file by default if the option hasn't been specified
+      createPwshFile: true,
+      createCmdFile: isWindows4(),
+      fs: require_graceful_fs()
+    };
+    var extensionToProgramMap = /* @__PURE__ */ new Map([
+      [".js", "node"],
+      [".cjs", "node"],
+      [".mjs", "node"],
+      [".cmd", "cmd"],
+      [".bat", "cmd"],
+      [".ps1", "pwsh"],
+      [".sh", "sh"]
+    ]);
+    function ingestOptions(opts) {
+      const opts_ = { ...DEFAULT_OPTIONS, ...opts };
+      const fs17 = opts_.fs;
+      opts_.fs_ = {
+        chmod: fs17.chmod ? (0, util_1.promisify)(fs17.chmod) : (async () => {
+        }),
+        mkdir: (0, util_1.promisify)(fs17.mkdir),
+        readFile: (0, util_1.promisify)(fs17.readFile),
+        stat: (0, util_1.promisify)(fs17.stat),
+        unlink: (0, util_1.promisify)(fs17.unlink),
+        writeFile: (0, util_1.promisify)(fs17.writeFile)
+      };
+      return opts_;
+    }
+    async function cmdShim2(src, to, opts) {
+      const opts_ = ingestOptions(opts);
+      await cmdShim_(src, to, opts_);
+    }
+    function cmdShimIfExists(src, to, opts) {
+      return cmdShim2(src, to, opts).catch(() => {
+      });
+    }
+    function rm(path17, opts) {
+      return opts.fs_.unlink(path17).catch(() => {
+      });
+    }
+    async function cmdShim_(src, to, opts) {
+      const srcRuntimeInfo = await searchScriptRuntime(src, opts);
+      await writeShimsPreCommon(to, opts);
+      return writeAllShims(src, to, srcRuntimeInfo, opts);
+    }
+    function writeShimsPreCommon(target, opts) {
+      return opts.fs_.mkdir(path16.dirname(target), { recursive: true });
+    }
+    function writeAllShims(src, to, srcRuntimeInfo, opts) {
+      const opts_ = ingestOptions(opts);
+      const generatorAndExts = [{ generator: generateShShim, extension: "" }];
+      if (opts_.createCmdFile) {
+        generatorAndExts.push({ generator: generateCmdShim, extension: CMD_EXTENSION });
       }
-      [PREFIX](path16) {
-        return prefixPath(path16, this.prefix);
+      if (opts_.createPwshFile) {
+        generatorAndExts.push({ generator: generatePwshShim, extension: ".ps1" });
       }
-      [HEADER]() {
-        if (!this.stat) {
-          throw new Error("cannot write header before stat");
-        }
-        if (this.type === "Directory" && this.portable) {
-          this.noMtime = true;
-        }
-        this.onWriteEntry?.(this);
-        this.header = new Header({
-          path: this[PREFIX](this.path),
-          // only apply the prefix to hard links.
-          linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
-          // only the permissions and setuid/setgid/sticky bitflags
-          // not the higher-order bits that specify file type
-          mode: this[MODE](this.stat.mode),
-          uid: this.portable ? void 0 : this.stat.uid,
-          gid: this.portable ? void 0 : this.stat.gid,
-          size: this.stat.size,
-          mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
-          /* c8 ignore next */
-          type: this.type === "Unsupported" ? void 0 : this.type,
-          uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "",
-          atime: this.portable ? void 0 : this.stat.atime,
-          ctime: this.portable ? void 0 : this.stat.ctime
-        });
-        if (this.header.encode() && !this.noPax) {
-          super.write(new Pax({
-            atime: this.portable ? void 0 : this.header.atime,
-            ctime: this.portable ? void 0 : this.header.ctime,
-            gid: this.portable ? void 0 : this.header.gid,
-            mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
-            path: this[PREFIX](this.path),
-            linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
-            size: this.header.size,
-            uid: this.portable ? void 0 : this.header.uid,
-            uname: this.portable ? void 0 : this.header.uname,
-            dev: this.portable ? void 0 : this.stat.dev,
-            ino: this.portable ? void 0 : this.stat.ino,
-            nlink: this.portable ? void 0 : this.stat.nlink
-          }).encode());
+      return Promise.all(generatorAndExts.map((generatorAndExt) => writeShim(src, to + generatorAndExt.extension, srcRuntimeInfo, generatorAndExt.generator, opts_)));
+    }
+    function writeShimPre(target, opts) {
+      return rm(target, opts);
+    }
+    function writeShimPost(target, opts) {
+      return chmodShim(target, opts);
+    }
+    async function searchScriptRuntime(target, opts) {
+      try {
+        const data = await opts.fs_.readFile(target, "utf8");
+        const firstLine = data.trim().split(/\r*\n/)[0];
+        const shebang = firstLine.match(shebangExpr);
+        if (!shebang) {
+          const targetExtension = path16.extname(target).toLowerCase();
+          return {
+            // undefined if extension is unknown but it's converted to null.
+            program: extensionToProgramMap.get(targetExtension) || null,
+            additionalArgs: ""
+          };
         }
-        const block = this.header?.block;
-        if (!block) {
-          throw new Error("failed to encode header");
+        return {
+          program: shebang[1],
+          additionalArgs: shebang[2]
+        };
+      } catch (err) {
+        if (!isWindows4() || err.code !== "ENOENT")
+          throw err;
+        if (await opts.fs_.stat(`${target}${getExeExtension()}`)) {
+          return {
+            program: null,
+            additionalArgs: ""
+          };
         }
-        super.write(block);
+        throw err;
       }
-      [DIRECTORY2]() {
-        if (!this.stat) {
-          throw new Error("cannot create directory entry without stat");
-        }
-        if (this.path.slice(-1) !== "/") {
-          this.path += "/";
-        }
-        this.stat.size = 0;
-        this[HEADER]();
-        this.end();
+    }
+    function getExeExtension() {
+      let cmdExtension;
+      if (process.env.PATHEXT) {
+        cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toLowerCase() === ".exe");
+      }
+      return cmdExtension || ".exe";
+    }
+    async function writeShim(src, to, srcRuntimeInfo, generateShimScript, opts) {
+      const defaultArgs = opts.preserveSymlinks ? "--preserve-symlinks" : "";
+      const args = [srcRuntimeInfo.additionalArgs, defaultArgs].filter((arg) => arg).join(" ");
+      opts = Object.assign({}, opts, {
+        prog: srcRuntimeInfo.program,
+        args
+      });
+      await writeShimPre(to, opts);
+      await opts.fs_.writeFile(to, generateShimScript(src, to, opts), "utf8");
+      return writeShimPost(to, opts);
+    }
+    function generateCmdShim(src, to, opts) {
+      const shTarget = path16.relative(path16.dirname(to), src);
+      let target = shTarget.split("/").join("\\");
+      const quotedPathToTarget = path16.isAbsolute(target) ? `"${target}"` : `"%~dp0\\${target}"`;
+      let longProg;
+      let prog = opts.prog;
+      let args = opts.args || "";
+      const nodePath = normalizePathEnvVar(opts.nodePath).win32;
+      const prependToPath = normalizePathEnvVar(opts.prependToPath).win32;
+      if (!prog) {
+        prog = quotedPathToTarget;
+        args = "";
+        target = "";
+      } else if (prog === "node" && opts.nodeExecPath) {
+        prog = `"${opts.nodeExecPath}"`;
+        target = quotedPathToTarget;
+      } else {
+        longProg = `"%~dp0\\${prog}.exe"`;
+        target = quotedPathToTarget;
       }
-      [SYMLINK2]() {
-        import_fs11.default.readlink(this.absolute, (er, linkpath) => {
-          if (er) {
-            return this.emit("error", er);
-          }
-          this[ONREADLINK](linkpath);
-        });
+      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
+      let cmd = "@SETLOCAL\r\n";
+      if (prependToPath) {
+        cmd += `@SET "PATH=${prependToPath}:%PATH%"\r
+`;
       }
-      [ONREADLINK](linkpath) {
-        this.linkpath = normalizeWindowsPath(linkpath);
-        this[HEADER]();
-        this.end();
+      if (nodePath) {
+        cmd += `@IF NOT DEFINED NODE_PATH (\r
+  @SET "NODE_PATH=${nodePath}"\r
+) ELSE (\r
+  @SET "NODE_PATH=${nodePath};%NODE_PATH%"\r
+)\r
+`;
       }
-      [HARDLINK2](linkpath) {
-        if (!this.stat) {
-          throw new Error("cannot create link entry without stat");
-        }
-        this.type = "Link";
-        this.linkpath = normalizeWindowsPath(import_path9.default.relative(this.cwd, linkpath));
-        this.stat.size = 0;
-        this[HEADER]();
-        this.end();
+      if (longProg) {
+        cmd += `@IF EXIST ${longProg} (\r
+  ${longProg} ${args} ${target} ${progArgs}%*\r
+) ELSE (\r
+  @SET PATHEXT=%PATHEXT:;.JS;=;%\r
+  ${prog} ${args} ${target} ${progArgs}%*\r
+)\r
+`;
+      } else {
+        cmd += `@${prog} ${args} ${target} ${progArgs}%*\r
+`;
       }
-      [FILE2]() {
-        if (!this.stat) {
-          throw new Error("cannot create file entry without stat");
-        }
-        if (this.stat.nlink > 1) {
-          const linkKey = `${this.stat.dev}:${this.stat.ino}`;
-          const linkpath = this.linkCache.get(linkKey);
-          if (linkpath?.indexOf(this.cwd) === 0) {
-            return this[HARDLINK2](linkpath);
-          }
-          this.linkCache.set(linkKey, this.absolute);
-        }
-        this[HEADER]();
-        if (this.stat.size === 0) {
-          return this.end();
-        }
-        this[OPENFILE]();
+      return cmd;
+    }
+    function generateShShim(src, to, opts) {
+      let shTarget = path16.relative(path16.dirname(to), src);
+      let shProg = opts.prog && opts.prog.split("\\").join("/");
+      let shLongProg;
+      shTarget = shTarget.split("\\").join("/");
+      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`;
+      let args = opts.args || "";
+      const shNodePath = normalizePathEnvVar(opts.nodePath).posix;
+      if (!shProg) {
+        shProg = quotedPathToTarget;
+        args = "";
+        shTarget = "";
+      } else if (opts.prog === "node" && opts.nodeExecPath) {
+        shProg = `"${opts.nodeExecPath}"`;
+        shTarget = quotedPathToTarget;
+      } else {
+        shLongProg = `"$basedir/${opts.prog}"`;
+        shTarget = quotedPathToTarget;
       }
-      [OPENFILE]() {
-        import_fs11.default.open(this.absolute, "r", (er, fd) => {
-          if (er) {
-            return this.emit("error", er);
-          }
-          this[ONOPENFILE](fd);
-        });
+      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
+      let sh = `#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')")
+
+case \`uname\` in
+    *CYGWIN*) basedir=\`cygpath -w "$basedir"\`;;
+esac
+
+`;
+      if (opts.prependToPath) {
+        sh += `export PATH="${opts.prependToPath}:$PATH"
+`;
       }
-      [ONOPENFILE](fd) {
-        this.fd = fd;
-        if (this.#hadError) {
-          return this[CLOSE]();
-        }
-        if (!this.stat) {
-          throw new Error("should stat before calling onopenfile");
-        }
-        this.blockLen = 512 * Math.ceil(this.stat.size / 512);
-        this.blockRemain = this.blockLen;
-        const bufLen = Math.min(this.blockLen, this.maxReadSize);
-        this.buf = Buffer.allocUnsafe(bufLen);
-        this.offset = 0;
-        this.pos = 0;
-        this.remain = this.stat.size;
-        this.length = this.buf.length;
-        this[READ2]();
+      if (shNodePath) {
+        sh += `if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="${shNodePath}"
+else
+  export NODE_PATH="${shNodePath}:$NODE_PATH"
+fi
+`;
       }
-      [READ2]() {
-        const { fd, buf, offset, length, pos: pos2 } = this;
-        if (fd === void 0 || buf === void 0) {
-          throw new Error("cannot read file without first opening");
-        }
-        import_fs11.default.read(fd, buf, offset, length, pos2, (er, bytesRead) => {
-          if (er) {
-            return this[CLOSE](() => this.emit("error", er));
-          }
-          this[ONREAD](bytesRead);
-        });
+      if (shLongProg) {
+        sh += `if [ -x ${shLongProg} ]; then
+  exec ${shLongProg} ${args} ${shTarget} ${progArgs}"$@"
+else
+  exec ${shProg} ${args} ${shTarget} ${progArgs}"$@"
+fi
+`;
+      } else {
+        sh += `${shProg} ${args} ${shTarget} ${progArgs}"$@"
+exit $?
+`;
       }
-      /* c8 ignore start */
-      [CLOSE](cb = () => {
-      }) {
-        if (this.fd !== void 0)
-          import_fs11.default.close(this.fd, cb);
+      return sh;
+    }
+    function generatePwshShim(src, to, opts) {
+      let shTarget = path16.relative(path16.dirname(to), src);
+      const shProg = opts.prog && opts.prog.split("\\").join("/");
+      let pwshProg = shProg && `"${shProg}$exe"`;
+      let pwshLongProg;
+      shTarget = shTarget.split("\\").join("/");
+      const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`;
+      let args = opts.args || "";
+      let normalizedNodePathEnvVar = normalizePathEnvVar(opts.nodePath);
+      const nodePath = normalizedNodePathEnvVar.win32;
+      const shNodePath = normalizedNodePathEnvVar.posix;
+      let normalizedPrependPathEnvVar = normalizePathEnvVar(opts.prependToPath);
+      const prependPath = normalizedPrependPathEnvVar.win32;
+      const shPrependPath = normalizedPrependPathEnvVar.posix;
+      if (!pwshProg) {
+        pwshProg = quotedPathToTarget;
+        args = "";
+        shTarget = "";
+      } else if (opts.prog === "node" && opts.nodeExecPath) {
+        pwshProg = `"${opts.nodeExecPath}"`;
+        shTarget = quotedPathToTarget;
+      } else {
+        pwshLongProg = `"$basedir/${opts.prog}$exe"`;
+        shTarget = quotedPathToTarget;
       }
-      [ONREAD](bytesRead) {
-        if (bytesRead <= 0 && this.remain > 0) {
-          const er = Object.assign(new Error("encountered unexpected EOF"), {
-            path: this.absolute,
-            syscall: "read",
-            code: "EOF"
-          });
-          return this[CLOSE](() => this.emit("error", er));
-        }
-        if (bytesRead > this.remain) {
-          const er = Object.assign(new Error("did not encounter expected EOF"), {
-            path: this.absolute,
-            syscall: "read",
-            code: "EOF"
-          });
-          return this[CLOSE](() => this.emit("error", er));
-        }
-        if (!this.buf) {
-          throw new Error("should have created buffer prior to reading");
-        }
-        if (bytesRead === this.remain) {
-          for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
-            this.buf[i + this.offset] = 0;
-            bytesRead++;
-            this.remain++;
-          }
-        }
-        const chunk = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead);
-        const flushed = this.write(chunk);
-        if (!flushed) {
-          this[AWAITDRAIN](() => this[ONDRAIN]());
-        } else {
-          this[ONDRAIN]();
-        }
+      let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : "";
+      let pwsh = `#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+${nodePath || prependPath ? '$pathsep=":"\n' : ""}${nodePath ? `$env_node_path=$env:NODE_PATH
+$new_node_path="${nodePath}"
+` : ""}${prependPath ? `$env_path=$env:PATH
+$prepend_path="${prependPath}"
+` : ""}if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+${nodePath || prependPath ? '  $pathsep=";"\n' : ""}}`;
+      if (shNodePath || shPrependPath) {
+        pwsh += ` else {
+${shNodePath ? `  $new_node_path="${shNodePath}"
+` : ""}${shPrependPath ? `  $prepend_path="${shPrependPath}"
+` : ""}}
+`;
       }
-      [AWAITDRAIN](cb) {
-        this.once("drain", cb);
+      if (shNodePath) {
+        pwsh += `if ([string]::IsNullOrEmpty($env_node_path)) {
+  $env:NODE_PATH=$new_node_path
+} else {
+  $env:NODE_PATH="$new_node_path$pathsep$env_node_path"
+}
+`;
       }
-      write(chunk, encoding, cb) {
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
-        }
-        if (typeof chunk === "string") {
-          chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
-        }
-        if (this.blockRemain < chunk.length) {
-          const er = Object.assign(new Error("writing more data than expected"), {
-            path: this.absolute
-          });
-          return this.emit("error", er);
-        }
-        this.remain -= chunk.length;
-        this.blockRemain -= chunk.length;
-        this.pos += chunk.length;
-        this.offset += chunk.length;
-        return super.write(chunk, null, cb);
+      if (opts.prependToPath) {
+        pwsh += `
+$env:PATH="$prepend_path$pathsep$env:PATH"
+`;
       }
-      [ONDRAIN]() {
-        if (!this.remain) {
-          if (this.blockRemain) {
-            super.write(Buffer.alloc(this.blockRemain));
-          }
-          return this[CLOSE]((er) => er ? this.emit("error", er) : this.end());
-        }
-        if (!this.buf) {
-          throw new Error("buffer lost somehow in ONDRAIN");
-        }
-        if (this.offset >= this.length) {
-          this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
-          this.offset = 0;
-        }
-        this.length = this.buf.length - this.offset;
-        this[READ2]();
+      if (pwshLongProg) {
+        pwsh += `
+$ret=0
+if (Test-Path ${pwshLongProg}) {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
+  } else {
+    & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
+  } else {
+    & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
+  }
+  $ret=$LASTEXITCODE
+}
+${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $ret
+`;
+      } else {
+        pwsh += `
+# Support pipeline input
+if ($MyInvocation.ExpectingInput) {
+  $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
+} else {
+  & ${pwshProg} ${args} ${shTarget} ${progArgs}$args
+}
+${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $LASTEXITCODE
+`;
       }
-    };
-    WriteEntrySync = class extends WriteEntry {
-      sync = true;
-      [LSTAT]() {
-        this[ONLSTAT](import_fs11.default.lstatSync(this.absolute));
+      return pwsh;
+    }
+    function chmodShim(to, opts) {
+      return opts.fs_.chmod(to, 493);
+    }
+    function normalizePathEnvVar(nodePath) {
+      if (!nodePath || !nodePath.length) {
+        return {
+          win32: "",
+          posix: ""
+        };
       }
-      [SYMLINK2]() {
-        this[ONREADLINK](import_fs11.default.readlinkSync(this.absolute));
+      let split = typeof nodePath === "string" ? nodePath.split(path16.delimiter) : Array.from(nodePath);
+      let result = {};
+      for (let i = 0; i < split.length; i++) {
+        const win322 = split[i].split("/").join("\\");
+        const posix = isWindows4() ? split[i].split("\\").join("/").replace(/^([^:\\/]*):/, (_, $1) => `/mnt/${$1.toLowerCase()}`) : split[i];
+        result.win32 = result.win32 ? `${result.win32};${win322}` : win322;
+        result.posix = result.posix ? `${result.posix}:${posix}` : posix;
+        result[i] = { win32: win322, posix };
       }
-      [OPENFILE]() {
-        this[ONOPENFILE](import_fs11.default.openSync(this.absolute, "r"));
+      return result;
+    }
+    module2.exports = cmdShim2;
+  }
+});
+
+// node_modules/tar/dist/esm/mode-fix.js
+var modeFix;
+var init_mode_fix = __esm({
+  "node_modules/tar/dist/esm/mode-fix.js"() {
+    modeFix = (mode, isDir, portable) => {
+      mode &= 4095;
+      if (portable) {
+        mode = (mode | 384) & ~18;
       }
-      [READ2]() {
-        let threw = true;
-        try {
-          const { fd, buf, offset, length, pos: pos2 } = this;
-          if (fd === void 0 || buf === void 0) {
-            throw new Error("fd and buf must be set in READ method");
-          }
-          const bytesRead = import_fs11.default.readSync(fd, buf, offset, length, pos2);
-          this[ONREAD](bytesRead);
-          threw = false;
-        } finally {
-          if (threw) {
-            try {
-              this[CLOSE](() => {
-              });
-            } catch {
-            }
-          }
+      if (isDir) {
+        if (mode & 256) {
+          mode |= 64;
+        }
+        if (mode & 32) {
+          mode |= 8;
+        }
+        if (mode & 4) {
+          mode |= 1;
         }
       }
-      [AWAITDRAIN](cb) {
-        cb();
-      }
-      /* c8 ignore start */
-      [CLOSE](cb = () => {
-      }) {
-        if (this.fd !== void 0)
-          import_fs11.default.closeSync(this.fd);
-        cb();
+      return mode;
+    };
+  }
+});
+
+// node_modules/tar/dist/esm/write-entry.js
+var import_fs11, import_path9, prefixPath, maxReadSize, PROCESS, FILE2, DIRECTORY2, SYMLINK2, HARDLINK2, HEADER, READ2, LSTAT, ONLSTAT, ONREAD, ONREADLINK, OPENFILE, ONOPENFILE, CLOSE, MODE, AWAITDRAIN, ONDRAIN, PREFIX, WriteEntry, WriteEntrySync, WriteEntryTar, getType;
+var init_write_entry = __esm({
+  "node_modules/tar/dist/esm/write-entry.js"() {
+    import_fs11 = __toESM(require("fs"), 1);
+    init_esm();
+    import_path9 = __toESM(require("path"), 1);
+    init_header();
+    init_mode_fix();
+    init_normalize_windows_path();
+    init_options();
+    init_pax();
+    init_strip_absolute_path();
+    init_strip_trailing_slashes();
+    init_warn_method();
+    init_winchars();
+    prefixPath = (path16, prefix) => {
+      if (!prefix) {
+        return normalizeWindowsPath(path16);
       }
+      path16 = normalizeWindowsPath(path16).replace(/^\.(\/|$)/, "");
+      return stripTrailingSlashes(prefix) + "/" + path16;
     };
-    WriteEntryTar = class extends Minipass {
-      blockLen = 0;
-      blockRemain = 0;
-      buf = 0;
-      pos = 0;
-      remain = 0;
-      length = 0;
-      preservePaths;
+    maxReadSize = 16 * 1024 * 1024;
+    PROCESS = /* @__PURE__ */ Symbol("process");
+    FILE2 = /* @__PURE__ */ Symbol("file");
+    DIRECTORY2 = /* @__PURE__ */ Symbol("directory");
+    SYMLINK2 = /* @__PURE__ */ Symbol("symlink");
+    HARDLINK2 = /* @__PURE__ */ Symbol("hardlink");
+    HEADER = /* @__PURE__ */ Symbol("header");
+    READ2 = /* @__PURE__ */ Symbol("read");
+    LSTAT = /* @__PURE__ */ Symbol("lstat");
+    ONLSTAT = /* @__PURE__ */ Symbol("onlstat");
+    ONREAD = /* @__PURE__ */ Symbol("onread");
+    ONREADLINK = /* @__PURE__ */ Symbol("onreadlink");
+    OPENFILE = /* @__PURE__ */ Symbol("openfile");
+    ONOPENFILE = /* @__PURE__ */ Symbol("onopenfile");
+    CLOSE = /* @__PURE__ */ Symbol("close");
+    MODE = /* @__PURE__ */ Symbol("mode");
+    AWAITDRAIN = /* @__PURE__ */ Symbol("awaitDrain");
+    ONDRAIN = /* @__PURE__ */ Symbol("ondrain");
+    PREFIX = /* @__PURE__ */ Symbol("prefix");
+    WriteEntry = class extends Minipass {
+      path;
       portable;
+      myuid = process.getuid && process.getuid() || 0;
+      // until node has builtin pwnam functions, this'll have to do
+      myuser = process.env.USER || "";
+      maxReadSize;
+      linkCache;
+      statCache;
+      preservePaths;
+      cwd;
       strict;
+      mtime;
       noPax;
       noMtime;
-      readEntry;
-      type;
       prefix;
-      path;
-      mode;
-      uid;
-      gid;
-      uname;
-      gname;
+      fd;
+      blockLen = 0;
+      blockRemain = 0;
+      buf;
+      pos = 0;
+      remain = 0;
+      length = 0;
+      offset = 0;
+      win32;
+      absolute;
       header;
-      mtime;
-      atime;
-      ctime;
+      type;
       linkpath;
-      size;
+      stat;
       onWriteEntry;
-      warn(code2, message, data = {}) {
-        return warnMethod(this, code2, message, data);
-      }
-      constructor(readEntry, opt_ = {}) {
+      #hadError = false;
+      constructor(p, opt_ = {}) {
         const opt = dealias(opt_);
         super();
+        this.path = normalizeWindowsPath(p);
+        this.portable = !!opt.portable;
+        this.maxReadSize = opt.maxReadSize || maxReadSize;
+        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+        this.statCache = opt.statCache || /* @__PURE__ */ new Map();
         this.preservePaths = !!opt.preservePaths;
-        this.portable = !!opt.portable;
+        this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
         this.strict = !!opt.strict;
         this.noPax = !!opt.noPax;
         this.noMtime = !!opt.noMtime;
+        this.mtime = opt.mtime;
+        this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : void 0;
         this.onWriteEntry = opt.onWriteEntry;
-        this.readEntry = readEntry;
-        const { type } = readEntry;
-        if (type === "Unsupported") {
-          throw new Error("writing entry that should be ignored");
-        }
-        this.type = type;
-        if (this.type === "Directory" && this.portable) {
-          this.noMtime = true;
-        }
-        this.prefix = opt.prefix;
-        this.path = normalizeWindowsPath(readEntry.path);
-        this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0;
-        this.uid = this.portable ? void 0 : readEntry.uid;
-        this.gid = this.portable ? void 0 : readEntry.gid;
-        this.uname = this.portable ? void 0 : readEntry.uname;
-        this.gname = this.portable ? void 0 : readEntry.gname;
-        this.size = readEntry.size;
-        this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime;
-        this.atime = this.portable ? void 0 : readEntry.atime;
-        this.ctime = this.portable ? void 0 : readEntry.ctime;
-        this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0;
         if (typeof opt.onwarn === "function") {
           this.on("warn", opt.onwarn);
         }
@@ -19102,2670 +11123,1450 @@ var init_write_entry = __esm({
             pathWarn = root;
           }
         }
-        this.remain = readEntry.size;
-        this.blockRemain = readEntry.startBlockSize;
-        this.onWriteEntry?.(this);
-        this.header = new Header({
-          path: this[PREFIX](this.path),
-          linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
-          // only the permissions and setuid/setgid/sticky bitflags
-          // not the higher-order bits that specify file type
-          mode: this.mode,
-          uid: this.portable ? void 0 : this.uid,
-          gid: this.portable ? void 0 : this.gid,
-          size: this.size,
-          mtime: this.noMtime ? void 0 : this.mtime,
-          type: this.type,
-          uname: this.portable ? void 0 : this.uname,
-          atime: this.portable ? void 0 : this.atime,
-          ctime: this.portable ? void 0 : this.ctime
-        });
+        this.win32 = !!opt.win32 || process.platform === "win32";
+        if (this.win32) {
+          this.path = decode(this.path.replaceAll(/\\/g, "/"));
+          p = p.replaceAll(/\\/g, "/");
+        }
+        this.absolute = normalizeWindowsPath(opt.absolute || import_path9.default.resolve(this.cwd, p));
+        if (this.path === "") {
+          this.path = "./";
+        }
         if (pathWarn) {
           this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
             entry: this,
             path: pathWarn + this.path
           });
         }
-        if (this.header.encode() && !this.noPax) {
-          super.write(new Pax({
-            atime: this.portable ? void 0 : this.atime,
-            ctime: this.portable ? void 0 : this.ctime,
-            gid: this.portable ? void 0 : this.gid,
-            mtime: this.noMtime ? void 0 : this.mtime,
-            path: this[PREFIX](this.path),
-            linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
-            size: this.size,
-            uid: this.portable ? void 0 : this.uid,
-            uname: this.portable ? void 0 : this.uname,
-            dev: this.portable ? void 0 : this.readEntry.dev,
-            ino: this.portable ? void 0 : this.readEntry.ino,
-            nlink: this.portable ? void 0 : this.readEntry.nlink
-          }).encode());
-        }
-        const b = this.header?.block;
-        if (!b)
-          throw new Error("failed to encode header");
-        super.write(b);
-        readEntry.pipe(this);
-      }
-      [PREFIX](path16) {
-        return prefixPath(path16, this.prefix);
-      }
-      [MODE](mode) {
-        return modeFix(mode, this.type === "Directory", this.portable);
-      }
-      write(chunk, encoding, cb) {
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
-        }
-        if (typeof chunk === "string") {
-          chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
-        }
-        const writeLen = chunk.length;
-        if (writeLen > this.blockRemain) {
-          throw new Error("writing more to entry than is appropriate");
-        }
-        this.blockRemain -= writeLen;
-        return super.write(chunk, cb);
-      }
-      end(chunk, encoding, cb) {
-        if (this.blockRemain) {
-          super.write(Buffer.alloc(this.blockRemain));
-        }
-        if (typeof chunk === "function") {
-          cb = chunk;
-          encoding = void 0;
-          chunk = void 0;
-        }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
-        }
-        if (typeof chunk === "string") {
-          chunk = Buffer.from(chunk, encoding ?? "utf8");
+        const cs = this.statCache.get(this.absolute);
+        if (cs) {
+          this[ONLSTAT](cs);
+        } else {
+          this[LSTAT]();
         }
-        if (cb)
-          this.once("finish", cb);
-        if (chunk)
-          super.end(chunk, cb);
-        else
-          super.end(cb);
-        return this;
-      }
-    };
-    getType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
-  }
-});
-
-// .yarn/cache/yallist-npm-5.0.0-8732dd9f1c-a499c81ce6.zip/node_modules/yallist/dist/esm/index.js
-function insertAfter(self2, node, value) {
-  const prev = node;
-  const next = node ? node.next : self2.head;
-  const inserted = new Node(value, prev, next, self2);
-  if (inserted.next === void 0) {
-    self2.tail = inserted;
-  }
-  if (inserted.prev === void 0) {
-    self2.head = inserted;
-  }
-  self2.length++;
-  return inserted;
-}
-function push(self2, item) {
-  self2.tail = new Node(item, self2.tail, void 0, self2);
-  if (!self2.head) {
-    self2.head = self2.tail;
-  }
-  self2.length++;
-}
-function unshift(self2, item) {
-  self2.head = new Node(item, void 0, self2.head, self2);
-  if (!self2.tail) {
-    self2.tail = self2.head;
-  }
-  self2.length++;
-}
-var Yallist, Node;
-var init_esm5 = __esm({
-  ".yarn/cache/yallist-npm-5.0.0-8732dd9f1c-a499c81ce6.zip/node_modules/yallist/dist/esm/index.js"() {
-    Yallist = class _Yallist {
-      tail;
-      head;
-      length = 0;
-      static create(list2 = []) {
-        return new _Yallist(list2);
       }
-      constructor(list2 = []) {
-        for (const item of list2) {
-          this.push(item);
-        }
+      warn(code2, message, data = {}) {
+        return warnMethod(this, code2, message, data);
       }
-      *[Symbol.iterator]() {
-        for (let walker = this.head; walker; walker = walker.next) {
-          yield walker.value;
+      emit(ev, ...data) {
+        if (ev === "error") {
+          this.#hadError = true;
         }
+        return super.emit(ev, ...data);
       }
-      removeNode(node) {
-        if (node.list !== this) {
-          throw new Error("removing node which does not belong to this list");
-        }
-        const next = node.next;
-        const prev = node.prev;
-        if (next) {
-          next.prev = prev;
-        }
-        if (prev) {
-          prev.next = next;
-        }
-        if (node === this.head) {
-          this.head = next;
-        }
-        if (node === this.tail) {
-          this.tail = prev;
-        }
-        this.length--;
-        node.next = void 0;
-        node.prev = void 0;
-        node.list = void 0;
-        return next;
+      [LSTAT]() {
+        import_fs11.default.lstat(this.absolute, (er, stat) => {
+          if (er) {
+            return this.emit("error", er);
+          }
+          this[ONLSTAT](stat);
+        });
       }
-      unshiftNode(node) {
-        if (node === this.head) {
-          return;
-        }
-        if (node.list) {
-          node.list.removeNode(node);
-        }
-        const head = this.head;
-        node.list = this;
-        node.next = head;
-        if (head) {
-          head.prev = node;
-        }
-        this.head = node;
-        if (!this.tail) {
-          this.tail = node;
+      [ONLSTAT](stat) {
+        this.statCache.set(this.absolute, stat);
+        this.stat = stat;
+        if (!stat.isFile()) {
+          stat.size = 0;
         }
-        this.length++;
+        this.type = getType(stat);
+        this.emit("stat", stat);
+        this[PROCESS]();
       }
-      pushNode(node) {
-        if (node === this.tail) {
-          return;
-        }
-        if (node.list) {
-          node.list.removeNode(node);
-        }
-        const tail = this.tail;
-        node.list = this;
-        node.prev = tail;
-        if (tail) {
-          tail.next = node;
-        }
-        this.tail = node;
-        if (!this.head) {
-          this.head = node;
+      [PROCESS]() {
+        switch (this.type) {
+          case "File":
+            return this[FILE2]();
+          case "Directory":
+            return this[DIRECTORY2]();
+          case "SymbolicLink":
+            return this[SYMLINK2]();
+          // unsupported types are ignored.
+          default:
+            return this.end();
         }
-        this.length++;
       }
-      push(...args) {
-        for (let i = 0, l = args.length; i < l; i++) {
-          push(this, args[i]);
-        }
-        return this.length;
+      [MODE](mode) {
+        return modeFix(mode, this.type === "Directory", this.portable);
       }
-      unshift(...args) {
-        for (var i = 0, l = args.length; i < l; i++) {
-          unshift(this, args[i]);
-        }
-        return this.length;
+      [PREFIX](path16) {
+        return prefixPath(path16, this.prefix);
       }
-      pop() {
-        if (!this.tail) {
-          return void 0;
+      [HEADER]() {
+        if (!this.stat) {
+          throw new Error("cannot write header before stat");
         }
-        const res = this.tail.value;
-        const t = this.tail;
-        this.tail = this.tail.prev;
-        if (this.tail) {
-          this.tail.next = void 0;
-        } else {
-          this.head = void 0;
+        if (this.type === "Directory" && this.portable) {
+          this.noMtime = true;
         }
-        t.list = void 0;
-        this.length--;
-        return res;
-      }
-      shift() {
-        if (!this.head) {
-          return void 0;
+        this.onWriteEntry?.(this);
+        this.header = new Header({
+          path: this[PREFIX](this.path),
+          // only apply the prefix to hard links.
+          linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+          // only the permissions and setuid/setgid/sticky bitflags
+          // not the higher-order bits that specify file type
+          mode: this[MODE](this.stat.mode),
+          uid: this.portable ? void 0 : this.stat.uid,
+          gid: this.portable ? void 0 : this.stat.gid,
+          size: this.stat.size,
+          mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime,
+          /* c8 ignore next */
+          type: this.type === "Unsupported" ? void 0 : this.type,
+          uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "",
+          atime: this.portable ? void 0 : this.stat.atime,
+          ctime: this.portable ? void 0 : this.stat.ctime
+        });
+        if (this.header.encode() && !this.noPax) {
+          super.write(new Pax({
+            atime: this.portable ? void 0 : this.header.atime,
+            ctime: this.portable ? void 0 : this.header.ctime,
+            gid: this.portable ? void 0 : this.header.gid,
+            mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime,
+            path: this[PREFIX](this.path),
+            linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+            size: this.header.size,
+            uid: this.portable ? void 0 : this.header.uid,
+            uname: this.portable ? void 0 : this.header.uname,
+            dev: this.portable ? void 0 : this.stat.dev,
+            ino: this.portable ? void 0 : this.stat.ino,
+            nlink: this.portable ? void 0 : this.stat.nlink
+          }).encode());
         }
-        const res = this.head.value;
-        const h = this.head;
-        this.head = this.head.next;
-        if (this.head) {
-          this.head.prev = void 0;
-        } else {
-          this.tail = void 0;
+        const block = this.header?.block;
+        if (!block) {
+          throw new Error("failed to encode header");
         }
-        h.list = void 0;
-        this.length--;
-        return res;
+        super.write(block);
       }
-      forEach(fn2, thisp) {
-        thisp = thisp || this;
-        for (let walker = this.head, i = 0; !!walker; i++) {
-          fn2.call(thisp, walker.value, i, this);
-          walker = walker.next;
+      [DIRECTORY2]() {
+        if (!this.stat) {
+          throw new Error("cannot create directory entry without stat");
         }
+        if (this.path.slice(-1) !== "/") {
+          this.path += "/";
+        }
+        this.stat.size = 0;
+        this[HEADER]();
+        this.end();
       }
-      forEachReverse(fn2, thisp) {
-        thisp = thisp || this;
-        for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
-          fn2.call(thisp, walker.value, i, this);
-          walker = walker.prev;
+      [SYMLINK2]() {
+        import_fs11.default.readlink(this.absolute, (er, linkpath) => {
+          if (er) {
+            return this.emit("error", er);
+          }
+          this[ONREADLINK](linkpath);
+        });
+      }
+      [ONREADLINK](linkpath) {
+        this.linkpath = normalizeWindowsPath(linkpath);
+        this[HEADER]();
+        this.end();
+      }
+      [HARDLINK2](linkpath) {
+        if (!this.stat) {
+          throw new Error("cannot create link entry without stat");
         }
+        this.type = "Link";
+        this.linkpath = normalizeWindowsPath(import_path9.default.relative(this.cwd, linkpath));
+        this.stat.size = 0;
+        this[HEADER]();
+        this.end();
       }
-      get(n) {
-        let i = 0;
-        let walker = this.head;
-        for (; !!walker && i < n; i++) {
-          walker = walker.next;
+      [FILE2]() {
+        if (!this.stat) {
+          throw new Error("cannot create file entry without stat");
         }
-        if (i === n && !!walker) {
-          return walker.value;
+        if (this.stat.nlink > 1) {
+          const linkKey = `${this.stat.dev}:${this.stat.ino}`;
+          const linkpath = this.linkCache.get(linkKey);
+          if (linkpath?.indexOf(this.cwd) === 0) {
+            return this[HARDLINK2](linkpath);
+          }
+          this.linkCache.set(linkKey, this.absolute);
+        }
+        this[HEADER]();
+        if (this.stat.size === 0) {
+          return this.end();
         }
+        this[OPENFILE]();
       }
-      getReverse(n) {
-        let i = 0;
-        let walker = this.tail;
-        for (; !!walker && i < n; i++) {
-          walker = walker.prev;
+      [OPENFILE]() {
+        import_fs11.default.open(this.absolute, "r", (er, fd) => {
+          if (er) {
+            return this.emit("error", er);
+          }
+          this[ONOPENFILE](fd);
+        });
+      }
+      [ONOPENFILE](fd) {
+        this.fd = fd;
+        if (this.#hadError) {
+          return this[CLOSE]();
         }
-        if (i === n && !!walker) {
-          return walker.value;
+        if (!this.stat) {
+          throw new Error("should stat before calling onopenfile");
         }
+        this.blockLen = 512 * Math.ceil(this.stat.size / 512);
+        this.blockRemain = this.blockLen;
+        const bufLen = Math.min(this.blockLen, this.maxReadSize);
+        this.buf = Buffer.allocUnsafe(bufLen);
+        this.offset = 0;
+        this.pos = 0;
+        this.remain = this.stat.size;
+        this.length = this.buf.length;
+        this[READ2]();
       }
-      map(fn2, thisp) {
-        thisp = thisp || this;
-        const res = new _Yallist();
-        for (let walker = this.head; !!walker; ) {
-          res.push(fn2.call(thisp, walker.value, this));
-          walker = walker.next;
+      [READ2]() {
+        const { fd, buf, offset, length, pos: pos2 } = this;
+        if (fd === void 0 || buf === void 0) {
+          throw new Error("cannot read file without first opening");
         }
-        return res;
+        import_fs11.default.read(fd, buf, offset, length, pos2, (er, bytesRead) => {
+          if (er) {
+            return this[CLOSE](() => this.emit("error", er));
+          }
+          this[ONREAD](bytesRead);
+        });
       }
-      mapReverse(fn2, thisp) {
-        thisp = thisp || this;
-        var res = new _Yallist();
-        for (let walker = this.tail; !!walker; ) {
-          res.push(fn2.call(thisp, walker.value, this));
-          walker = walker.prev;
-        }
-        return res;
+      /* c8 ignore start */
+      [CLOSE](cb = () => {
+      }) {
+        if (this.fd !== void 0)
+          import_fs11.default.close(this.fd, cb);
       }
-      reduce(fn2, initial) {
-        let acc;
-        let walker = this.head;
-        if (arguments.length > 1) {
-          acc = initial;
-        } else if (this.head) {
-          walker = this.head.next;
-          acc = this.head.value;
-        } else {
-          throw new TypeError("Reduce of empty list with no initial value");
-        }
-        for (var i = 0; !!walker; i++) {
-          acc = fn2(acc, walker.value, i);
-          walker = walker.next;
+      [ONREAD](bytesRead) {
+        if (bytesRead <= 0 && this.remain > 0) {
+          const er = Object.assign(new Error("encountered unexpected EOF"), {
+            path: this.absolute,
+            syscall: "read",
+            code: "EOF"
+          });
+          return this[CLOSE](() => this.emit("error", er));
         }
-        return acc;
-      }
-      reduceReverse(fn2, initial) {
-        let acc;
-        let walker = this.tail;
-        if (arguments.length > 1) {
-          acc = initial;
-        } else if (this.tail) {
-          walker = this.tail.prev;
-          acc = this.tail.value;
-        } else {
-          throw new TypeError("Reduce of empty list with no initial value");
+        if (bytesRead > this.remain) {
+          const er = Object.assign(new Error("did not encounter expected EOF"), {
+            path: this.absolute,
+            syscall: "read",
+            code: "EOF"
+          });
+          return this[CLOSE](() => this.emit("error", er));
         }
-        for (let i = this.length - 1; !!walker; i--) {
-          acc = fn2(acc, walker.value, i);
-          walker = walker.prev;
+        if (!this.buf) {
+          throw new Error("should have created buffer prior to reading");
         }
-        return acc;
-      }
-      toArray() {
-        const arr = new Array(this.length);
-        for (let i = 0, walker = this.head; !!walker; i++) {
-          arr[i] = walker.value;
-          walker = walker.next;
+        if (bytesRead === this.remain) {
+          for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
+            this.buf[i + this.offset] = 0;
+            bytesRead++;
+            this.remain++;
+          }
         }
-        return arr;
-      }
-      toArrayReverse() {
-        const arr = new Array(this.length);
-        for (let i = 0, walker = this.tail; !!walker; i++) {
-          arr[i] = walker.value;
-          walker = walker.prev;
+        const chunk = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead);
+        const flushed = this.write(chunk);
+        if (!flushed) {
+          this[AWAITDRAIN](() => this[ONDRAIN]());
+        } else {
+          this[ONDRAIN]();
         }
-        return arr;
       }
-      slice(from = 0, to = this.length) {
-        if (to < 0) {
-          to += this.length;
-        }
-        if (from < 0) {
-          from += this.length;
+      [AWAITDRAIN](cb) {
+        this.once("drain", cb);
+      }
+      write(chunk, encoding, cb) {
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = void 0;
         }
-        const ret = new _Yallist();
-        if (to < from || to < 0) {
-          return ret;
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
         }
-        if (from < 0) {
-          from = 0;
+        if (this.blockRemain < chunk.length) {
+          const er = Object.assign(new Error("writing more data than expected"), {
+            path: this.absolute
+          });
+          return this.emit("error", er);
         }
-        if (to > this.length) {
-          to = this.length;
+        this.remain -= chunk.length;
+        this.blockRemain -= chunk.length;
+        this.pos += chunk.length;
+        this.offset += chunk.length;
+        return super.write(chunk, null, cb);
+      }
+      [ONDRAIN]() {
+        if (!this.remain) {
+          if (this.blockRemain) {
+            super.write(Buffer.alloc(this.blockRemain));
+          }
+          return this[CLOSE]((er) => er ? this.emit("error", er) : this.end());
         }
-        let walker = this.head;
-        let i = 0;
-        for (i = 0; !!walker && i < from; i++) {
-          walker = walker.next;
+        if (!this.buf) {
+          throw new Error("buffer lost somehow in ONDRAIN");
         }
-        for (; !!walker && i < to; i++, walker = walker.next) {
-          ret.push(walker.value);
+        if (this.offset >= this.length) {
+          this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
+          this.offset = 0;
         }
-        return ret;
+        this.length = this.buf.length - this.offset;
+        this[READ2]();
       }
-      sliceReverse(from = 0, to = this.length) {
-        if (to < 0) {
-          to += this.length;
+    };
+    WriteEntrySync = class extends WriteEntry {
+      sync = true;
+      [LSTAT]() {
+        this[ONLSTAT](import_fs11.default.lstatSync(this.absolute));
+      }
+      [SYMLINK2]() {
+        this[ONREADLINK](import_fs11.default.readlinkSync(this.absolute));
+      }
+      [OPENFILE]() {
+        this[ONOPENFILE](import_fs11.default.openSync(this.absolute, "r"));
+      }
+      [READ2]() {
+        let threw = true;
+        try {
+          const { fd, buf, offset, length, pos: pos2 } = this;
+          if (fd === void 0 || buf === void 0) {
+            throw new Error("fd and buf must be set in READ method");
+          }
+          const bytesRead = import_fs11.default.readSync(fd, buf, offset, length, pos2);
+          this[ONREAD](bytesRead);
+          threw = false;
+        } finally {
+          if (threw) {
+            try {
+              this[CLOSE](() => {
+              });
+            } catch {
+            }
+          }
         }
-        if (from < 0) {
-          from += this.length;
+      }
+      [AWAITDRAIN](cb) {
+        cb();
+      }
+      /* c8 ignore start */
+      [CLOSE](cb = () => {
+      }) {
+        if (this.fd !== void 0)
+          import_fs11.default.closeSync(this.fd);
+        cb();
+      }
+    };
+    WriteEntryTar = class extends Minipass {
+      blockLen = 0;
+      blockRemain = 0;
+      buf = 0;
+      pos = 0;
+      remain = 0;
+      length = 0;
+      preservePaths;
+      portable;
+      strict;
+      noPax;
+      noMtime;
+      readEntry;
+      type;
+      prefix;
+      path;
+      mode;
+      uid;
+      gid;
+      uname;
+      gname;
+      header;
+      mtime;
+      atime;
+      ctime;
+      linkpath;
+      size;
+      onWriteEntry;
+      warn(code2, message, data = {}) {
+        return warnMethod(this, code2, message, data);
+      }
+      constructor(readEntry, opt_ = {}) {
+        const opt = dealias(opt_);
+        super();
+        this.preservePaths = !!opt.preservePaths;
+        this.portable = !!opt.portable;
+        this.strict = !!opt.strict;
+        this.noPax = !!opt.noPax;
+        this.noMtime = !!opt.noMtime;
+        this.onWriteEntry = opt.onWriteEntry;
+        this.readEntry = readEntry;
+        const { type } = readEntry;
+        if (type === "Unsupported") {
+          throw new Error("writing entry that should be ignored");
         }
-        const ret = new _Yallist();
-        if (to < from || to < 0) {
-          return ret;
+        this.type = type;
+        if (this.type === "Directory" && this.portable) {
+          this.noMtime = true;
         }
-        if (from < 0) {
-          from = 0;
+        this.prefix = opt.prefix;
+        this.path = normalizeWindowsPath(readEntry.path);
+        this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0;
+        this.uid = this.portable ? void 0 : readEntry.uid;
+        this.gid = this.portable ? void 0 : readEntry.gid;
+        this.uname = this.portable ? void 0 : readEntry.uname;
+        this.gname = this.portable ? void 0 : readEntry.gname;
+        this.size = readEntry.size;
+        this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime;
+        this.atime = this.portable ? void 0 : readEntry.atime;
+        this.ctime = this.portable ? void 0 : readEntry.ctime;
+        this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0;
+        if (typeof opt.onwarn === "function") {
+          this.on("warn", opt.onwarn);
         }
-        if (to > this.length) {
-          to = this.length;
+        let pathWarn = false;
+        if (!this.preservePaths) {
+          const [root, stripped] = stripAbsolutePath(this.path);
+          if (root && typeof stripped === "string") {
+            this.path = stripped;
+            pathWarn = root;
+          }
         }
-        let i = this.length;
-        let walker = this.tail;
-        for (; !!walker && i > to; i--) {
-          walker = walker.prev;
+        this.remain = readEntry.size;
+        this.blockRemain = readEntry.startBlockSize;
+        this.onWriteEntry?.(this);
+        this.header = new Header({
+          path: this[PREFIX](this.path),
+          linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+          // only the permissions and setuid/setgid/sticky bitflags
+          // not the higher-order bits that specify file type
+          mode: this.mode,
+          uid: this.portable ? void 0 : this.uid,
+          gid: this.portable ? void 0 : this.gid,
+          size: this.size,
+          mtime: this.noMtime ? void 0 : this.mtime,
+          type: this.type,
+          uname: this.portable ? void 0 : this.uname,
+          atime: this.portable ? void 0 : this.atime,
+          ctime: this.portable ? void 0 : this.ctime
+        });
+        if (pathWarn) {
+          this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, {
+            entry: this,
+            path: pathWarn + this.path
+          });
         }
-        for (; !!walker && i > from; i--, walker = walker.prev) {
-          ret.push(walker.value);
+        if (this.header.encode() && !this.noPax) {
+          super.write(new Pax({
+            atime: this.portable ? void 0 : this.atime,
+            ctime: this.portable ? void 0 : this.ctime,
+            gid: this.portable ? void 0 : this.gid,
+            mtime: this.noMtime ? void 0 : this.mtime,
+            path: this[PREFIX](this.path),
+            linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath,
+            size: this.size,
+            uid: this.portable ? void 0 : this.uid,
+            uname: this.portable ? void 0 : this.uname,
+            dev: this.portable ? void 0 : this.readEntry.dev,
+            ino: this.portable ? void 0 : this.readEntry.ino,
+            nlink: this.portable ? void 0 : this.readEntry.nlink
+          }).encode());
         }
-        return ret;
+        const b = this.header?.block;
+        if (!b)
+          throw new Error("failed to encode header");
+        super.write(b);
+        readEntry.pipe(this);
+      }
+      [PREFIX](path16) {
+        return prefixPath(path16, this.prefix);
+      }
+      [MODE](mode) {
+        return modeFix(mode, this.type === "Directory", this.portable);
       }
-      splice(start, deleteCount = 0, ...nodes) {
-        if (start > this.length) {
-          start = this.length - 1;
+      write(chunk, encoding, cb) {
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = void 0;
         }
-        if (start < 0) {
-          start = this.length + start;
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
         }
-        let walker = this.head;
-        for (let i = 0; !!walker && i < start; i++) {
-          walker = walker.next;
+        const writeLen = chunk.length;
+        if (writeLen > this.blockRemain) {
+          throw new Error("writing more to entry than is appropriate");
         }
-        const ret = [];
-        for (let i = 0; !!walker && i < deleteCount; i++) {
-          ret.push(walker.value);
-          walker = this.removeNode(walker);
+        this.blockRemain -= writeLen;
+        return super.write(chunk, cb);
+      }
+      end(chunk, encoding, cb) {
+        if (this.blockRemain) {
+          super.write(Buffer.alloc(this.blockRemain));
         }
-        if (!walker) {
-          walker = this.tail;
-        } else if (walker !== this.tail) {
-          walker = walker.prev;
+        if (typeof chunk === "function") {
+          cb = chunk;
+          encoding = void 0;
+          chunk = void 0;
         }
-        for (const v of nodes) {
-          walker = insertAfter(this, walker, v);
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = void 0;
         }
-        return ret;
-      }
-      reverse() {
-        const head = this.head;
-        const tail = this.tail;
-        for (let walker = head; !!walker; walker = walker.prev) {
-          const p = walker.prev;
-          walker.prev = walker.next;
-          walker.next = p;
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(chunk, encoding ?? "utf8");
         }
-        this.head = tail;
-        this.tail = head;
+        if (cb)
+          this.once("finish", cb);
+        if (chunk)
+          super.end(chunk, cb);
+        else
+          super.end(cb);
         return this;
       }
     };
-    Node = class {
-      list;
-      next;
-      prev;
-      value;
-      constructor(value, prev, next, list2) {
-        this.list = list2;
-        this.value = value;
-        if (prev) {
-          prev.next = this;
-          this.prev = prev;
-        } else {
-          this.prev = void 0;
-        }
-        if (next) {
-          next.prev = this;
-          this.next = next;
-        } else {
-          this.next = void 0;
-        }
-      }
-    };
+    getType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
   }
 });
 
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pack.js
-var import_fs12, import_path10, PackJob, EOF2, ONSTAT, ENDED3, QUEUE2, CURRENT, PROCESS2, PROCESSING, PROCESSJOB, JOBS, JOBDONE, ADDFSENTRY, ADDTARENTRY, STAT, READDIR, ONREADDIR, PIPE, ENTRY, ENTRYOPT, WRITEENTRYCLASS, WRITE, ONDRAIN2, Pack, PackSync;
-var init_pack = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pack.js"() {
-    import_fs12 = __toESM(require("fs"), 1);
-    init_write_entry();
-    init_esm();
-    init_esm3();
-    init_esm5();
-    init_read_entry();
-    init_warn_method();
-    import_path10 = __toESM(require("path"), 1);
-    init_normalize_windows_path();
-    PackJob = class {
-      path;
-      absolute;
-      entry;
-      stat;
-      readdir;
-      pending = false;
-      ignore = false;
-      piped = false;
-      constructor(path16, absolute) {
-        this.path = path16 || "./";
-        this.absolute = absolute;
+// node_modules/yallist/dist/esm/index.js
+function insertAfter(self2, node, value) {
+  const prev = node;
+  const next = node ? node.next : self2.head;
+  const inserted = new Node(value, prev, next, self2);
+  if (inserted.next === void 0) {
+    self2.tail = inserted;
+  }
+  if (inserted.prev === void 0) {
+    self2.head = inserted;
+  }
+  self2.length++;
+  return inserted;
+}
+function push(self2, item) {
+  self2.tail = new Node(item, self2.tail, void 0, self2);
+  if (!self2.head) {
+    self2.head = self2.tail;
+  }
+  self2.length++;
+}
+function unshift(self2, item) {
+  self2.head = new Node(item, void 0, self2.head, self2);
+  if (!self2.tail) {
+    self2.tail = self2.head;
+  }
+  self2.length++;
+}
+var Yallist, Node;
+var init_esm5 = __esm({
+  "node_modules/yallist/dist/esm/index.js"() {
+    Yallist = class _Yallist {
+      tail;
+      head;
+      length = 0;
+      static create(list2 = []) {
+        return new _Yallist(list2);
       }
-    };
-    EOF2 = Buffer.alloc(1024);
-    ONSTAT = /* @__PURE__ */ Symbol("onStat");
-    ENDED3 = /* @__PURE__ */ Symbol("ended");
-    QUEUE2 = /* @__PURE__ */ Symbol("queue");
-    CURRENT = /* @__PURE__ */ Symbol("current");
-    PROCESS2 = /* @__PURE__ */ Symbol("process");
-    PROCESSING = /* @__PURE__ */ Symbol("processing");
-    PROCESSJOB = /* @__PURE__ */ Symbol("processJob");
-    JOBS = /* @__PURE__ */ Symbol("jobs");
-    JOBDONE = /* @__PURE__ */ Symbol("jobDone");
-    ADDFSENTRY = /* @__PURE__ */ Symbol("addFSEntry");
-    ADDTARENTRY = /* @__PURE__ */ Symbol("addTarEntry");
-    STAT = /* @__PURE__ */ Symbol("stat");
-    READDIR = /* @__PURE__ */ Symbol("readdir");
-    ONREADDIR = /* @__PURE__ */ Symbol("onreaddir");
-    PIPE = /* @__PURE__ */ Symbol("pipe");
-    ENTRY = /* @__PURE__ */ Symbol("entry");
-    ENTRYOPT = /* @__PURE__ */ Symbol("entryOpt");
-    WRITEENTRYCLASS = /* @__PURE__ */ Symbol("writeEntryClass");
-    WRITE = /* @__PURE__ */ Symbol("write");
-    ONDRAIN2 = /* @__PURE__ */ Symbol("ondrain");
-    Pack = class extends Minipass {
-      sync = false;
-      opt;
-      cwd;
-      maxReadSize;
-      preservePaths;
-      strict;
-      noPax;
-      prefix;
-      linkCache;
-      statCache;
-      file;
-      portable;
-      zip;
-      readdirCache;
-      noDirRecurse;
-      follow;
-      noMtime;
-      mtime;
-      filter;
-      jobs;
-      [WRITEENTRYCLASS];
-      onWriteEntry;
-      // Note: we actually DO need a linked list here, because we
-      // shift() to update the head of the list where we start, but still
-      // while that happens, need to know what the next item in the queue
-      // will be. Since we do multiple jobs in parallel, it's not as simple
-      // as just an Array.shift(), since that would lose the information about
-      // the next job in the list. We could add a .next field on the PackJob
-      // class, but then we'd have to be tracking the tail of the queue the
-      // whole time, and Yallist just does that for us anyway.
-      [QUEUE2];
-      [JOBS] = 0;
-      [PROCESSING] = false;
-      [ENDED3] = false;
-      constructor(opt = {}) {
-        super();
-        this.opt = opt;
-        this.file = opt.file || "";
-        this.cwd = opt.cwd || process.cwd();
-        this.maxReadSize = opt.maxReadSize;
-        this.preservePaths = !!opt.preservePaths;
-        this.strict = !!opt.strict;
-        this.noPax = !!opt.noPax;
-        this.prefix = normalizeWindowsPath(opt.prefix || "");
-        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
-        this.statCache = opt.statCache || /* @__PURE__ */ new Map();
-        this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map();
-        this.onWriteEntry = opt.onWriteEntry;
-        this[WRITEENTRYCLASS] = WriteEntry;
-        if (typeof opt.onwarn === "function") {
-          this.on("warn", opt.onwarn);
+      constructor(list2 = []) {
+        for (const item of list2) {
+          this.push(item);
         }
-        this.portable = !!opt.portable;
-        if (opt.gzip || opt.brotli || opt.zstd) {
-          if ((opt.gzip ? 1 : 0) + (opt.brotli ? 1 : 0) + (opt.zstd ? 1 : 0) > 1) {
-            throw new TypeError("gzip, brotli, zstd are mutually exclusive");
-          }
-          if (opt.gzip) {
-            if (typeof opt.gzip !== "object") {
-              opt.gzip = {};
-            }
-            if (this.portable) {
-              opt.gzip.portable = true;
-            }
-            this.zip = new Gzip(opt.gzip);
-          }
-          if (opt.brotli) {
-            if (typeof opt.brotli !== "object") {
-              opt.brotli = {};
-            }
-            this.zip = new BrotliCompress(opt.brotli);
-          }
-          if (opt.zstd) {
-            if (typeof opt.zstd !== "object") {
-              opt.zstd = {};
-            }
-            this.zip = new ZstdCompress(opt.zstd);
-          }
-          if (!this.zip)
-            throw new Error("impossible");
-          const zip = this.zip;
-          zip.on("data", (chunk) => super.write(chunk));
-          zip.on("end", () => super.end());
-          zip.on("drain", () => this[ONDRAIN2]());
-          this.on("resume", () => zip.resume());
-        } else {
-          this.on("drain", this[ONDRAIN2]);
+      }
+      *[Symbol.iterator]() {
+        for (let walker = this.head; walker; walker = walker.next) {
+          yield walker.value;
         }
-        this.noDirRecurse = !!opt.noDirRecurse;
-        this.follow = !!opt.follow;
-        this.noMtime = !!opt.noMtime;
-        if (opt.mtime)
-          this.mtime = opt.mtime;
-        this.filter = typeof opt.filter === "function" ? opt.filter : () => true;
-        this[QUEUE2] = new Yallist();
-        this[JOBS] = 0;
-        this.jobs = Number(opt.jobs) || 4;
-        this[PROCESSING] = false;
-        this[ENDED3] = false;
       }
-      [WRITE](chunk) {
-        return super.write(chunk);
+      removeNode(node) {
+        if (node.list !== this) {
+          throw new Error("removing node which does not belong to this list");
+        }
+        const next = node.next;
+        const prev = node.prev;
+        if (next) {
+          next.prev = prev;
+        }
+        if (prev) {
+          prev.next = next;
+        }
+        if (node === this.head) {
+          this.head = next;
+        }
+        if (node === this.tail) {
+          this.tail = prev;
+        }
+        this.length--;
+        node.next = void 0;
+        node.prev = void 0;
+        node.list = void 0;
+        return next;
       }
-      add(path16) {
-        this.write(path16);
-        return this;
+      unshiftNode(node) {
+        if (node === this.head) {
+          return;
+        }
+        if (node.list) {
+          node.list.removeNode(node);
+        }
+        const head = this.head;
+        node.list = this;
+        node.next = head;
+        if (head) {
+          head.prev = node;
+        }
+        this.head = node;
+        if (!this.tail) {
+          this.tail = node;
+        }
+        this.length++;
       }
-      end(path16, encoding, cb) {
-        if (typeof path16 === "function") {
-          cb = path16;
-          path16 = void 0;
+      pushNode(node) {
+        if (node === this.tail) {
+          return;
         }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = void 0;
+        if (node.list) {
+          node.list.removeNode(node);
         }
-        if (path16) {
-          this.add(path16);
+        const tail = this.tail;
+        node.list = this;
+        node.prev = tail;
+        if (tail) {
+          tail.next = node;
         }
-        this[ENDED3] = true;
-        this[PROCESS2]();
-        if (cb)
-          cb();
-        return this;
+        this.tail = node;
+        if (!this.head) {
+          this.head = node;
+        }
+        this.length++;
       }
-      write(path16) {
-        if (this[ENDED3]) {
-          throw new Error("write after end");
+      push(...args) {
+        for (let i = 0, l = args.length; i < l; i++) {
+          push(this, args[i]);
         }
-        if (path16 instanceof ReadEntry) {
-          this[ADDTARENTRY](path16);
+        return this.length;
+      }
+      unshift(...args) {
+        for (var i = 0, l = args.length; i < l; i++) {
+          unshift(this, args[i]);
+        }
+        return this.length;
+      }
+      pop() {
+        if (!this.tail) {
+          return void 0;
+        }
+        const res = this.tail.value;
+        const t = this.tail;
+        this.tail = this.tail.prev;
+        if (this.tail) {
+          this.tail.next = void 0;
         } else {
-          this[ADDFSENTRY](path16);
+          this.head = void 0;
         }
-        return this.flowing;
+        t.list = void 0;
+        this.length--;
+        return res;
       }
-      [ADDTARENTRY](p) {
-        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p.path));
-        if (!this.filter(p.path, p)) {
-          p.resume();
+      shift() {
+        if (!this.head) {
+          return void 0;
+        }
+        const res = this.head.value;
+        const h = this.head;
+        this.head = this.head.next;
+        if (this.head) {
+          this.head.prev = void 0;
         } else {
-          const job = new PackJob(p.path, absolute);
-          job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
-          job.entry.on("end", () => this[JOBDONE](job));
-          this[JOBS] += 1;
-          this[QUEUE2].push(job);
+          this.tail = void 0;
         }
-        this[PROCESS2]();
+        h.list = void 0;
+        this.length--;
+        return res;
       }
-      [ADDFSENTRY](p) {
-        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p));
-        this[QUEUE2].push(new PackJob(p, absolute));
-        this[PROCESS2]();
+      forEach(fn2, thisp) {
+        thisp = thisp || this;
+        for (let walker = this.head, i = 0; !!walker; i++) {
+          fn2.call(thisp, walker.value, i, this);
+          walker = walker.next;
+        }
       }
-      [STAT](job) {
-        job.pending = true;
-        this[JOBS] += 1;
-        const stat = this.follow ? "stat" : "lstat";
-        import_fs12.default[stat](job.absolute, (er, stat2) => {
-          job.pending = false;
-          this[JOBS] -= 1;
-          if (er) {
-            this.emit("error", er);
-          } else {
-            this[ONSTAT](job, stat2);
-          }
-        });
+      forEachReverse(fn2, thisp) {
+        thisp = thisp || this;
+        for (let walker = this.tail, i = this.length - 1; !!walker; i--) {
+          fn2.call(thisp, walker.value, i, this);
+          walker = walker.prev;
+        }
       }
-      [ONSTAT](job, stat) {
-        this.statCache.set(job.absolute, stat);
-        job.stat = stat;
-        if (!this.filter(job.path, stat)) {
-          job.ignore = true;
-        } else if (stat.isFile() && stat.nlink > 1 && job === this[CURRENT] && !this.linkCache.get(`${stat.dev}:${stat.ino}`) && !this.sync) {
-          this[PROCESSJOB](job);
+      get(n) {
+        let i = 0;
+        let walker = this.head;
+        for (; !!walker && i < n; i++) {
+          walker = walker.next;
+        }
+        if (i === n && !!walker) {
+          return walker.value;
         }
-        this[PROCESS2]();
       }
-      [READDIR](job) {
-        job.pending = true;
-        this[JOBS] += 1;
-        import_fs12.default.readdir(job.absolute, (er, entries) => {
-          job.pending = false;
-          this[JOBS] -= 1;
-          if (er) {
-            return this.emit("error", er);
-          }
-          this[ONREADDIR](job, entries);
-        });
+      getReverse(n) {
+        let i = 0;
+        let walker = this.tail;
+        for (; !!walker && i < n; i++) {
+          walker = walker.prev;
+        }
+        if (i === n && !!walker) {
+          return walker.value;
+        }
       }
-      [ONREADDIR](job, entries) {
-        this.readdirCache.set(job.absolute, entries);
-        job.readdir = entries;
-        this[PROCESS2]();
+      map(fn2, thisp) {
+        thisp = thisp || this;
+        const res = new _Yallist();
+        for (let walker = this.head; !!walker; ) {
+          res.push(fn2.call(thisp, walker.value, this));
+          walker = walker.next;
+        }
+        return res;
       }
-      [PROCESS2]() {
-        if (this[PROCESSING]) {
-          return;
+      mapReverse(fn2, thisp) {
+        thisp = thisp || this;
+        var res = new _Yallist();
+        for (let walker = this.tail; !!walker; ) {
+          res.push(fn2.call(thisp, walker.value, this));
+          walker = walker.prev;
         }
-        this[PROCESSING] = true;
-        for (let w = this[QUEUE2].head; !!w && this[JOBS] < this.jobs; w = w.next) {
-          this[PROCESSJOB](w.value);
-          if (w.value.ignore) {
-            const p = w.next;
-            this[QUEUE2].removeNode(w);
-            w.next = p;
-          }
+        return res;
+      }
+      reduce(fn2, initial) {
+        let acc;
+        let walker = this.head;
+        if (arguments.length > 1) {
+          acc = initial;
+        } else if (this.head) {
+          walker = this.head.next;
+          acc = this.head.value;
+        } else {
+          throw new TypeError("Reduce of empty list with no initial value");
         }
-        this[PROCESSING] = false;
-        if (this[ENDED3] && this[QUEUE2].length === 0 && this[JOBS] === 0) {
-          if (this.zip) {
-            this.zip.end(EOF2);
-          } else {
-            super.write(EOF2);
-            super.end();
-          }
+        for (var i = 0; !!walker; i++) {
+          acc = fn2(acc, walker.value, i);
+          walker = walker.next;
         }
+        return acc;
       }
-      get [CURRENT]() {
-        return this[QUEUE2] && this[QUEUE2].head && this[QUEUE2].head.value;
+      reduceReverse(fn2, initial) {
+        let acc;
+        let walker = this.tail;
+        if (arguments.length > 1) {
+          acc = initial;
+        } else if (this.tail) {
+          walker = this.tail.prev;
+          acc = this.tail.value;
+        } else {
+          throw new TypeError("Reduce of empty list with no initial value");
+        }
+        for (let i = this.length - 1; !!walker; i--) {
+          acc = fn2(acc, walker.value, i);
+          walker = walker.prev;
+        }
+        return acc;
       }
-      [JOBDONE](_job) {
-        this[QUEUE2].shift();
-        this[JOBS] -= 1;
-        this[PROCESS2]();
+      toArray() {
+        const arr = new Array(this.length);
+        for (let i = 0, walker = this.head; !!walker; i++) {
+          arr[i] = walker.value;
+          walker = walker.next;
+        }
+        return arr;
       }
-      [PROCESSJOB](job) {
-        if (job.pending) {
-          return;
+      toArrayReverse() {
+        const arr = new Array(this.length);
+        for (let i = 0, walker = this.tail; !!walker; i++) {
+          arr[i] = walker.value;
+          walker = walker.prev;
         }
-        if (job.entry) {
-          if (job === this[CURRENT] && !job.piped) {
-            this[PIPE](job);
-          }
-          return;
+        return arr;
+      }
+      slice(from = 0, to = this.length) {
+        if (to < 0) {
+          to += this.length;
         }
-        if (!job.stat) {
-          const sc = this.statCache.get(job.absolute);
-          if (sc) {
-            this[ONSTAT](job, sc);
-          } else {
-            this[STAT](job);
-          }
+        if (from < 0) {
+          from += this.length;
         }
-        if (!job.stat) {
-          return;
+        const ret = new _Yallist();
+        if (to < from || to < 0) {
+          return ret;
         }
-        if (job.ignore) {
-          return;
+        if (from < 0) {
+          from = 0;
         }
-        if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
-          const rc = this.readdirCache.get(job.absolute);
-          if (rc) {
-            this[ONREADDIR](job, rc);
-          } else {
-            this[READDIR](job);
-          }
-          if (!job.readdir) {
-            return;
-          }
+        if (to > this.length) {
+          to = this.length;
         }
-        job.entry = this[ENTRY](job);
-        if (!job.entry) {
-          job.ignore = true;
-          return;
+        let walker = this.head;
+        let i = 0;
+        for (i = 0; !!walker && i < from; i++) {
+          walker = walker.next;
         }
-        if (job === this[CURRENT] && !job.piped) {
-          this[PIPE](job);
+        for (; !!walker && i < to; i++, walker = walker.next) {
+          ret.push(walker.value);
         }
+        return ret;
       }
-      [ENTRYOPT](job) {
-        return {
-          onwarn: (code2, msg, data) => this.warn(code2, msg, data),
-          noPax: this.noPax,
-          cwd: this.cwd,
-          absolute: job.absolute,
-          preservePaths: this.preservePaths,
-          maxReadSize: this.maxReadSize,
-          strict: this.strict,
-          portable: this.portable,
-          linkCache: this.linkCache,
-          statCache: this.statCache,
-          noMtime: this.noMtime,
-          mtime: this.mtime,
-          prefix: this.prefix,
-          onWriteEntry: this.onWriteEntry
-        };
-      }
-      [ENTRY](job) {
-        this[JOBS] += 1;
-        try {
-          const e = new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job));
-          return e.on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er));
-        } catch (er) {
-          this.emit("error", er);
+      sliceReverse(from = 0, to = this.length) {
+        if (to < 0) {
+          to += this.length;
         }
-      }
-      [ONDRAIN2]() {
-        if (this[CURRENT] && this[CURRENT].entry) {
-          this[CURRENT].entry.resume();
+        if (from < 0) {
+          from += this.length;
         }
-      }
-      // like .pipe() but using super, because our write() is special
-      [PIPE](job) {
-        job.piped = true;
-        if (job.readdir) {
-          job.readdir.forEach((entry) => {
-            const p = job.path;
-            const base = p === "./" ? "" : p.replace(/\/*$/, "/");
-            this[ADDFSENTRY](base + entry);
-          });
+        const ret = new _Yallist();
+        if (to < from || to < 0) {
+          return ret;
         }
-        const source = job.entry;
-        const zip = this.zip;
-        if (!source)
-          throw new Error("cannot pipe without source");
-        if (zip) {
-          source.on("data", (chunk) => {
-            if (!zip.write(chunk)) {
-              source.pause();
-            }
-          });
-        } else {
-          source.on("data", (chunk) => {
-            if (!super.write(chunk)) {
-              source.pause();
-            }
-          });
+        if (from < 0) {
+          from = 0;
         }
-      }
-      pause() {
-        if (this.zip) {
-          this.zip.pause();
+        if (to > this.length) {
+          to = this.length;
         }
-        return super.pause();
-      }
-      warn(code2, message, data = {}) {
-        warnMethod(this, code2, message, data);
-      }
-    };
-    PackSync = class extends Pack {
-      sync = true;
-      constructor(opt) {
-        super(opt);
-        this[WRITEENTRYCLASS] = WriteEntrySync;
-      }
-      // pause/resume are no-ops in sync streams.
-      pause() {
-      }
-      resume() {
-      }
-      [STAT](job) {
-        const stat = this.follow ? "statSync" : "lstatSync";
-        this[ONSTAT](job, import_fs12.default[stat](job.absolute));
-      }
-      [READDIR](job) {
-        this[ONREADDIR](job, import_fs12.default.readdirSync(job.absolute));
-      }
-      // gotta get it all in this tick
-      [PIPE](job) {
-        const source = job.entry;
-        const zip = this.zip;
-        if (job.readdir) {
-          job.readdir.forEach((entry) => {
-            const p = job.path;
-            const base = p === "./" ? "" : p.replace(/\/*$/, "/");
-            this[ADDFSENTRY](base + entry);
-          });
+        let i = this.length;
+        let walker = this.tail;
+        for (; !!walker && i > to; i--) {
+          walker = walker.prev;
         }
-        if (!source)
-          throw new Error("Cannot pipe without source");
-        if (zip) {
-          source.on("data", (chunk) => {
-            zip.write(chunk);
-          });
-        } else {
-          source.on("data", (chunk) => {
-            super[WRITE](chunk);
-          });
+        for (; !!walker && i > from; i--, walker = walker.prev) {
+          ret.push(walker.value);
         }
+        return ret;
+      }
+      splice(start, deleteCount = 0, ...nodes) {
+        if (start > this.length) {
+          start = this.length - 1;
+        }
+        if (start < 0) {
+          start = this.length + start;
+        }
+        let walker = this.head;
+        for (let i = 0; !!walker && i < start; i++) {
+          walker = walker.next;
+        }
+        const ret = [];
+        for (let i = 0; !!walker && i < deleteCount; i++) {
+          ret.push(walker.value);
+          walker = this.removeNode(walker);
+        }
+        if (!walker) {
+          walker = this.tail;
+        } else if (walker !== this.tail) {
+          walker = walker.prev;
+        }
+        for (const v of nodes) {
+          walker = insertAfter(this, walker, v);
+        }
+        return ret;
+      }
+      reverse() {
+        const head = this.head;
+        const tail = this.tail;
+        for (let walker = head; !!walker; walker = walker.prev) {
+          const p = walker.prev;
+          walker.prev = walker.next;
+          walker.next = p;
+        }
+        this.head = tail;
+        this.tail = head;
+        return this;
       }
     };
-  }
-});
-
-// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/create.js
-var create_exports = {};
-__export(create_exports, {
-  create: () => create
-});
-var import_node_path8, createFileSync, createFile, addFilesSync, addFilesAsync, createSync, createAsync, create;
-var init_create = __esm({
-  ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/create.js"() {
-    init_esm2();
-    import_node_path8 = __toESM(require("node:path"), 1);
-    init_list();
-    init_make_command();
-    init_pack();
-    createFileSync = (opt, files) => {
-      const p = new PackSync(opt);
-      const stream = new WriteStreamSync(opt.file, {
-        mode: opt.mode || 438
-      });
-      p.pipe(stream);
-      addFilesSync(p, files);
-    };
-    createFile = (opt, files) => {
-      const p = new Pack(opt);
-      const stream = new WriteStream(opt.file, {
-        mode: opt.mode || 438
-      });
-      p.pipe(stream);
-      const promise = new Promise((res, rej) => {
-        stream.on("error", rej);
-        stream.on("close", res);
-        p.on("error", rej);
-      });
-      addFilesAsync(p, files).catch((er) => p.emit("error", er));
-      return promise;
-    };
-    addFilesSync = (p, files) => {
-      files.forEach((file) => {
-        if (file.charAt(0) === "@") {
-          list({
-            file: import_node_path8.default.resolve(p.cwd, file.slice(1)),
-            sync: true,
-            noResume: true,
-            onReadEntry: (entry) => p.add(entry)
-          });
+    Node = class {
+      list;
+      next;
+      prev;
+      value;
+      constructor(value, prev, next, list2) {
+        this.list = list2;
+        this.value = value;
+        if (prev) {
+          prev.next = this;
+          this.prev = prev;
         } else {
-          p.add(file);
+          this.prev = void 0;
         }
-      });
-      p.end();
-    };
-    addFilesAsync = async (p, files) => {
-      for (const file of files) {
-        if (file.charAt(0) === "@") {
-          await list({
-            file: import_node_path8.default.resolve(String(p.cwd), file.slice(1)),
-            noResume: true,
-            onReadEntry: (entry) => {
-              p.add(entry);
-            }
-          });
+        if (next) {
+          next.prev = this;
+          this.next = next;
         } else {
-          p.add(file);
+          this.next = void 0;
         }
       }
-      p.end();
-    };
-    createSync = (opt, files) => {
-      const p = new PackSync(opt);
-      addFilesSync(p, files);
-      return p;
-    };
-    createAsync = (opt, files) => {
-      const p = new Pack(opt);
-      addFilesAsync(p, files).catch((er) => p.emit("error", er));
-      return p;
     };
-    create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => {
-      if (!files?.length) {
-        throw new TypeError("no paths specified to add to archive");
-      }
-    });
-  }
-});
-
-// .yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/major.js
-var require_major = __commonJS({
-  ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/functions/major.js"(exports2, module2) {
-    "use strict";
-    var SemVer3 = require_semver();
-    var major = (a, loose) => new SemVer3(a, loose).major;
-    module2.exports = major;
   }
 });
 
-// sources/_lib.ts
-var lib_exports2 = {};
-__export(lib_exports2, {
-  runMain: () => runMain
-});
-module.exports = __toCommonJS(lib_exports2);
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/constants.mjs
-var NODE_INITIAL = 0;
-var NODE_SUCCESS = 1;
-var NODE_ERRORED = 2;
-var START_OF_INPUT = `
`;
-var END_OF_INPUT = `\0`;
-var HELP_COMMAND_INDEX = -1;
-var HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
-var OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
-var BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
-var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
-var DEBUG = process.env.DEBUG_CLI === `1`;
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/errors.mjs
-var UsageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.clipanion = { type: `usage` };
-    this.name = `UsageError`;
-  }
-};
-var UnknownSyntaxError = class extends Error {
-  constructor(input, candidates) {
-    super();
-    this.input = input;
-    this.candidates = candidates;
-    this.clipanion = { type: `none` };
-    this.name = `UnknownSyntaxError`;
-    if (this.candidates.length === 0) {
-      this.message = `Command not found, but we're not sure what's the alternative.`;
-    } else if (this.candidates.every((candidate) => candidate.reason !== null && candidate.reason === candidates[0].reason)) {
-      const [{ reason }] = this.candidates;
-      this.message = `${reason}
-
-${this.candidates.map(({ usage }) => `$ ${usage}`).join(`
-`)}`;
-    } else if (this.candidates.length === 1) {
-      const [{ usage }] = this.candidates;
-      this.message = `Command not found; did you mean:
-
-$ ${usage}
-${whileRunning(input)}`;
-    } else {
-      this.message = `Command not found; did you mean one of:
-
-${this.candidates.map(({ usage }, index) => {
-        return `${`${index}.`.padStart(4)} ${usage}`;
-      }).join(`
-`)}
-
-${whileRunning(input)}`;
-    }
-  }
-};
-var AmbiguousSyntaxError = class extends Error {
-  constructor(input, usages) {
-    super();
-    this.input = input;
-    this.usages = usages;
-    this.clipanion = { type: `none` };
-    this.name = `AmbiguousSyntaxError`;
-    this.message = `Cannot find which to pick amongst the following alternatives:
-
-${this.usages.map((usage, index) => {
-      return `${`${index}.`.padStart(4)} ${usage}`;
-    }).join(`
-`)}
-
-${whileRunning(input)}`;
-  }
-};
-var whileRunning = (input) => `While running ${input.filter((token) => {
-  return token !== END_OF_INPUT;
-}).map((token) => {
-  const json = JSON.stringify(token);
-  if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
-    return json;
-  } else {
-    return token;
-  }
-}).join(` `)}`;
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/format.mjs
-var MAX_LINE_LENGTH = 80;
-var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`);
-for (let t = 0; t <= 24; ++t)
-  richLine[richLine.length - t] = `\x1B[38;5;${232 + t}m\u2501`;
-var richFormat = {
-  header: (str) => `\x1B[1m\u2501\u2501\u2501 ${str}${str.length < MAX_LINE_LENGTH - 5 ? ` ${richLine.slice(str.length + 5).join(``)}` : `:`}\x1B[0m`,
-  bold: (str) => `\x1B[1m${str}\x1B[22m`,
-  error: (str) => `\x1B[31m\x1B[1m${str}\x1B[22m\x1B[39m`,
-  code: (str) => `\x1B[36m${str}\x1B[39m`
-};
-var textFormat = {
-  header: (str) => str,
-  bold: (str) => str,
-  error: (str) => str,
-  code: (str) => str
-};
-function dedent(text) {
-  const lines = text.split(`
-`);
-  const nonEmptyLines = lines.filter((line) => line.match(/\S/));
-  const indent = nonEmptyLines.length > 0 ? nonEmptyLines.reduce((minLength, line) => Math.min(minLength, line.length - line.trimStart().length), Number.MAX_VALUE) : 0;
-  return lines.map((line) => line.slice(indent).trimRight()).join(`
-`);
-}
-function formatMarkdownish(text, { format, paragraphs }) {
-  text = text.replace(/\r\n?/g, `
-`);
-  text = dedent(text);
-  text = text.replace(/^\n+|\n+$/g, ``);
-  text = text.replace(/^(\s*)-([^\n]*?)\n+/gm, `$1-$2
-
-`);
-  text = text.replace(/\n(\n)?\n*/g, ($0, $1) => $1 ? $1 : ` `);
-  if (paragraphs) {
-    text = text.split(/\n/).map((paragraph) => {
-      const bulletMatch = paragraph.match(/^\s*[*-][\t ]+(.*)/);
-      if (!bulletMatch)
-        return paragraph.match(/(.{1,80})(?: |$)/g).join(`
-`);
-      const indent = paragraph.length - paragraph.trimStart().length;
-      return bulletMatch[1].match(new RegExp(`(.{1,${78 - indent}})(?: |$)`, `g`)).map((line, index) => {
-        return ` `.repeat(indent) + (index === 0 ? `- ` : `  `) + line;
-      }).join(`
-`);
-    }).join(`
-
-`);
-  }
-  text = text.replace(/(`+)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
-    return format.code($1 + $2 + $1);
-  });
-  text = text.replace(/(\*\*)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
-    return format.bold($1 + $2 + $1);
-  });
-  return text ? `${text}
-` : ``;
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/utils.mjs
-var isOptionSymbol = /* @__PURE__ */ Symbol(`clipanion/isOption`);
-function makeCommandOption(spec) {
-  return { ...spec, [isOptionSymbol]: true };
-}
-function rerouteArguments(a, b) {
-  if (typeof a === `undefined`)
-    return [a, b];
-  if (typeof a === `object` && a !== null && !Array.isArray(a)) {
-    return [void 0, a];
-  } else {
-    return [a, b];
-  }
-}
-function cleanValidationError(message, { mergeName = false } = {}) {
-  const match = message.match(/^([^:]+): (.*)$/m);
-  if (!match)
-    return `validation failed`;
-  let [, path16, line] = match;
-  if (mergeName)
-    line = line[0].toLowerCase() + line.slice(1);
-  line = path16 !== `.` || !mergeName ? `${path16.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`;
-  return line;
-}
-function formatError(message, errors) {
-  if (errors.length === 1) {
-    return new UsageError(`${message}${cleanValidationError(errors[0], { mergeName: true })}`);
-  } else {
-    return new UsageError(`${message}:
-${errors.map((error) => `
-- ${cleanValidationError(error)}`).join(``)}`);
-  }
-}
-function applyValidator(name2, value, validator) {
-  if (typeof validator === `undefined`)
-    return value;
-  const errors = [];
-  const coercions = [];
-  const coercion = (v) => {
-    const orig = value;
-    value = v;
-    return coercion.bind(null, orig);
-  };
-  const check = validator(value, { errors, coercions, coercion });
-  if (!check)
-    throw formatError(`Invalid value for ${name2}`, errors);
-  for (const [, op] of coercions)
-    op();
-  return value;
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Command.mjs
-var Command = class {
-  constructor() {
-    this.help = false;
-  }
-  /**
-   * Defines the usage information for the given command.
-   */
-  static Usage(usage) {
-    return usage;
-  }
-  /**
-   * Standard error handler which will simply rethrow the error. Can be used
-   * to add custom logic to handle errors from the command or simply return
-   * the parent class error handling.
-   */
-  async catch(error) {
-    throw error;
-  }
-  async validateAndExecute() {
-    const commandClass = this.constructor;
-    const cascade2 = commandClass.schema;
-    if (Array.isArray(cascade2)) {
-      const { isDict: isDict2, isUnknown: isUnknown2, applyCascade: applyCascade2 } = await Promise.resolve().then(() => (init_lib(), lib_exports));
-      const schema = applyCascade2(isDict2(isUnknown2()), cascade2);
-      const errors = [];
-      const coercions = [];
-      const check = schema(this, { errors, coercions });
-      if (!check)
-        throw formatError(`Invalid option schema`, errors);
-      for (const [, op] of coercions) {
-        op();
+// node_modules/tar/dist/esm/pack.js
+var import_fs12, import_path10, PackJob, EOF2, ONSTAT, ENDED3, QUEUE2, PENDINGLINKS, CURRENT, PROCESS2, PROCESSING, PROCESSJOB, JOBS, JOBDONE, ADDFSENTRY, ADDTARENTRY, STAT, READDIR, ONREADDIR, PIPE, ENTRY, ENTRYOPT, WRITEENTRYCLASS, WRITE, ONDRAIN2, Pack, PackSync;
+var init_pack = __esm({
+  "node_modules/tar/dist/esm/pack.js"() {
+    import_fs12 = __toESM(require("fs"), 1);
+    init_write_entry();
+    init_esm();
+    init_esm3();
+    init_esm5();
+    init_read_entry();
+    init_warn_method();
+    import_path10 = __toESM(require("path"), 1);
+    init_normalize_windows_path();
+    PackJob = class {
+      path;
+      absolute;
+      entry;
+      stat;
+      readdir;
+      pending = false;
+      pendingLink = false;
+      ignore = false;
+      piped = false;
+      constructor(path16, absolute) {
+        this.path = path16 || "./";
+        this.absolute = absolute;
       }
-    } else if (cascade2 != null) {
-      throw new Error(`Invalid command schema`);
-    }
-    const exitCode = await this.execute();
-    if (typeof exitCode !== `undefined`) {
-      return exitCode;
-    } else {
-      return 0;
-    }
-  }
-};
-Command.isOption = isOptionSymbol;
-Command.Default = [];
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/core.mjs
-function debug(str) {
-  if (DEBUG) {
-    console.log(str);
-  }
-}
-var basicHelpState = {
-  candidateUsage: null,
-  requiredOptions: [],
-  errorMessage: null,
-  ignoreOptions: false,
-  path: [],
-  positionals: [],
-  options: [],
-  remainder: null,
-  selectedIndex: HELP_COMMAND_INDEX
-};
-function makeStateMachine() {
-  return {
-    nodes: [makeNode(), makeNode(), makeNode()]
-  };
-}
-function makeAnyOfMachine(inputs) {
-  const output = makeStateMachine();
-  const heads = [];
-  let offset = output.nodes.length;
-  for (const input of inputs) {
-    heads.push(offset);
-    for (let t = 0; t < input.nodes.length; ++t)
-      if (!isTerminalNode(t))
-        output.nodes.push(cloneNode(input.nodes[t], offset));
-    offset += input.nodes.length - 2;
-  }
-  for (const head of heads)
-    registerShortcut(output, NODE_INITIAL, head);
-  return output;
-}
-function injectNode(machine, node) {
-  machine.nodes.push(node);
-  return machine.nodes.length - 1;
-}
-function simplifyMachine(input) {
-  const visited = /* @__PURE__ */ new Set();
-  const process5 = (node) => {
-    if (visited.has(node))
-      return;
-    visited.add(node);
-    const nodeDef = input.nodes[node];
-    for (const transitions of Object.values(nodeDef.statics))
-      for (const { to } of transitions)
-        process5(to);
-    for (const [, { to }] of nodeDef.dynamics)
-      process5(to);
-    for (const { to } of nodeDef.shortcuts)
-      process5(to);
-    const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
-    while (nodeDef.shortcuts.length > 0) {
-      const { to } = nodeDef.shortcuts.shift();
-      const toDef = input.nodes[to];
-      for (const [segment, transitions] of Object.entries(toDef.statics)) {
-        const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment) ? nodeDef.statics[segment] = [] : nodeDef.statics[segment];
-        for (const transition of transitions) {
-          if (!store.some(({ to: to2 }) => transition.to === to2)) {
-            store.push(transition);
+    };
+    EOF2 = Buffer.alloc(1024);
+    ONSTAT = /* @__PURE__ */ Symbol("onStat");
+    ENDED3 = /* @__PURE__ */ Symbol("ended");
+    QUEUE2 = /* @__PURE__ */ Symbol("queue");
+    PENDINGLINKS = /* @__PURE__ */ Symbol("queue");
+    CURRENT = /* @__PURE__ */ Symbol("current");
+    PROCESS2 = /* @__PURE__ */ Symbol("process");
+    PROCESSING = /* @__PURE__ */ Symbol("processing");
+    PROCESSJOB = /* @__PURE__ */ Symbol("processJob");
+    JOBS = /* @__PURE__ */ Symbol("jobs");
+    JOBDONE = /* @__PURE__ */ Symbol("jobDone");
+    ADDFSENTRY = /* @__PURE__ */ Symbol("addFSEntry");
+    ADDTARENTRY = /* @__PURE__ */ Symbol("addTarEntry");
+    STAT = /* @__PURE__ */ Symbol("stat");
+    READDIR = /* @__PURE__ */ Symbol("readdir");
+    ONREADDIR = /* @__PURE__ */ Symbol("onreaddir");
+    PIPE = /* @__PURE__ */ Symbol("pipe");
+    ENTRY = /* @__PURE__ */ Symbol("entry");
+    ENTRYOPT = /* @__PURE__ */ Symbol("entryOpt");
+    WRITEENTRYCLASS = /* @__PURE__ */ Symbol("writeEntryClass");
+    WRITE = /* @__PURE__ */ Symbol("write");
+    ONDRAIN2 = /* @__PURE__ */ Symbol("ondrain");
+    Pack = class extends Minipass {
+      sync = false;
+      opt;
+      cwd;
+      maxReadSize;
+      preservePaths;
+      strict;
+      noPax;
+      prefix;
+      linkCache;
+      statCache;
+      file;
+      portable;
+      zip;
+      readdirCache;
+      noDirRecurse;
+      follow;
+      noMtime;
+      mtime;
+      filter;
+      jobs;
+      [WRITEENTRYCLASS];
+      onWriteEntry;
+      // Note: we actually DO need a linked list here, because we
+      // shift() to update the head of the list where we start, but still
+      // while that happens, need to know what the next item in the queue
+      // will be. Since we do multiple jobs in parallel, it's not as simple
+      // as just an Array.shift(), since that would lose the information about
+      // the next job in the list. We could add a .next field on the PackJob
+      // class, but then we'd have to be tracking the tail of the queue the
+      // whole time, and Yallist just does that for us anyway.
+      [QUEUE2];
+      [PENDINGLINKS] = /* @__PURE__ */ new Map();
+      [JOBS] = 0;
+      [PROCESSING] = false;
+      [ENDED3] = false;
+      constructor(opt = {}) {
+        super();
+        this.opt = opt;
+        this.file = opt.file || "";
+        this.cwd = opt.cwd || process.cwd();
+        this.maxReadSize = opt.maxReadSize;
+        this.preservePaths = !!opt.preservePaths;
+        this.strict = !!opt.strict;
+        this.noPax = !!opt.noPax;
+        this.prefix = normalizeWindowsPath(opt.prefix || "");
+        this.linkCache = opt.linkCache || /* @__PURE__ */ new Map();
+        this.statCache = opt.statCache || /* @__PURE__ */ new Map();
+        this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map();
+        this.onWriteEntry = opt.onWriteEntry;
+        this[WRITEENTRYCLASS] = WriteEntry;
+        if (typeof opt.onwarn === "function") {
+          this.on("warn", opt.onwarn);
+        }
+        this.portable = !!opt.portable;
+        if (opt.gzip || opt.brotli || opt.zstd) {
+          if ((opt.gzip ? 1 : 0) + (opt.brotli ? 1 : 0) + (opt.zstd ? 1 : 0) > 1) {
+            throw new TypeError("gzip, brotli, zstd are mutually exclusive");
+          }
+          if (opt.gzip) {
+            if (typeof opt.gzip !== "object") {
+              opt.gzip = {};
+            }
+            if (this.portable) {
+              opt.gzip.portable = true;
+            }
+            this.zip = new Gzip(opt.gzip);
+          }
+          if (opt.brotli) {
+            if (typeof opt.brotli !== "object") {
+              opt.brotli = {};
+            }
+            this.zip = new BrotliCompress(opt.brotli);
+          }
+          if (opt.zstd) {
+            if (typeof opt.zstd !== "object") {
+              opt.zstd = {};
+            }
+            this.zip = new ZstdCompress(opt.zstd);
           }
+          if (!this.zip)
+            throw new Error("impossible");
+          const zip = this.zip;
+          zip.on("data", (chunk) => super.write(chunk));
+          zip.on("end", () => super.end());
+          zip.on("drain", () => this[ONDRAIN2]());
+          this.on("resume", () => zip.resume());
+        } else {
+          this.on("drain", this[ONDRAIN2]);
         }
+        this.noDirRecurse = !!opt.noDirRecurse;
+        this.follow = !!opt.follow;
+        this.noMtime = !!opt.noMtime;
+        if (opt.mtime)
+          this.mtime = opt.mtime;
+        this.filter = typeof opt.filter === "function" ? opt.filter : () => true;
+        this[QUEUE2] = new Yallist();
+        this[JOBS] = 0;
+        this.jobs = Number(opt.jobs) || 4;
+        this[PROCESSING] = false;
+        this[ENDED3] = false;
       }
-      for (const [test, transition] of toDef.dynamics)
-        if (!nodeDef.dynamics.some(([otherTest, { to: to2 }]) => test === otherTest && transition.to === to2))
-          nodeDef.dynamics.push([test, transition]);
-      for (const transition of toDef.shortcuts) {
-        if (!shortcuts.has(transition.to)) {
-          nodeDef.shortcuts.push(transition);
-          shortcuts.add(transition.to);
-        }
+      [WRITE](chunk) {
+        return super.write(chunk);
       }
-    }
-  };
-  process5(NODE_INITIAL);
-}
-function debugMachine(machine, { prefix = `` } = {}) {
-  if (DEBUG) {
-    debug(`${prefix}Nodes are:`);
-    for (let t = 0; t < machine.nodes.length; ++t) {
-      debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
-    }
-  }
-}
-function runMachineInternal(machine, input, partial = false) {
-  debug(`Running a vm on ${JSON.stringify(input)}`);
-  let branches = [{ node: NODE_INITIAL, state: {
-    candidateUsage: null,
-    requiredOptions: [],
-    errorMessage: null,
-    ignoreOptions: false,
-    options: [],
-    path: [],
-    positionals: [],
-    remainder: null,
-    selectedIndex: null
-  } }];
-  debugMachine(machine, { prefix: `  ` });
-  const tokens = [START_OF_INPUT, ...input];
-  for (let t = 0; t < tokens.length; ++t) {
-    const segment = tokens[t];
-    debug(`  Processing ${JSON.stringify(segment)}`);
-    const nextBranches = [];
-    for (const { node, state } of branches) {
-      debug(`    Current node is ${node}`);
-      const nodeDef = machine.nodes[node];
-      if (node === NODE_ERRORED) {
-        nextBranches.push({ node, state });
-        continue;
+      add(path16) {
+        this.write(path16);
+        return this;
       }
-      console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
-      const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
-      if (!partial || t < tokens.length - 1 || hasExactMatch) {
-        if (hasExactMatch) {
-          const transitions = nodeDef.statics[segment];
-          for (const { to, reducer } of transitions) {
-            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-            debug(`      Static transition to ${to} found`);
-          }
-        } else {
-          debug(`      No static transition found`);
+      end(path16, encoding, cb) {
+        if (typeof path16 === "function") {
+          cb = path16;
+          path16 = void 0;
         }
-      } else {
-        let hasMatches = false;
-        for (const candidate of Object.keys(nodeDef.statics)) {
-          if (!candidate.startsWith(segment))
-            continue;
-          if (segment === candidate) {
-            for (const { to, reducer } of nodeDef.statics[candidate]) {
-              nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-              debug(`      Static transition to ${to} found`);
-            }
-          } else {
-            for (const { to } of nodeDef.statics[candidate]) {
-              nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
-              debug(`      Static transition to ${to} found (partial match)`);
-            }
-          }
-          hasMatches = true;
+        if (typeof encoding === "function") {
+          cb = encoding;
+          encoding = void 0;
         }
-        if (!hasMatches) {
-          debug(`      No partial static transition found`);
+        if (path16) {
+          this.add(path16);
         }
+        this[ENDED3] = true;
+        this[PROCESS2]();
+        if (cb)
+          cb();
+        return this;
       }
-      if (segment !== END_OF_INPUT) {
-        for (const [test, { to, reducer }] of nodeDef.dynamics) {
-          if (execute(tests, test, state, segment)) {
-            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment) : state });
-            debug(`      Dynamic transition to ${to} found (via ${test})`);
-          }
+      write(path16) {
+        if (this[ENDED3]) {
+          throw new Error("write after end");
         }
-      }
-    }
-    if (nextBranches.length === 0 && segment === END_OF_INPUT && input.length === 1) {
-      return [{
-        node: NODE_INITIAL,
-        state: basicHelpState
-      }];
-    }
-    if (nextBranches.length === 0) {
-      throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
-        return node !== NODE_ERRORED;
-      }).map(({ state }) => {
-        return { usage: state.candidateUsage, reason: null };
-      }));
-    }
-    if (nextBranches.every(({ node }) => node === NODE_ERRORED)) {
-      throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
-        return { usage: state.candidateUsage, reason: state.errorMessage };
-      }));
-    }
-    branches = trimSmallerBranches(nextBranches);
-  }
-  if (branches.length > 0) {
-    debug(`  Results:`);
-    for (const branch of branches) {
-      debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
-    }
-  } else {
-    debug(`  No results`);
-  }
-  return branches;
-}
-function checkIfNodeIsFinished(node, state) {
-  if (state.selectedIndex !== null)
-    return true;
-  if (Object.prototype.hasOwnProperty.call(node.statics, END_OF_INPUT)) {
-    for (const { to } of node.statics[END_OF_INPUT])
-      if (to === NODE_SUCCESS)
-        return true;
-  }
-  return false;
-}
-function suggestMachine(machine, input, partial) {
-  const prefix = partial && input.length > 0 ? [``] : [];
-  const branches = runMachineInternal(machine, input, partial);
-  const suggestions = [];
-  const suggestionsJson = /* @__PURE__ */ new Set();
-  const traverseSuggestion = (suggestion, node, skipFirst = true) => {
-    let nextNodes = [node];
-    while (nextNodes.length > 0) {
-      const currentNodes = nextNodes;
-      nextNodes = [];
-      for (const node2 of currentNodes) {
-        const nodeDef = machine.nodes[node2];
-        const keys = Object.keys(nodeDef.statics);
-        for (const key of Object.keys(nodeDef.statics)) {
-          const segment = keys[0];
-          for (const { to, reducer } of nodeDef.statics[segment]) {
-            if (reducer !== `pushPath`)
-              continue;
-            if (!skipFirst)
-              suggestion.push(segment);
-            nextNodes.push(to);
-          }
+        if (path16 instanceof ReadEntry) {
+          this[ADDTARENTRY](path16);
+        } else {
+          this[ADDFSENTRY](path16);
         }
+        return this.flowing;
       }
-      skipFirst = false;
-    }
-    const json = JSON.stringify(suggestion);
-    if (suggestionsJson.has(json))
-      return;
-    suggestions.push(suggestion);
-    suggestionsJson.add(json);
-  };
-  for (const { node, state } of branches) {
-    if (state.remainder !== null) {
-      traverseSuggestion([state.remainder], node);
-      continue;
-    }
-    const nodeDef = machine.nodes[node];
-    const isFinished = checkIfNodeIsFinished(nodeDef, state);
-    for (const [candidate, transitions] of Object.entries(nodeDef.statics))
-      if (isFinished && candidate !== END_OF_INPUT || !candidate.startsWith(`-`) && transitions.some(({ reducer }) => reducer === `pushPath`))
-        traverseSuggestion([...prefix, candidate], node);
-    if (!isFinished)
-      continue;
-    for (const [test, { to }] of nodeDef.dynamics) {
-      if (to === NODE_ERRORED)
-        continue;
-      const tokens = suggest(test, state);
-      if (tokens === null)
-        continue;
-      for (const token of tokens) {
-        traverseSuggestion([...prefix, token], node);
-      }
-    }
-  }
-  return [...suggestions].sort();
-}
-function runMachine(machine, input) {
-  const branches = runMachineInternal(machine, [...input, END_OF_INPUT]);
-  return selectBestState(input, branches.map(({ state }) => {
-    return state;
-  }));
-}
-function trimSmallerBranches(branches) {
-  let maxPathSize = 0;
-  for (const { state } of branches)
-    if (state.path.length > maxPathSize)
-      maxPathSize = state.path.length;
-  return branches.filter(({ state }) => {
-    return state.path.length === maxPathSize;
-  });
-}
-function selectBestState(input, states) {
-  const terminalStates = states.filter((state) => {
-    return state.selectedIndex !== null;
-  });
-  if (terminalStates.length === 0)
-    throw new Error();
-  const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name2) => state.options.find((opt) => opt.name === name2))));
-  if (requiredOptionsSetStates.length === 0) {
-    throw new UnknownSyntaxError(input, terminalStates.map((state) => ({
-      usage: state.candidateUsage,
-      reason: null
-    })));
-  }
-  let maxPathSize = 0;
-  for (const state of requiredOptionsSetStates)
-    if (state.path.length > maxPathSize)
-      maxPathSize = state.path.length;
-  const bestPathBranches = requiredOptionsSetStates.filter((state) => {
-    return state.path.length === maxPathSize;
-  });
-  const getPositionalCount = (state) => state.positionals.filter(({ extra }) => {
-    return !extra;
-  }).length + state.options.length;
-  const statesWithPositionalCount = bestPathBranches.map((state) => {
-    return { state, positionalCount: getPositionalCount(state) };
-  });
-  let maxPositionalCount = 0;
-  for (const { positionalCount } of statesWithPositionalCount)
-    if (positionalCount > maxPositionalCount)
-      maxPositionalCount = positionalCount;
-  const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) => {
-    return positionalCount === maxPositionalCount;
-  }).map(({ state }) => {
-    return state;
-  });
-  const fixedStates = aggregateHelpStates(bestPositionalStates);
-  if (fixedStates.length > 1)
-    throw new AmbiguousSyntaxError(input, fixedStates.map((state) => state.candidateUsage));
-  return fixedStates[0];
-}
-function aggregateHelpStates(states) {
-  const notHelps = [];
-  const helps = [];
-  for (const state of states) {
-    if (state.selectedIndex === HELP_COMMAND_INDEX) {
-      helps.push(state);
-    } else {
-      notHelps.push(state);
-    }
-  }
-  if (helps.length > 0) {
-    notHelps.push({
-      ...basicHelpState,
-      path: findCommonPrefix(...helps.map((state) => state.path)),
-      options: helps.reduce((options, state) => options.concat(state.options), [])
-    });
-  }
-  return notHelps;
-}
-function findCommonPrefix(firstPath, secondPath, ...rest) {
-  if (secondPath === void 0)
-    return Array.from(firstPath);
-  return findCommonPrefix(firstPath.filter((segment, i) => segment === secondPath[i]), ...rest);
-}
-function makeNode() {
-  return {
-    dynamics: [],
-    shortcuts: [],
-    statics: {}
-  };
-}
-function isTerminalNode(node) {
-  return node === NODE_SUCCESS || node === NODE_ERRORED;
-}
-function cloneTransition(input, offset = 0) {
-  return {
-    to: !isTerminalNode(input.to) ? input.to > 2 ? input.to + offset - 2 : input.to + offset : input.to,
-    reducer: input.reducer
-  };
-}
-function cloneNode(input, offset = 0) {
-  const output = makeNode();
-  for (const [test, transition] of input.dynamics)
-    output.dynamics.push([test, cloneTransition(transition, offset)]);
-  for (const transition of input.shortcuts)
-    output.shortcuts.push(cloneTransition(transition, offset));
-  for (const [segment, transitions] of Object.entries(input.statics))
-    output.statics[segment] = transitions.map((transition) => cloneTransition(transition, offset));
-  return output;
-}
-function registerDynamic(machine, from, test, to, reducer) {
-  machine.nodes[from].dynamics.push([
-    test,
-    { to, reducer }
-  ]);
-}
-function registerShortcut(machine, from, to, reducer) {
-  machine.nodes[from].shortcuts.push({ to, reducer });
-}
-function registerStatic(machine, from, test, to, reducer) {
-  const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test) ? machine.nodes[from].statics[test] = [] : machine.nodes[from].statics[test];
-  store.push({ to, reducer });
-}
-function execute(store, callback, state, segment) {
-  if (Array.isArray(callback)) {
-    const [name2, ...args] = callback;
-    return store[name2](state, segment, ...args);
-  } else {
-    return store[callback](state, segment);
-  }
-}
-function suggest(callback, state) {
-  const fn2 = Array.isArray(callback) ? tests[callback[0]] : tests[callback];
-  if (typeof fn2.suggest === `undefined`)
-    return null;
-  const args = Array.isArray(callback) ? callback.slice(1) : [];
-  return fn2.suggest(state, ...args);
-}
-var tests = {
-  always: () => {
-    return true;
-  },
-  isOptionLike: (state, segment) => {
-    return !state.ignoreOptions && (segment !== `-` && segment.startsWith(`-`));
-  },
-  isNotOptionLike: (state, segment) => {
-    return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
-  },
-  isOption: (state, segment, name2, hidden) => {
-    return !state.ignoreOptions && segment === name2;
-  },
-  isBatchOption: (state, segment, names) => {
-    return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name2) => names.includes(`-${name2}`));
-  },
-  isBoundOption: (state, segment, names, options) => {
-    const optionParsing = segment.match(BINDING_REGEX);
-    return !state.ignoreOptions && !!optionParsing && OPTION_REGEX.test(optionParsing[1]) && names.includes(optionParsing[1]) && options.filter((opt) => opt.names.includes(optionParsing[1])).every((opt) => opt.allowBinding);
-  },
-  isNegatedOption: (state, segment, name2) => {
-    return !state.ignoreOptions && segment === `--no-${name2.slice(2)}`;
-  },
-  isHelp: (state, segment) => {
-    return !state.ignoreOptions && HELP_REGEX.test(segment);
-  },
-  isUnsupportedOption: (state, segment, names) => {
-    return !state.ignoreOptions && segment.startsWith(`-`) && OPTION_REGEX.test(segment) && !names.includes(segment);
-  },
-  isInvalidOption: (state, segment) => {
-    return !state.ignoreOptions && segment.startsWith(`-`) && !OPTION_REGEX.test(segment);
-  }
-};
-tests.isOption.suggest = (state, name2, hidden = true) => {
-  return !hidden ? [name2] : null;
-};
-var reducers = {
-  setCandidateState: (state, segment, candidateState) => {
-    return { ...state, ...candidateState };
-  },
-  setSelectedIndex: (state, segment, index) => {
-    return { ...state, selectedIndex: index };
-  },
-  pushBatch: (state, segment) => {
-    return { ...state, options: state.options.concat([...segment.slice(1)].map((name2) => ({ name: `-${name2}`, value: true }))) };
-  },
-  pushBound: (state, segment) => {
-    const [, name2, value] = segment.match(BINDING_REGEX);
-    return { ...state, options: state.options.concat({ name: name2, value }) };
-  },
-  pushPath: (state, segment) => {
-    return { ...state, path: state.path.concat(segment) };
-  },
-  pushPositional: (state, segment) => {
-    return { ...state, positionals: state.positionals.concat({ value: segment, extra: false }) };
-  },
-  pushExtra: (state, segment) => {
-    return { ...state, positionals: state.positionals.concat({ value: segment, extra: true }) };
-  },
-  pushExtraNoLimits: (state, segment) => {
-    return { ...state, positionals: state.positionals.concat({ value: segment, extra: NoLimits }) };
-  },
-  pushTrue: (state, segment, name2 = segment) => {
-    return { ...state, options: state.options.concat({ name: segment, value: true }) };
-  },
-  pushFalse: (state, segment, name2 = segment) => {
-    return { ...state, options: state.options.concat({ name: name2, value: false }) };
-  },
-  pushUndefined: (state, segment) => {
-    return { ...state, options: state.options.concat({ name: segment, value: void 0 }) };
-  },
-  pushStringValue: (state, segment) => {
-    var _a;
-    const copy = { ...state, options: [...state.options] };
-    const lastOption = state.options[state.options.length - 1];
-    lastOption.value = ((_a = lastOption.value) !== null && _a !== void 0 ? _a : []).concat([segment]);
-    return copy;
-  },
-  setStringValue: (state, segment) => {
-    const copy = { ...state, options: [...state.options] };
-    const lastOption = state.options[state.options.length - 1];
-    lastOption.value = segment;
-    return copy;
-  },
-  inhibateOptions: (state) => {
-    return { ...state, ignoreOptions: true };
-  },
-  useHelp: (state, segment, command) => {
-    const [
-      ,
-      /* name */
-      ,
-      index
-    ] = segment.match(HELP_REGEX);
-    if (typeof index !== `undefined`) {
-      return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
-    } else {
-      return { ...state, options: [{ name: `-c`, value: String(command) }] };
-    }
-  },
-  setError: (state, segment, errorMessage) => {
-    if (segment === END_OF_INPUT) {
-      return { ...state, errorMessage: `${errorMessage}.` };
-    } else {
-      return { ...state, errorMessage: `${errorMessage} ("${segment}").` };
-    }
-  },
-  setOptionArityError: (state, segment) => {
-    const lastOption = state.options[state.options.length - 1];
-    return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
-  }
-};
-var NoLimits = /* @__PURE__ */ Symbol();
-var CommandBuilder = class {
-  constructor(cliIndex, cliOpts) {
-    this.allOptionNames = [];
-    this.arity = { leading: [], trailing: [], extra: [], proxy: false };
-    this.options = [];
-    this.paths = [];
-    this.cliIndex = cliIndex;
-    this.cliOpts = cliOpts;
-  }
-  addPath(path16) {
-    this.paths.push(path16);
-  }
-  setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
-    Object.assign(this.arity, { leading, trailing, extra, proxy });
-  }
-  addPositional({ name: name2 = `arg`, required = true } = {}) {
-    if (!required && this.arity.extra === NoLimits)
-      throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
-    if (!required && this.arity.trailing.length > 0)
-      throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
-    if (!required && this.arity.extra !== NoLimits) {
-      this.arity.extra.push(name2);
-    } else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) {
-      this.arity.leading.push(name2);
-    } else {
-      this.arity.trailing.push(name2);
-    }
-  }
-  addRest({ name: name2 = `arg`, required = 0 } = {}) {
-    if (this.arity.extra === NoLimits)
-      throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
-    if (this.arity.trailing.length > 0)
-      throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
-    for (let t = 0; t < required; ++t)
-      this.addPositional({ name: name2 });
-    this.arity.extra = NoLimits;
-  }
-  addProxy({ required = 0 } = {}) {
-    this.addRest({ required });
-    this.arity.proxy = true;
-  }
-  addOption({ names, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
-    if (!allowBinding && arity > 1)
-      throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
-    if (!Number.isInteger(arity))
-      throw new Error(`The arity must be an integer, got ${arity}`);
-    if (arity < 0)
-      throw new Error(`The arity must be positive, got ${arity}`);
-    this.allOptionNames.push(...names);
-    this.options.push({ names, description, arity, hidden, required, allowBinding });
-  }
-  setContext(context) {
-    this.context = context;
-  }
-  usage({ detailed = true, inlineOptions = true } = {}) {
-    const segments = [this.cliOpts.binaryName];
-    const detailedOptionList = [];
-    if (this.paths.length > 0)
-      segments.push(...this.paths[0]);
-    if (detailed) {
-      for (const { names, arity, hidden, description, required } of this.options) {
-        if (hidden)
-          continue;
-        const args = [];
-        for (let t = 0; t < arity; ++t)
-          args.push(` #${t}`);
-        const definition = `${names.join(`,`)}${args.join(``)}`;
-        if (!inlineOptions && description) {
-          detailedOptionList.push({ definition, description, required });
+      [ADDTARENTRY](p) {
+        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p.path));
+        if (!this.filter(p.path, p)) {
+          p.resume();
         } else {
-          segments.push(required ? `<${definition}>` : `[${definition}]`);
+          const job = new PackJob(p.path, absolute);
+          job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
+          job.entry.on("end", () => this[JOBDONE](job));
+          this[JOBS] += 1;
+          this[QUEUE2].push(job);
         }
+        this[PROCESS2]();
+      }
+      [ADDFSENTRY](p) {
+        const absolute = normalizeWindowsPath(import_path10.default.resolve(this.cwd, p));
+        this[QUEUE2].push(new PackJob(p, absolute));
+        this[PROCESS2]();
+      }
+      [STAT](job) {
+        job.pending = true;
+        this[JOBS] += 1;
+        const stat = this.follow ? "stat" : "lstat";
+        import_fs12.default[stat](job.absolute, (er, stat2) => {
+          job.pending = false;
+          this[JOBS] -= 1;
+          if (er) {
+            this.emit("error", er);
+          } else {
+            this[ONSTAT](job, stat2);
+          }
+        });
       }
-      segments.push(...this.arity.leading.map((name2) => `<${name2}>`));
-      if (this.arity.extra === NoLimits)
-        segments.push(`...`);
-      else
-        segments.push(...this.arity.extra.map((name2) => `[${name2}]`));
-      segments.push(...this.arity.trailing.map((name2) => `<${name2}>`));
-    }
-    const usage = segments.join(` `);
-    return { usage, options: detailedOptionList };
-  }
-  compile() {
-    if (typeof this.context === `undefined`)
-      throw new Error(`Assertion failed: No context attached`);
-    const machine = makeStateMachine();
-    let firstNode = NODE_INITIAL;
-    const candidateUsage = this.usage().usage;
-    const requiredOptions = this.options.filter((opt) => opt.required).map((opt) => opt.names);
-    firstNode = injectNode(machine, makeNode());
-    registerStatic(machine, NODE_INITIAL, START_OF_INPUT, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
-    const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`;
-    const paths = this.paths.length > 0 ? this.paths : [[]];
-    for (const path16 of paths) {
-      let lastPathNode = firstNode;
-      if (path16.length > 0) {
-        const optionPathNode = injectNode(machine, makeNode());
-        registerShortcut(machine, lastPathNode, optionPathNode);
-        this.registerOptions(machine, optionPathNode);
-        lastPathNode = optionPathNode;
-      }
-      for (let t = 0; t < path16.length; ++t) {
-        const nextPathNode = injectNode(machine, makeNode());
-        registerStatic(machine, lastPathNode, path16[t], nextPathNode, `pushPath`);
-        lastPathNode = nextPathNode;
-      }
-      if (this.arity.leading.length > 0 || !this.arity.proxy) {
-        const helpNode = injectNode(machine, makeNode());
-        registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
-        registerDynamic(machine, helpNode, `always`, helpNode, `pushExtra`);
-        registerStatic(machine, helpNode, END_OF_INPUT, NODE_SUCCESS, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
-        this.registerOptions(machine, lastPathNode);
-      }
-      if (this.arity.leading.length > 0)
-        registerStatic(machine, lastPathNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
-      let lastLeadingNode = lastPathNode;
-      for (let t = 0; t < this.arity.leading.length; ++t) {
-        const nextLeadingNode = injectNode(machine, makeNode());
-        if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
-          this.registerOptions(machine, nextLeadingNode);
-        if (this.arity.trailing.length > 0 || t + 1 !== this.arity.leading.length)
-          registerStatic(machine, nextLeadingNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
-        registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
-        lastLeadingNode = nextLeadingNode;
-      }
-      let lastExtraNode = lastLeadingNode;
-      if (this.arity.extra === NoLimits || this.arity.extra.length > 0) {
-        const extraShortcutNode = injectNode(machine, makeNode());
-        registerShortcut(machine, lastLeadingNode, extraShortcutNode);
-        if (this.arity.extra === NoLimits) {
-          const extraNode = injectNode(machine, makeNode());
-          if (!this.arity.proxy)
-            this.registerOptions(machine, extraNode);
-          registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
-          registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
-          registerShortcut(machine, extraNode, extraShortcutNode);
-        } else {
-          for (let t = 0; t < this.arity.extra.length; ++t) {
-            const nextExtraNode = injectNode(machine, makeNode());
-            if (!this.arity.proxy || t > 0)
-              this.registerOptions(machine, nextExtraNode);
-            registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
-            registerShortcut(machine, nextExtraNode, extraShortcutNode);
-            lastExtraNode = nextExtraNode;
+      [ONSTAT](job, stat) {
+        this.statCache.set(job.absolute, stat);
+        job.stat = stat;
+        if (!this.filter(job.path, stat)) {
+          job.ignore = true;
+        } else if (stat.isFile() && stat.nlink > 1 && !this.linkCache.get(`${stat.dev}:${stat.ino}`) && !this.sync) {
+          if (job === this[CURRENT]) {
+            this[PROCESSJOB](job);
+          } else {
+            const key = `${stat.dev}:${stat.ino}`;
+            const pending = this[PENDINGLINKS].get(key);
+            if (pending)
+              pending.push(job);
+            else
+              this[PENDINGLINKS].set(key, [job]);
+            job.pendingLink = true;
+            job.pending = true;
           }
         }
-        lastExtraNode = extraShortcutNode;
-      }
-      if (this.arity.trailing.length > 0)
-        registerStatic(machine, lastExtraNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
-      let lastTrailingNode = lastExtraNode;
-      for (let t = 0; t < this.arity.trailing.length; ++t) {
-        const nextTrailingNode = injectNode(machine, makeNode());
-        if (!this.arity.proxy)
-          this.registerOptions(machine, nextTrailingNode);
-        if (t + 1 < this.arity.trailing.length)
-          registerStatic(machine, nextTrailingNode, END_OF_INPUT, NODE_ERRORED, [`setError`, `Not enough positional arguments`]);
-        registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
-        lastTrailingNode = nextTrailingNode;
-      }
-      registerDynamic(machine, lastTrailingNode, positionalArgument, NODE_ERRORED, [`setError`, `Extraneous positional argument`]);
-      registerStatic(machine, lastTrailingNode, END_OF_INPUT, NODE_SUCCESS, [`setSelectedIndex`, this.cliIndex]);
-    }
-    return {
-      machine,
-      context: this.context
-    };
-  }
-  registerOptions(machine, node) {
-    registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
-    registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, `pushBatch`);
-    registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
-    registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], NODE_ERRORED, [`setError`, `Unsupported option name`]);
-    registerDynamic(machine, node, [`isInvalidOption`], NODE_ERRORED, [`setError`, `Invalid option name`]);
-    for (const option of this.options) {
-      const longestName = option.names.reduce((longestName2, name2) => {
-        return name2.length > longestName2.length ? name2 : longestName2;
-      }, ``);
-      if (option.arity === 0) {
-        for (const name2 of option.names) {
-          registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], node, `pushTrue`);
-          if (name2.startsWith(`--`) && !name2.startsWith(`--no-`)) {
-            registerDynamic(machine, node, [`isNegatedOption`, name2], node, [`pushFalse`, name2]);
+        this[PROCESS2]();
+      }
+      [READDIR](job) {
+        job.pending = true;
+        this[JOBS] += 1;
+        import_fs12.default.readdir(job.absolute, (er, entries) => {
+          job.pending = false;
+          this[JOBS] -= 1;
+          if (er) {
+            return this.emit("error", er);
           }
-        }
-      } else {
-        let lastNode = injectNode(machine, makeNode());
-        for (const name2 of option.names)
-          registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], lastNode, `pushUndefined`);
-        for (let t = 0; t < option.arity; ++t) {
-          const nextNode = injectNode(machine, makeNode());
-          registerStatic(machine, lastNode, END_OF_INPUT, NODE_ERRORED, `setOptionArityError`);
-          registerDynamic(machine, lastNode, `isOptionLike`, NODE_ERRORED, `setOptionArityError`);
-          const action = option.arity === 1 ? `setStringValue` : `pushStringValue`;
-          registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
-          lastNode = nextNode;
-        }
-        registerShortcut(machine, lastNode, node);
+          this[ONREADDIR](job, entries);
+        });
       }
-    }
-  }
-};
-var CliBuilder = class _CliBuilder {
-  constructor({ binaryName = `...` } = {}) {
-    this.builders = [];
-    this.opts = { binaryName };
-  }
-  static build(cbs, opts = {}) {
-    return new _CliBuilder(opts).commands(cbs).compile();
-  }
-  getBuilderByIndex(n) {
-    if (!(n >= 0 && n < this.builders.length))
-      throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
-    return this.builders[n];
-  }
-  commands(cbs) {
-    for (const cb of cbs)
-      cb(this.command());
-    return this;
-  }
-  command() {
-    const builder = new CommandBuilder(this.builders.length, this.opts);
-    this.builders.push(builder);
-    return builder;
-  }
-  compile() {
-    const machines = [];
-    const contexts = [];
-    for (const builder of this.builders) {
-      const { machine: machine2, context } = builder.compile();
-      machines.push(machine2);
-      contexts.push(context);
-    }
-    const machine = makeAnyOfMachine(machines);
-    simplifyMachine(machine);
-    return {
-      machine,
-      contexts,
-      process: (input) => {
-        return runMachine(machine, input);
-      },
-      suggest: (input, partial) => {
-        return suggestMachine(machine, input, partial);
+      [ONREADDIR](job, entries) {
+        this.readdirCache.set(job.absolute, entries);
+        job.readdir = entries;
+        this[PROCESS2]();
       }
-    };
-  }
-};
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Cli.mjs
-var import_platform = __toESM(require_node(), 1);
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/HelpCommand.mjs
-var HelpCommand = class _HelpCommand extends Command {
-  constructor(contexts) {
-    super();
-    this.contexts = contexts;
-    this.commands = [];
-  }
-  static from(state, contexts) {
-    const command = new _HelpCommand(contexts);
-    command.path = state.path;
-    for (const opt of state.options) {
-      switch (opt.name) {
-        case `-c`:
-          {
-            command.commands.push(Number(opt.value));
+      [PROCESS2]() {
+        if (this[PROCESSING]) {
+          return;
+        }
+        this[PROCESSING] = true;
+        for (let w = this[QUEUE2].head; !!w && this[JOBS] < this.jobs; w = w.next) {
+          this[PROCESSJOB](w.value);
+          if (w.value.ignore) {
+            const p = w.next;
+            this[QUEUE2].removeNode(w);
+            w.next = p;
           }
-          break;
-        case `-i`:
-          {
-            command.index = Number(opt.value);
+        }
+        this[PROCESSING] = false;
+        if (this[ENDED3] && this[QUEUE2].length === 0 && this[JOBS] === 0) {
+          if (this.zip) {
+            this.zip.end(EOF2);
+          } else {
+            super.write(EOF2);
+            super.end();
           }
-          break;
-      }
-    }
-    return command;
-  }
-  async execute() {
-    let commands = this.commands;
-    if (typeof this.index !== `undefined` && this.index >= 0 && this.index < commands.length)
-      commands = [commands[this.index]];
-    if (commands.length === 0) {
-      this.context.stdout.write(this.cli.usage());
-    } else if (commands.length === 1) {
-      this.context.stdout.write(this.cli.usage(this.contexts[commands[0]].commandClass, { detailed: true }));
-    } else if (commands.length > 1) {
-      this.context.stdout.write(`Multiple commands match your selection:
-`);
-      this.context.stdout.write(`
-`);
-      let index = 0;
-      for (const command of this.commands)
-        this.context.stdout.write(this.cli.usage(this.contexts[command].commandClass, { prefix: `${index++}. `.padStart(5) }));
-      this.context.stdout.write(`
-`);
-      this.context.stdout.write(`Run again with -h=<index> to see the longer details of any of those commands.
-`);
-    }
-  }
-};
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Cli.mjs
-var errorCommandSymbol = /* @__PURE__ */ Symbol(`clipanion/errorCommand`);
-var Cli = class _Cli {
-  constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
-    this.registrations = /* @__PURE__ */ new Map();
-    this.builder = new CliBuilder({ binaryName: binaryNameOpt });
-    this.binaryLabel = binaryLabel;
-    this.binaryName = binaryNameOpt;
-    this.binaryVersion = binaryVersion;
-    this.enableCapture = enableCapture;
-    this.enableColors = enableColors;
-  }
-  /**
-   * Creates a new Cli and registers all commands passed as parameters.
-   *
-   * @param commandClasses The Commands to register
-   * @returns The created `Cli` instance
-   */
-  static from(commandClasses, options = {}) {
-    const cli = new _Cli(options);
-    const resolvedCommandClasses = Array.isArray(commandClasses) ? commandClasses : [commandClasses];
-    for (const commandClass of resolvedCommandClasses)
-      cli.register(commandClass);
-    return cli;
-  }
-  /**
-   * Registers a command inside the CLI.
-   */
-  register(commandClass) {
-    var _a;
-    const specs = /* @__PURE__ */ new Map();
-    const command = new commandClass();
-    for (const key in command) {
-      const value = command[key];
-      if (typeof value === `object` && value !== null && value[Command.isOption]) {
-        specs.set(key, value);
+        }
       }
-    }
-    const builder = this.builder.command();
-    const index = builder.cliIndex;
-    const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths;
-    if (typeof paths !== `undefined`)
-      for (const path16 of paths)
-        builder.addPath(path16);
-    this.registrations.set(commandClass, { specs, builder, index });
-    for (const [key, { definition }] of specs.entries())
-      definition(builder, key);
-    builder.setContext({
-      commandClass
-    });
-  }
-  process(input, userContext) {
-    const { contexts, process: process5 } = this.builder.compile();
-    const state = process5(input);
-    const context = {
-      ..._Cli.defaultContext,
-      ...userContext
-    };
-    switch (state.selectedIndex) {
-      case HELP_COMMAND_INDEX: {
-        const command = HelpCommand.from(state, contexts);
-        command.context = context;
-        return command;
+      get [CURRENT]() {
+        return this[QUEUE2] && this[QUEUE2].head && this[QUEUE2].head.value;
       }
-      default:
-        {
-          const { commandClass } = contexts[state.selectedIndex];
-          const record = this.registrations.get(commandClass);
-          if (typeof record === `undefined`)
-            throw new Error(`Assertion failed: Expected the command class to have been registered.`);
-          const command = new commandClass();
-          command.context = context;
-          command.path = state.path;
-          try {
-            for (const [key, { transformer }] of record.specs.entries())
-              command[key] = transformer(record.builder, key, state, context);
-            return command;
-          } catch (error) {
-            error[errorCommandSymbol] = command;
-            throw error;
+      [JOBDONE](job) {
+        this[QUEUE2].shift();
+        this[JOBS] -= 1;
+        const { stat } = job;
+        if (stat && stat.isFile() && stat.nlink > 1) {
+          const key = `${stat.dev}:${stat.ino}`;
+          const pending = this[PENDINGLINKS].get(key);
+          if (pending) {
+            this[PENDINGLINKS].delete(key);
+            for (const job2 of pending) {
+              job2.pending = false;
+              this[PROCESSJOB](job2);
+            }
           }
         }
-        break;
-    }
-  }
-  async run(input, userContext) {
-    var _a, _b;
-    let command;
-    const context = {
-      ..._Cli.defaultContext,
-      ...userContext
-    };
-    const colored = (_a = this.enableColors) !== null && _a !== void 0 ? _a : context.colorDepth > 1;
-    if (!Array.isArray(input)) {
-      command = input;
-    } else {
-      try {
-        command = this.process(input, context);
-      } catch (error) {
-        context.stdout.write(this.error(error, { colored }));
-        return 1;
+        this[PROCESS2]();
       }
-    }
-    if (command.help) {
-      context.stdout.write(this.usage(command, { colored, detailed: true }));
-      return 0;
-    }
-    command.context = context;
-    command.cli = {
-      binaryLabel: this.binaryLabel,
-      binaryName: this.binaryName,
-      binaryVersion: this.binaryVersion,
-      enableCapture: this.enableCapture,
-      enableColors: this.enableColors,
-      definitions: () => this.definitions(),
-      error: (error, opts) => this.error(error, opts),
-      format: (colored2) => this.format(colored2),
-      process: (input2, subContext) => this.process(input2, { ...context, ...subContext }),
-      run: (input2, subContext) => this.run(input2, { ...context, ...subContext }),
-      usage: (command2, opts) => this.usage(command2, opts)
-    };
-    const activate = this.enableCapture ? (_b = (0, import_platform.getCaptureActivator)(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator;
-    let exitCode;
-    try {
-      exitCode = await activate(() => command.validateAndExecute().catch((error) => command.catch(error).then(() => 0)));
-    } catch (error) {
-      context.stdout.write(this.error(error, { colored, command }));
-      return 1;
-    }
-    return exitCode;
-  }
-  async runExit(input, context) {
-    process.exitCode = await this.run(input, context);
-  }
-  suggest(input, partial) {
-    const { suggest: suggest2 } = this.builder.compile();
-    return suggest2(input, partial);
-  }
-  definitions({ colored = false } = {}) {
-    const data = [];
-    for (const [commandClass, { index }] of this.registrations) {
-      if (typeof commandClass.usage === `undefined`)
-        continue;
-      const { usage: path16 } = this.getUsageByIndex(index, { detailed: false });
-      const { usage, options } = this.getUsageByIndex(index, { detailed: true, inlineOptions: false });
-      const category = typeof commandClass.usage.category !== `undefined` ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0;
-      const description = typeof commandClass.usage.description !== `undefined` ? formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0;
-      const details = typeof commandClass.usage.details !== `undefined` ? formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0;
-      const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli]) => [formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli.replace(/\$0/g, this.binaryName)]) : void 0;
-      data.push({ path: path16, usage, category, description, details, examples, options });
-    }
-    return data;
-  }
-  usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
-    var _a;
-    if (command === null) {
-      for (const commandClass2 of this.registrations.keys()) {
-        const paths = commandClass2.paths;
-        const isDocumented = typeof commandClass2.usage !== `undefined`;
-        const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 && paths[0].length === 0;
-        const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path16) => path16.length === 0)) !== null && _a !== void 0 ? _a : false);
-        if (isDefault) {
-          if (command) {
-            command = null;
-            break;
+      [PROCESSJOB](job) {
+        if (job.pending && job.pendingLink && job === this[CURRENT]) {
+          job.pending = false;
+          job.pendingLink = false;
+        }
+        if (job.pending) {
+          return;
+        }
+        if (job.entry) {
+          if (job === this[CURRENT] && !job.piped) {
+            this[PIPE](job);
+          }
+          return;
+        }
+        if (!job.stat) {
+          const sc = this.statCache.get(job.absolute);
+          if (sc) {
+            this[ONSTAT](job, sc);
           } else {
-            command = commandClass2;
+            this[STAT](job);
           }
-        } else {
-          if (isDocumented) {
-            command = null;
-            continue;
+        }
+        if (!job.stat) {
+          return;
+        }
+        if (job.ignore) {
+          return;
+        }
+        if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
+          const rc = this.readdirCache.get(job.absolute);
+          if (rc) {
+            this[ONREADDIR](job, rc);
+          } else {
+            this[READDIR](job);
+          }
+          if (!job.readdir) {
+            return;
           }
         }
+        job.entry = this[ENTRY](job);
+        if (!job.entry) {
+          job.ignore = true;
+          return;
+        }
+        if (job === this[CURRENT] && !job.piped) {
+          this[PIPE](job);
+        }
       }
-      if (command) {
-        detailed = true;
-      }
-    }
-    const commandClass = command !== null && command instanceof Command ? command.constructor : command;
-    let result = ``;
-    if (!commandClass) {
-      const commandsByCategories = /* @__PURE__ */ new Map();
-      for (const [commandClass2, { index }] of this.registrations.entries()) {
-        if (typeof commandClass2.usage === `undefined`)
-          continue;
-        const category = typeof commandClass2.usage.category !== `undefined` ? formatMarkdownish(commandClass2.usage.category, { format: this.format(colored), paragraphs: false }) : null;
-        let categoryCommands = commandsByCategories.get(category);
-        if (typeof categoryCommands === `undefined`)
-          commandsByCategories.set(category, categoryCommands = []);
-        const { usage } = this.getUsageByIndex(index);
-        categoryCommands.push({ commandClass: commandClass2, usage });
-      }
-      const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) => {
-        if (a === null)
-          return -1;
-        if (b === null)
-          return 1;
-        return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
-      });
-      const hasLabel = typeof this.binaryLabel !== `undefined`;
-      const hasVersion = typeof this.binaryVersion !== `undefined`;
-      if (hasLabel || hasVersion) {
-        if (hasLabel && hasVersion)
-          result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}
-
-`;
-        else if (hasLabel)
-          result += `${this.format(colored).header(`${this.binaryLabel}`)}
-`;
-        else
-          result += `${this.format(colored).header(`${this.binaryVersion}`)}
-`;
-        result += `  ${this.format(colored).bold(prefix)}${this.binaryName} <command>
-`;
-      } else {
-        result += `${this.format(colored).bold(prefix)}${this.binaryName} <command>
-`;
+      [ENTRYOPT](job) {
+        return {
+          onwarn: (code2, msg, data) => this.warn(code2, msg, data),
+          noPax: this.noPax,
+          cwd: this.cwd,
+          absolute: job.absolute,
+          preservePaths: this.preservePaths,
+          maxReadSize: this.maxReadSize,
+          strict: this.strict,
+          portable: this.portable,
+          linkCache: this.linkCache,
+          statCache: this.statCache,
+          noMtime: this.noMtime,
+          mtime: this.mtime,
+          prefix: this.prefix,
+          onWriteEntry: this.onWriteEntry
+        };
       }
-      for (const categoryName of categoryNames) {
-        const commands = commandsByCategories.get(categoryName).slice().sort((a, b) => {
-          return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
-        });
-        const header = categoryName !== null ? categoryName.trim() : `General commands`;
-        result += `
-`;
-        result += `${this.format(colored).header(`${header}`)}
-`;
-        for (const { commandClass: commandClass2, usage } of commands) {
-          const doc = commandClass2.usage.description || `undocumented`;
-          result += `
-`;
-          result += `  ${this.format(colored).bold(usage)}
-`;
-          result += `    ${formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
+      [ENTRY](job) {
+        this[JOBS] += 1;
+        try {
+          const e = new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job));
+          return e.on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er));
+        } catch (er) {
+          this.emit("error", er);
         }
       }
-      result += `
-`;
-      result += formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
-    } else {
-      if (!detailed) {
-        const { usage } = this.getUsageByRegistration(commandClass);
-        result += `${this.format(colored).bold(prefix)}${usage}
-`;
-      } else {
-        const { description = ``, details = ``, examples = [] } = commandClass.usage || {};
-        if (description !== ``) {
-          result += formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, ($0) => $0.toUpperCase());
-          result += `
-`;
-        }
-        if (details !== `` || examples.length > 0) {
-          result += `${this.format(colored).header(`Usage`)}
-`;
-          result += `
-`;
-        }
-        const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
-        result += `${this.format(colored).bold(prefix)}${usage}
-`;
-        if (options.length > 0) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Options`)}
-`;
-          const maxDefinitionLength = options.reduce((length, option) => {
-            return Math.max(length, option.definition.length);
-          }, 0);
-          result += `
-`;
-          for (const { definition, description: description2 } of options) {
-            result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${formatMarkdownish(description2, { format: this.format(colored), paragraphs: false })}`;
-          }
+      [ONDRAIN2]() {
+        if (this[CURRENT] && this[CURRENT].entry) {
+          this[CURRENT].entry.resume();
         }
-        if (details !== ``) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Details`)}
-`;
-          result += `
-`;
-          result += formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
+      }
+      // like .pipe() but using super, because our write() is special
+      [PIPE](job) {
+        job.piped = true;
+        if (job.readdir) {
+          job.readdir.forEach((entry) => {
+            const p = job.path;
+            const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+            this[ADDFSENTRY](base + entry);
+          });
         }
-        if (examples.length > 0) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Examples`)}
-`;
-          for (const [description2, example] of examples) {
-            result += `
-`;
-            result += formatMarkdownish(description2, { format: this.format(colored), paragraphs: false });
-            result += `${example.replace(/^/m, `  ${this.format(colored).bold(prefix)}`).replace(/\$0/g, this.binaryName)}
-`;
-          }
+        const source = job.entry;
+        const zip = this.zip;
+        if (!source)
+          throw new Error("cannot pipe without source");
+        if (zip) {
+          source.on("data", (chunk) => {
+            if (!zip.write(chunk)) {
+              source.pause();
+            }
+          });
+        } else {
+          source.on("data", (chunk) => {
+            if (!super.write(chunk)) {
+              source.pause();
+            }
+          });
         }
       }
-    }
-    return result;
-  }
-  error(error, _a) {
-    var _b;
-    var { colored, command = (_b = error[errorCommandSymbol]) !== null && _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
-    if (!error || typeof error !== `object` || !(`stack` in error))
-      error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
-    let result = ``;
-    let name2 = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
-    if (name2 === `Error`)
-      name2 = `Internal Error`;
-    result += `${this.format(colored).error(name2)}: ${error.message}
-`;
-    const meta = error.clipanion;
-    if (typeof meta !== `undefined`) {
-      if (meta.type === `usage`) {
-        result += `
-`;
-        result += this.usage(command);
+      pause() {
+        if (this.zip) {
+          this.zip.pause();
+        }
+        return super.pause();
       }
-    } else {
-      if (error.stack) {
-        result += `${error.stack.replace(/^.*\n/, ``)}
-`;
+      warn(code2, message, data = {}) {
+        warnMethod(this, code2, message, data);
       }
-    }
-    return result;
-  }
-  format(colored) {
-    var _a;
-    return ((_a = colored !== null && colored !== void 0 ? colored : this.enableColors) !== null && _a !== void 0 ? _a : _Cli.defaultContext.colorDepth > 1) ? richFormat : textFormat;
-  }
-  getUsageByRegistration(klass, opts) {
-    const record = this.registrations.get(klass);
-    if (typeof record === `undefined`)
-      throw new Error(`Assertion failed: Unregistered command`);
-    return this.getUsageByIndex(record.index, opts);
-  }
-  getUsageByIndex(n, opts) {
-    return this.builder.getBuilderByIndex(n).usage(opts);
-  }
-};
-Cli.defaultContext = {
-  env: process.env,
-  stdin: process.stdin,
-  stdout: process.stdout,
-  stderr: process.stderr,
-  colorDepth: (0, import_platform.getDefaultColorDepth)()
-};
-function noopCaptureActivator(fn2) {
-  return fn2();
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/index.mjs
-var builtins_exports = {};
-__export(builtins_exports, {
-  DefinitionsCommand: () => DefinitionsCommand,
-  HelpCommand: () => HelpCommand2,
-  VersionCommand: () => VersionCommand
-});
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/definitions.mjs
-var DefinitionsCommand = class extends Command {
-  async execute() {
-    this.context.stdout.write(`${JSON.stringify(this.cli.definitions(), null, 2)}
-`);
-  }
-};
-DefinitionsCommand.paths = [[`--clipanion=definitions`]];
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/help.mjs
-var HelpCommand2 = class extends Command {
-  async execute() {
-    this.context.stdout.write(this.cli.usage());
-  }
-};
-HelpCommand2.paths = [[`-h`], [`--help`]];
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/version.mjs
-var VersionCommand = class extends Command {
-  async execute() {
-    var _a;
-    this.context.stdout.write(`${(_a = this.cli.binaryVersion) !== null && _a !== void 0 ? _a : `<unknown>`}
-`);
-  }
-};
-VersionCommand.paths = [[`-v`], [`--version`]];
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/index.mjs
-var options_exports = {};
-__export(options_exports, {
-  Array: () => Array2,
-  Boolean: () => Boolean2,
-  Counter: () => Counter,
-  Proxy: () => Proxy2,
-  Rest: () => Rest,
-  String: () => String2,
-  applyValidator: () => applyValidator,
-  cleanValidationError: () => cleanValidationError,
-  formatError: () => formatError,
-  isOptionSymbol: () => isOptionSymbol,
-  makeCommandOption: () => makeCommandOption,
-  rerouteArguments: () => rerouteArguments
-});
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Array.mjs
-function Array2(descriptor, initialValueBase, optsBase) {
-  const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
-  const { arity = 1 } = opts;
-  const optNames = descriptor.split(`,`);
-  const nameSet = new Set(optNames);
-  return makeCommandOption({
-    definition(builder) {
-      builder.addOption({
-        names: optNames,
-        arity,
-        hidden: opts === null || opts === void 0 ? void 0 : opts.hidden,
-        description: opts === null || opts === void 0 ? void 0 : opts.description,
-        required: opts.required
-      });
-    },
-    transformer(builder, key, state) {
-      let usedName;
-      let currentValue = typeof initialValue !== `undefined` ? [...initialValue] : void 0;
-      for (const { name: name2, value } of state.options) {
-        if (!nameSet.has(name2))
-          continue;
-        usedName = name2;
-        currentValue = currentValue !== null && currentValue !== void 0 ? currentValue : [];
-        currentValue.push(value);
+    };
+    PackSync = class extends Pack {
+      sync = true;
+      constructor(opt) {
+        super(opt);
+        this[WRITEENTRYCLASS] = WriteEntrySync;
       }
-      if (typeof currentValue !== `undefined`) {
-        return applyValidator(usedName !== null && usedName !== void 0 ? usedName : key, currentValue, opts.validator);
-      } else {
-        return currentValue;
+      // pause/resume are no-ops in sync streams.
+      pause() {
       }
-    }
-  });
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Boolean.mjs
-function Boolean2(descriptor, initialValueBase, optsBase) {
-  const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
-  const optNames = descriptor.split(`,`);
-  const nameSet = new Set(optNames);
-  return makeCommandOption({
-    definition(builder) {
-      builder.addOption({
-        names: optNames,
-        allowBinding: false,
-        arity: 0,
-        hidden: opts.hidden,
-        description: opts.description,
-        required: opts.required
-      });
-    },
-    transformer(builer, key, state) {
-      let currentValue = initialValue;
-      for (const { name: name2, value } of state.options) {
-        if (!nameSet.has(name2))
-          continue;
-        currentValue = value;
+      resume() {
       }
-      return currentValue;
-    }
-  });
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Counter.mjs
-function Counter(descriptor, initialValueBase, optsBase) {
-  const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
-  const optNames = descriptor.split(`,`);
-  const nameSet = new Set(optNames);
-  return makeCommandOption({
-    definition(builder) {
-      builder.addOption({
-        names: optNames,
-        allowBinding: false,
-        arity: 0,
-        hidden: opts.hidden,
-        description: opts.description,
-        required: opts.required
-      });
-    },
-    transformer(builder, key, state) {
-      let currentValue = initialValue;
-      for (const { name: name2, value } of state.options) {
-        if (!nameSet.has(name2))
-          continue;
-        currentValue !== null && currentValue !== void 0 ? currentValue : currentValue = 0;
-        if (!value) {
-          currentValue = 0;
+      [STAT](job) {
+        const stat = this.follow ? "statSync" : "lstatSync";
+        this[ONSTAT](job, import_fs12.default[stat](job.absolute));
+      }
+      [READDIR](job) {
+        this[ONREADDIR](job, import_fs12.default.readdirSync(job.absolute));
+      }
+      // gotta get it all in this tick
+      [PIPE](job) {
+        const source = job.entry;
+        const zip = this.zip;
+        if (job.readdir) {
+          job.readdir.forEach((entry) => {
+            const p = job.path;
+            const base = p === "./" ? "" : p.replace(/\/*$/, "/");
+            this[ADDFSENTRY](base + entry);
+          });
+        }
+        if (!source)
+          throw new Error("Cannot pipe without source");
+        if (zip) {
+          source.on("data", (chunk) => {
+            zip.write(chunk);
+          });
         } else {
-          currentValue += 1;
+          source.on("data", (chunk) => {
+            super[WRITE](chunk);
+          });
         }
       }
-      return currentValue;
-    }
-  });
-}
+    };
+  }
+});
 
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Proxy.mjs
-function Proxy2(opts = {}) {
-  return makeCommandOption({
-    definition(builder, key) {
-      var _a;
-      builder.addProxy({
-        name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
-        required: opts.required
+// node_modules/tar/dist/esm/create.js
+var create_exports = {};
+__export(create_exports, {
+  create: () => create
+});
+var import_node_path8, createFileSync, createFile, addFilesSync, addFilesAsync, createSync, createAsync, create;
+var init_create = __esm({
+  "node_modules/tar/dist/esm/create.js"() {
+    init_esm2();
+    import_node_path8 = __toESM(require("node:path"), 1);
+    init_list();
+    init_make_command();
+    init_pack();
+    createFileSync = (opt, files) => {
+      const p = new PackSync(opt);
+      const stream = new WriteStreamSync(opt.file, {
+        mode: opt.mode || 438
       });
-    },
-    transformer(builder, key, state) {
-      return state.positionals.map(({ value }) => value);
-    }
-  });
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Rest.mjs
-function Rest(opts = {}) {
-  return makeCommandOption({
-    definition(builder, key) {
-      var _a;
-      builder.addRest({
-        name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
-        required: opts.required
+      p.pipe(stream);
+      addFilesSync(p, files);
+    };
+    createFile = (opt, files) => {
+      const p = new Pack(opt);
+      const stream = new WriteStream(opt.file, {
+        mode: opt.mode || 438
       });
-    },
-    transformer(builder, key, state) {
-      const isRestPositional = (index) => {
-        const positional = state.positionals[index];
-        if (positional.extra === NoLimits)
-          return true;
-        if (positional.extra === false && index < builder.arity.leading.length)
-          return true;
-        return false;
-      };
-      let count = 0;
-      while (count < state.positionals.length && isRestPositional(count))
-        count += 1;
-      return state.positionals.splice(0, count).map(({ value }) => value);
-    }
-  });
-}
-
-// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/String.mjs
-function StringOption(descriptor, initialValueBase, optsBase) {
-  const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {});
-  const { arity = 1 } = opts;
-  const optNames = descriptor.split(`,`);
-  const nameSet = new Set(optNames);
-  return makeCommandOption({
-    definition(builder) {
-      builder.addOption({
-        names: optNames,
-        arity: opts.tolerateBoolean ? 0 : arity,
-        hidden: opts.hidden,
-        description: opts.description,
-        required: opts.required
+      p.pipe(stream);
+      const promise = new Promise((res, rej) => {
+        stream.on("error", rej);
+        stream.on("close", res);
+        p.on("error", rej);
       });
-    },
-    transformer(builder, key, state, context) {
-      let usedName;
-      let currentValue = initialValue;
-      if (typeof opts.env !== `undefined` && context.env[opts.env]) {
-        usedName = opts.env;
-        currentValue = context.env[opts.env];
-      }
-      for (const { name: name2, value } of state.options) {
-        if (!nameSet.has(name2))
-          continue;
-        usedName = name2;
-        currentValue = value;
-      }
-      if (typeof currentValue === `string`) {
-        return applyValidator(usedName !== null && usedName !== void 0 ? usedName : key, currentValue, opts.validator);
-      } else {
-        return currentValue;
-      }
-    }
-  });
-}
-function StringPositional(opts = {}) {
-  const { required = true } = opts;
-  return makeCommandOption({
-    definition(builder, key) {
-      var _a;
-      builder.addPositional({
-        name: (_a = opts.name) !== null && _a !== void 0 ? _a : key,
-        required: opts.required
+      addFilesAsync(p, files).catch((er) => p.emit("error", er));
+      return promise;
+    };
+    addFilesSync = (p, files) => {
+      files.forEach((file) => {
+        if (file.charAt(0) === "@") {
+          list({
+            file: import_node_path8.default.resolve(p.cwd, file.slice(1)),
+            sync: true,
+            noResume: true,
+            onReadEntry: (entry) => p.add(entry)
+          });
+        } else {
+          p.add(file);
+        }
       });
-    },
-    transformer(builder, key, state) {
-      var _a;
-      for (let i = 0; i < state.positionals.length; ++i) {
-        if (state.positionals[i].extra === NoLimits)
-          continue;
-        if (required && state.positionals[i].extra === true)
-          continue;
-        if (!required && state.positionals[i].extra === false)
-          continue;
-        const [positional] = state.positionals.splice(i, 1);
-        return applyValidator((_a = opts.name) !== null && _a !== void 0 ? _a : key, positional.value, opts.validator);
+      p.end();
+    };
+    addFilesAsync = async (p, files) => {
+      for (const file of files) {
+        if (file.charAt(0) === "@") {
+          await list({
+            file: import_node_path8.default.resolve(String(p.cwd), file.slice(1)),
+            noResume: true,
+            onReadEntry: (entry) => {
+              p.add(entry);
+            }
+          });
+        } else {
+          p.add(file);
+        }
       }
-      return void 0;
-    }
-  });
-}
-function String2(descriptor, ...args) {
-  if (typeof descriptor === `string`) {
-    return StringOption(descriptor, ...args);
-  } else {
-    return StringPositional(descriptor);
+      p.end();
+    };
+    createSync = (opt, files) => {
+      const p = new PackSync(opt);
+      addFilesSync(p, files);
+      return p;
+    };
+    createAsync = (opt, files) => {
+      const p = new Pack(opt);
+      addFilesAsync(p, files).catch((er) => p.emit("error", er));
+      return p;
+    };
+    create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => {
+      if (!files?.length) {
+        throw new TypeError("no paths specified to add to archive");
+      }
+    });
   }
-}
+});
+
+// node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "node_modules/semver/functions/major.js"(exports2, module2) {
+    "use strict";
+    var SemVer3 = require_semver();
+    var major = (a, loose) => new SemVer3(a, loose).major;
+    module2.exports = major;
+  }
+});
+
+// sources/_lib.ts
+var lib_exports2 = {};
+__export(lib_exports2, {
+  runMain: () => runMain
+});
+module.exports = __toCommonJS(lib_exports2);
+
+// sources/main.ts
+var import_clipanion17 = __toESM(require_advanced());
 
 // package.json
-var version = "0.34.7";
+var version = "0.35.0";
 
 // sources/Engine.ts
+var import_clipanion5 = __toESM(require_advanced());
 var import_fs6 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
 var import_process3 = __toESM(require("process"));
@@ -21777,7 +12578,7 @@ var import_valid4 = __toESM(require_valid2());
 var config_default = {
   definitions: {
     npm: {
-      default: "11.12.1+sha1.432da55a9f0ca53c982740fabe2b081a38019fb1",
+      default: "11.14.1+sha1.4a6839650da0005f323fec6abd39d77ee24f842f",
       fetchLatestFrom: {
         type: "npm",
         package: "npm"
@@ -21814,7 +12615,7 @@ var config_default = {
       }
     },
     pnpm: {
-      default: "10.33.0+sha1.46a0bef28aad690765997ab6da6d5475bdd4148e",
+      default: "11.1.2+sha1.ed39d701687311ce9345771c62376f9fe7286694",
       fetchLatestFrom: {
         type: "npm",
         package: "pnpm"
@@ -21992,6 +12793,7 @@ var import_debug = __toESM(require_src());
 var log = (0, import_debug.default)(`corepack`);
 
 // sources/folderUtils.ts
+var import_clipanion = __toESM(require_advanced());
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
@@ -22022,7 +12824,7 @@ function getTemporaryFolder(target = (0, import_os.tmpdir)()) {
       if (error.code === `EEXIST`) {
         continue;
       } else if (error.code === `EACCES`) {
-        throw new UsageError(`Failed to create cache directory. Please ensure the user has write access to the target directory (${target}). If the user's home directory does not exist, create it first.`);
+        throw new import_clipanion.UsageError(`Failed to create cache directory. Please ensure the user has write access to the target directory (${target}). If the user's home directory does not exist, create it first.`);
       } else {
         throw error;
       }
@@ -22032,11 +12834,13 @@ function getTemporaryFolder(target = (0, import_os.tmpdir)()) {
 
 // sources/httpUtils.ts
 var import_assert = __toESM(require("assert"));
+var import_clipanion3 = __toESM(require_advanced());
 var import_events = require("events");
 var import_process2 = require("process");
 var import_stream = require("stream");
 
 // sources/npmRegistryUtils.ts
+var import_clipanion2 = __toESM(require_advanced());
 var import_crypto = require("crypto");
 var DEFAULT_HEADERS = {
   [`Accept`]: `application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8`
@@ -22045,7 +12849,7 @@ var DEFAULT_NPM_REGISTRY_URL = `https://registry.npmjs.org`;
 async function fetchAsJson2(packageName, version2) {
   const npmRegistryUrl = process.env.COREPACK_NPM_REGISTRY || DEFAULT_NPM_REGISTRY_URL;
   if (process.env.COREPACK_ENABLE_NETWORK === `0`)
-    throw new UsageError(`Network access disabled by the environment; can't reach npm repository ${npmRegistryUrl}`);
+    throw new import_clipanion2.UsageError(`Network access disabled by the environment; can't reach npm repository ${npmRegistryUrl}`);
   const headers = { ...DEFAULT_HEADERS };
   if (`COREPACK_NPM_TOKEN` in process.env) {
     headers.authorization = `Bearer ${process.env.COREPACK_NPM_TOKEN}`;
@@ -22067,7 +12871,7 @@ function verifySignature({ signatures, integrity, packageName, version: version2
       break;
     }
   }
-  if (signature?.sig == null) throw new UsageError(`The package was not signed by any trusted keys: ${JSON.stringify({ signatures, trustedKeys }, void 0, 2)}`);
+  if (signature?.sig == null) throw new import_clipanion2.UsageError(`The package was not signed by any trusted keys: ${JSON.stringify({ signatures, trustedKeys }, void 0, 2)}`);
   const verifier = (0, import_crypto.createVerify)(`SHA256`);
   verifier.end(`${packageName}@${version2}:${integrity}`);
   const valid = verifier.verify(
@@ -22117,8 +12921,7 @@ async function fetchTarballURLAndSignature(packageName, version2) {
 // sources/httpUtils.ts
 async function fetch(input, init) {
   if (process.env.COREPACK_ENABLE_NETWORK === `0`)
-    throw new UsageError(`Network access disabled by the environment; can't reach ${input}`);
-  const agent = await getProxyAgent(input);
+    throw new import_clipanion3.UsageError(`Network access disabled by the environment; can't reach ${input}`);
   if (typeof input === `string`)
     input = new URL(input);
   let headers = init?.headers;
@@ -22142,7 +12945,6 @@ async function fetch(input, init) {
   try {
     response = await globalThis.fetch(input, {
       ...init,
-      dispatcher: agent,
       headers
     });
   } catch (error) {
@@ -22172,7 +12974,7 @@ async function fetchUrlStream(input, init) {
       const chars = await (0, import_events.once)(import_process2.stdin, `data`);
       import_process2.stdin.pause();
       if (chars[0][0] === 110 || chars[0][0] === 78)
-        throw new UsageError(`Aborted by the user`);
+        throw new import_clipanion3.UsageError(`Aborted by the user`);
       console.error();
     }
   }
@@ -22182,25 +12984,6 @@ async function fetchUrlStream(input, init) {
   const stream = import_stream.Readable.fromWeb(webStream);
   return stream;
 }
-var ProxyAgent;
-async function getProxyAgent(input) {
-  const { getProxyForUrl } = await Promise.resolve().then(() => __toESM(require_proxy_from_env()));
-  const proxy = getProxyForUrl(input);
-  if (!proxy) return void 0;
-  if (ProxyAgent == null) {
-    const [api, Dispatcher, _ProxyAgent] = await Promise.all([
-      // @ts-expect-error internal module is untyped
-      Promise.resolve().then(() => __toESM(require_api())),
-      // @ts-expect-error internal module is untyped
-      Promise.resolve().then(() => __toESM(require_dispatcher())),
-      // @ts-expect-error internal module is untyped
-      Promise.resolve().then(() => __toESM(require_proxy_agent()))
-    ]);
-    Object.assign(Dispatcher.default.prototype, api.default);
-    ProxyAgent = _ProxyAgent.default;
-  }
-  return new ProxyAgent(proxy);
-}
 
 // sources/nodeUtils.ts
 var import_os2 = __toESM(require("os"));
@@ -22611,6 +13394,7 @@ function satisfiesWithPrereleases(version2, range, loose = false) {
 }
 
 // sources/specUtils.ts
+var import_clipanion4 = __toESM(require_advanced());
 var import_fs5 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_satisfies = __toESM(require_satisfies());
@@ -22640,14 +13424,14 @@ function isSupportedPackageManager(value) {
 var nodeModulesRegExp = /[\\/]node_modules[\\/](@[^\\/]*[\\/])?([^@\\/][^\\/]*)$/;
 function parseSpec(raw2, source, { enforceExactVersion = true } = {}) {
   if (typeof raw2 !== `string`)
-    throw new UsageError(`Invalid package manager specification in ${source}; expected a string`);
+    throw new import_clipanion4.UsageError(`Invalid package manager specification in ${source}; expected a string`);
   const atIndex = raw2.indexOf(`@`);
   if (atIndex === -1 || atIndex === raw2.length - 1) {
     if (enforceExactVersion)
-      throw new UsageError(`No version specified for ${raw2} in "packageManager" of ${source}`);
+      throw new import_clipanion4.UsageError(`No version specified for ${raw2} in "packageManager" of ${source}`);
     const name3 = atIndex === -1 ? raw2 : raw2.slice(0, -1);
     if (!isSupportedPackageManager(name3))
-      throw new UsageError(`Unsupported package manager specification (${name3})`);
+      throw new import_clipanion4.UsageError(`Unsupported package manager specification (${name3})`);
     return {
       name: name3,
       range: `*`
@@ -22658,12 +13442,12 @@ function parseSpec(raw2, source, { enforceExactVersion = true } = {}) {
   const isURL = URL.canParse(range);
   if (!isURL) {
     if (enforceExactVersion && !(0, import_valid.default)(range))
-      throw new UsageError(`Invalid package manager specification in ${source} (${raw2}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`);
+      throw new import_clipanion4.UsageError(`Invalid package manager specification in ${source} (${raw2}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`);
     if (!isSupportedPackageManager(name2)) {
-      throw new UsageError(`Unsupported package manager specification (${raw2})`);
+      throw new import_clipanion4.UsageError(`Unsupported package manager specification (${raw2})`);
     }
   } else if (isSupportedPackageManager(name2) && process.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1`) {
-    throw new UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${raw2})`);
+    throw new import_clipanion4.UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${raw2})`);
   }
   return {
     name: name2,
@@ -22676,7 +13460,7 @@ function warnOrThrow(errorMessage, onFail) {
       break;
     case `error`:
     case void 0:
-      throw new UsageError(errorMessage);
+      throw new import_clipanion4.UsageError(errorMessage);
     default:
       console.warn(`! Corepack validation warning: ${errorMessage}`);
   }
@@ -22757,7 +13541,7 @@ async function loadSpec(initialCwd) {
     } catch {
     }
     if (typeof data !== `object` || data === null)
-      throw new UsageError(`Invalid package.json in ${import_path4.default.relative(initialCwd, manifestPath)}`);
+      throw new import_clipanion4.UsageError(`Invalid package.json in ${import_path4.default.relative(initialCwd, manifestPath)}`);
     let localEnv;
     const envFilePath2 = import_path4.default.resolve(currCwd, process.env.COREPACK_ENV_FILE ?? `.corepack.env`);
     if (process.env.COREPACK_ENV_FILE == `0`) {
@@ -22902,7 +13686,7 @@ var Engine = class {
     }
     const definition = this.config.definitions[locator.name];
     if (typeof definition === `undefined`)
-      throw new UsageError(`This package manager (${locator.name}) isn't supported by this corepack build`);
+      throw new import_clipanion5.UsageError(`This package manager (${locator.name}) isn't supported by this corepack build`);
     const ranges = Object.keys(definition.ranges).reverse();
     const range = ranges.find((range2) => satisfiesWithPrereleases(locator.reference, range2));
     if (typeof range === `undefined`)
@@ -22928,7 +13712,7 @@ var Engine = class {
   async getDefaultVersion(packageManager) {
     const definition = this.config.definitions[packageManager];
     if (typeof definition === `undefined`)
-      throw new UsageError(`This package manager (${packageManager}) isn't supported by this corepack build`);
+      throw new import_clipanion5.UsageError(`This package manager (${packageManager}) isn't supported by this corepack build`);
     const lastKnownGood = await getLastKnownGood();
     const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager);
     if (lastKnownGoodForThisPackageManager) {
@@ -23012,7 +13796,7 @@ var Engine = class {
           if (import_process3.default.env.COREPACK_ENABLE_AUTO_PIN === `1`) {
             const resolved = await this.resolveDescriptor(fallbackDescriptor, { allowTags: true });
             if (resolved === null)
-              throw new UsageError(`Failed to successfully resolve '${fallbackDescriptor.range}' to a valid ${fallbackDescriptor.name} release`);
+              throw new import_clipanion5.UsageError(`Failed to successfully resolve '${fallbackDescriptor.range}' to a valid ${fallbackDescriptor.name} release`);
             const installSpec = await this.ensurePackageManager(resolved);
             console.error(`! The local project doesn't define a 'packageManager' field. Corepack will now add one referencing ${installSpec.locator.name}@${installSpec.locator.reference}.`);
             console.error(`! For more details about this field, consult the documentation at https://nodejs.org/api/packages.html#packagemanager`);
@@ -23031,7 +13815,7 @@ var Engine = class {
               log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} in a ${spec.name}@${spec.range} project`);
               return fallbackDescriptor;
             } else {
-              throw new UsageError(`This project is configured to use ${spec.name} because ${result.target} has a "packageManager" field`);
+              throw new import_clipanion5.UsageError(`This project is configured to use ${spec.name} because ${result.target} has a "packageManager" field`);
             }
           } else {
             log(`Using ${spec.name}@${spec.range} as defined in project manifest ${result.target}`);
@@ -23067,14 +13851,14 @@ var Engine = class {
       descriptor.range = binaryVersion;
     const resolved = await this.resolveDescriptor(descriptor, { allowTags: true });
     if (resolved === null)
-      throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+      throw new import_clipanion5.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
     const installSpec = await this.ensurePackageManager(resolved);
     return await runVersion(resolved, installSpec, binaryName, args);
   }
   async resolveDescriptor(descriptor, { allowTags = false, useCache = true } = {}) {
     if (!isSupportedPackageManagerDescriptor(descriptor)) {
       if (import_process3.default.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1` && isSupportedPackageManager(descriptor.name))
-        throw new UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${descriptor.name}@${descriptor.range})`);
+        throw new import_clipanion5.UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${descriptor.name}@${descriptor.range})`);
       return {
         name: descriptor.name,
         reference: descriptor.range
@@ -23082,18 +13866,18 @@ var Engine = class {
     }
     const definition = this.config.definitions[descriptor.name];
     if (typeof definition === `undefined`)
-      throw new UsageError(`This package manager (${descriptor.name}) isn't supported by this corepack build`);
+      throw new import_clipanion5.UsageError(`This package manager (${descriptor.name}) isn't supported by this corepack build`);
     let finalDescriptor = descriptor;
     if (!(0, import_valid3.default)(descriptor.range) && !(0, import_valid4.default)(descriptor.range)) {
       if (!allowTags)
-        throw new UsageError(`Packages managers can't be referenced via tags in this context`);
+        throw new import_clipanion5.UsageError(`Packages managers can't be referenced via tags in this context`);
       const ranges = Object.keys(definition.ranges);
       const tagRange = ranges[ranges.length - 1];
       const packageManagerSpec = definition.ranges[tagRange];
       const registry = getRegistryFromPackageManagerSpec(packageManagerSpec);
       const tags = await fetchAvailableTags2(registry);
       if (!Object.hasOwn(tags, descriptor.range))
-        throw new UsageError(`Tag not found (${descriptor.range})`);
+        throw new import_clipanion5.UsageError(`Tag not found (${descriptor.range})`);
       finalDescriptor = {
         name: descriptor.name,
         range: tags[descriptor.range]
@@ -23118,13 +13902,14 @@ var Engine = class {
 };
 
 // sources/commands/Cache.ts
+var import_clipanion6 = __toESM(require_advanced());
 var import_fs7 = __toESM(require("fs"));
-var CacheCommand = class extends Command {
+var CacheCommand = class extends import_clipanion6.Command {
   static paths = [
     [`cache`, `clean`],
     [`cache`, `clear`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion6.Command.Usage({
     description: `Cleans Corepack cache`,
     details: `
       Removes Corepack cache directory from your local disk.
@@ -23136,14 +13921,15 @@ var CacheCommand = class extends Command {
 };
 
 // sources/commands/Disable.ts
+var import_clipanion7 = __toESM(require_advanced());
 var import_fs8 = __toESM(require("fs"));
 var import_path6 = __toESM(require("path"));
 var import_which = __toESM(require_lib());
-var DisableCommand = class extends Command {
+var DisableCommand = class extends import_clipanion7.Command {
   static paths = [
     [`disable`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion7.Command.Usage({
     description: `Remove the Corepack shims from the install directory`,
     details: `
       When run, this command will remove the shims for the specified package managers from the install directory, or all shims if no parameters are passed.
@@ -23161,10 +13947,10 @@ var DisableCommand = class extends Command {
       `$0 disable yarn`
     ]]
   });
-  installDirectory = options_exports.String(`--install-directory`, {
+  installDirectory = import_clipanion7.Option.String(`--install-directory`, {
     description: `Where the shims are located`
   });
-  names = options_exports.Rest();
+  names = import_clipanion7.Option.Rest();
   async execute() {
     let installDirectory = this.installDirectory;
     if (typeof installDirectory === `undefined`)
@@ -23173,7 +13959,7 @@ var DisableCommand = class extends Command {
     const allBinNames = [];
     for (const name2 of new Set(names)) {
       if (!isSupportedPackageManager(name2))
-        throw new UsageError(`Invalid package manager name '${name2}'`);
+        throw new import_clipanion7.UsageError(`Invalid package manager name '${name2}'`);
       const binNames = this.context.engine.getBinariesFor(name2);
       allBinNames.push(...binNames);
     }
@@ -23210,14 +13996,15 @@ var DisableCommand = class extends Command {
 
 // sources/commands/Enable.ts
 var import_cmd_shim = __toESM(require_cmd_shim());
+var import_clipanion8 = __toESM(require_advanced());
 var import_fs9 = __toESM(require("fs"));
 var import_path7 = __toESM(require("path"));
 var import_which2 = __toESM(require_lib());
-var EnableCommand = class extends Command {
+var EnableCommand = class extends import_clipanion8.Command {
   static paths = [
     [`enable`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion8.Command.Usage({
     description: `Add the Corepack shims to the install directory`,
     details: `
       When run, this command will check whether the shims for the specified package managers can be found with the correct values inside the install directory. If not, or if they don't exist, they will be created.
@@ -23235,10 +14022,10 @@ var EnableCommand = class extends Command {
       `$0 enable yarn`
     ]]
   });
-  installDirectory = options_exports.String(`--install-directory`, {
+  installDirectory = import_clipanion8.Option.String(`--install-directory`, {
     description: `Where the shims are to be installed`
   });
-  names = options_exports.Rest();
+  names = import_clipanion8.Option.Rest();
   async execute() {
     let installDirectory = this.installDirectory;
     if (typeof installDirectory === `undefined`)
@@ -23252,7 +14039,7 @@ var EnableCommand = class extends Command {
     const allBinNames = [];
     for (const name2 of new Set(names)) {
       if (!isSupportedPackageManager(name2))
-        throw new UsageError(`Invalid package manager name '${name2}'`);
+        throw new import_clipanion8.UsageError(`Invalid package manager name '${name2}'`);
       const binNames = this.context.engine.getBinariesFor(name2);
       allBinNames.push(...binNames);
     }
@@ -23287,20 +14074,22 @@ var EnableCommand = class extends Command {
 };
 
 // sources/commands/InstallGlobal.ts
+var import_clipanion10 = __toESM(require_advanced());
 var import_fs10 = __toESM(require("fs"));
 var import_path8 = __toESM(require("path"));
 
 // sources/commands/Base.ts
-var BaseCommand = class extends Command {
+var import_clipanion9 = __toESM(require_advanced());
+var BaseCommand = class extends import_clipanion9.Command {
   async resolvePatternsToDescriptors({ patterns }) {
     const resolvedSpecs = patterns.map((pattern) => parseSpec(pattern, `CLI arguments`, { enforceExactVersion: false }));
     if (resolvedSpecs.length === 0) {
       const lookup = await loadSpec(this.context.cwd);
       switch (lookup.type) {
         case `NoProject`:
-          throw new UsageError(`Couldn't find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
+          throw new import_clipanion9.UsageError(`Couldn't find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
         case `NoSpec`:
-          throw new UsageError(`The local project doesn't feature a 'packageManager' field nor a 'devEngines.packageManager' field - please specify the package manager to pack, or update the manifest to reference it`);
+          throw new import_clipanion9.UsageError(`The local project doesn't feature a 'packageManager' field nor a 'devEngines.packageManager' field - please specify the package manager to pack, or update the manifest to reference it`);
         default: {
           return [lookup.range ?? lookup.getSpec()];
         }
@@ -23328,7 +14117,7 @@ var InstallGlobalCommand = class extends BaseCommand {
   static paths = [
     [`install`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion10.Command.Usage({
     description: `Install package managers on the system`,
     details: `
       Download the selected package managers and install them on the system.
@@ -23343,16 +14132,16 @@ var InstallGlobalCommand = class extends BaseCommand {
       `corepack install -g pnpm`
     ]]
   });
-  global = options_exports.Boolean(`-g,--global`, {
+  global = import_clipanion10.Option.Boolean(`-g,--global`, {
     required: true
   });
-  cacheOnly = options_exports.Boolean(`--cache-only`, false, {
+  cacheOnly = import_clipanion10.Option.Boolean(`--cache-only`, false, {
     description: `If true, the package managers will only be cached, not set as new defaults`
   });
-  args = options_exports.Rest();
+  args = import_clipanion10.Option.Rest();
   async execute() {
     if (this.args.length === 0)
-      throw new UsageError(`No package managers specified`);
+      throw new import_clipanion10.UsageError(`No package managers specified`);
     await Promise.all(this.args.map((arg) => {
       if (arg.endsWith(`.tgz`)) {
         return this.installFromTarball(import_path8.default.resolve(this.context.cwd, arg));
@@ -23373,7 +14162,7 @@ var InstallGlobalCommand = class extends BaseCommand {
   async installFromDescriptor(descriptor) {
     const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
     if (resolved === null)
-      throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+      throw new import_clipanion10.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
     this.log(resolved);
     await this.context.engine.ensurePackageManager(resolved);
     if (!this.cacheOnly) {
@@ -23399,12 +14188,12 @@ var InstallGlobalCommand = class extends BaseCommand {
       }
     } });
     if (hasShortEntries || archiveEntries.size < 1)
-      throw new UsageError(`Invalid archive format; did it get generated by 'corepack pack'?`);
+      throw new import_clipanion10.UsageError(`Invalid archive format; did it get generated by 'corepack pack'?`);
     const { extract: tarX } = await Promise.resolve().then(() => (init_extract(), extract_exports));
     for (const [name2, references] of archiveEntries) {
       for (const reference of references) {
         if (!isSupportedPackageManager(name2))
-          throw new UsageError(`Unsupported package manager '${name2}'`);
+          throw new import_clipanion10.UsageError(`Unsupported package manager '${name2}'`);
         this.log({ name: name2, reference });
         await import_fs10.default.promises.mkdir(installFolder, { recursive: true });
         await tarX({ file: p, cwd: installFolder }, [`${name2}/${reference}`]);
@@ -23417,11 +14206,12 @@ var InstallGlobalCommand = class extends BaseCommand {
 };
 
 // sources/commands/InstallLocal.ts
+var import_clipanion11 = __toESM(require_advanced());
 var InstallLocalCommand = class extends BaseCommand {
   static paths = [
     [`install`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion11.Command.Usage({
     description: `Install the package manager configured in the local project`,
     details: `
       Download and install the package manager configured in the local project. This command doesn't change the global version used when running the package manager from outside the project (use the \`-g,--global\` flag if you wish to do this).
@@ -23437,7 +14227,7 @@ var InstallLocalCommand = class extends BaseCommand {
     });
     const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true });
     if (resolved === null)
-      throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+      throw new import_clipanion11.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
     this.context.stdout.write(`Adding ${resolved.name}@${resolved.reference} to the cache...
 `);
     await this.context.engine.ensurePackageManager(resolved);
@@ -23445,13 +14235,14 @@ var InstallLocalCommand = class extends BaseCommand {
 };
 
 // sources/commands/Pack.ts
+var import_clipanion12 = __toESM(require_advanced());
 var import_promises3 = require("fs/promises");
 var import_path11 = __toESM(require("path"));
 var PackCommand = class extends BaseCommand {
   static paths = [
     [`pack`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion12.Command.Usage({
     description: `Store package managers in a tarball`,
     details: `
       Download the selected package managers and store them inside a tarball suitable for use with \`corepack install -g\`.
@@ -23464,13 +14255,13 @@ var PackCommand = class extends BaseCommand {
       `corepack pack yarn@^1`
     ]]
   });
-  json = options_exports.Boolean(`--json`, false, {
+  json = import_clipanion12.Option.Boolean(`--json`, false, {
     description: `If true, the path to the generated tarball will be printed on stdout`
   });
-  output = options_exports.String(`-o,--output`, {
+  output = import_clipanion12.Option.String(`-o,--output`, {
     description: `Where the tarball should be generated; by default "corepack.tgz"`
   });
-  patterns = options_exports.Rest();
+  patterns = import_clipanion12.Option.Rest();
   async execute() {
     const descriptors = await this.resolvePatternsToDescriptors({
       patterns: this.patterns
@@ -23479,7 +14270,7 @@ var PackCommand = class extends BaseCommand {
     for (const descriptor of descriptors) {
       const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
       if (resolved === null)
-        throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+        throw new import_clipanion12.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
       this.context.stdout.write(`Adding ${resolved.name}@${resolved.reference} to the cache...
 `);
       const packageManagerInfo = await this.context.engine.ensurePackageManager(resolved);
@@ -23510,6 +14301,7 @@ var PackCommand = class extends BaseCommand {
 };
 
 // sources/commands/Up.ts
+var import_clipanion13 = __toESM(require_advanced());
 var import_major = __toESM(require_major());
 var import_valid5 = __toESM(require_valid());
 var import_valid6 = __toESM(require_valid2());
@@ -23517,7 +14309,7 @@ var UpCommand = class extends BaseCommand {
   static paths = [
     [`up`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion13.Command.Usage({
     description: `Update the package manager used in the current project`,
     details: `
       Retrieve the latest available version for the current major release line
@@ -23539,15 +14331,15 @@ var UpCommand = class extends BaseCommand {
       patterns: []
     });
     if (!(0, import_valid5.default)(descriptor.range) && !(0, import_valid6.default)(descriptor.range))
-      throw new UsageError(`The 'corepack up' command can only be used when your project's packageManager field is set to a semver version or semver range`);
+      throw new import_clipanion13.UsageError(`The 'corepack up' command can only be used when your project's packageManager field is set to a semver version or semver range`);
     const resolved = await this.context.engine.resolveDescriptor(descriptor, { useCache: false });
     if (!resolved)
-      throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+      throw new import_clipanion13.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
     const majorVersion = (0, import_major.default)(resolved.reference);
     const majorDescriptor = { name: descriptor.name, range: `^${majorVersion}.0.0` };
     const highestVersion = await this.context.engine.resolveDescriptor(majorDescriptor, { useCache: false });
     if (!highestVersion)
-      throw new UsageError(`Failed to find the highest release for ${descriptor.name} ${majorVersion}.x`);
+      throw new import_clipanion13.UsageError(`Failed to find the highest release for ${descriptor.name} ${majorVersion}.x`);
     this.context.stdout.write(`Installing ${highestVersion.name}@${highestVersion.reference} in the project...
 `);
     const packageManagerInfo = await this.context.engine.ensurePackageManager(highestVersion);
@@ -23556,11 +14348,12 @@ var UpCommand = class extends BaseCommand {
 };
 
 // sources/commands/Use.ts
+var import_clipanion14 = __toESM(require_advanced());
 var UseCommand = class extends BaseCommand {
   static paths = [
     [`use`]
   ];
-  static usage = Command.Usage({
+  static usage = import_clipanion14.Command.Usage({
     description: `Define the package manager to use for the current project`,
     details: `
       When run, this command will retrieve the latest release matching the
@@ -23572,14 +14365,14 @@ var UseCommand = class extends BaseCommand {
       `corepack use yarn`
     ]]
   });
-  pattern = options_exports.String();
+  pattern = import_clipanion14.Option.String();
   async execute() {
     const [descriptor] = await this.resolvePatternsToDescriptors({
       patterns: [this.pattern]
     });
     const resolved = await this.context.engine.resolveDescriptor(descriptor, { allowTags: true, useCache: false });
     if (resolved === null)
-      throw new UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
+      throw new import_clipanion14.UsageError(`Failed to successfully resolve '${descriptor.range}' to a valid ${descriptor.name} release`);
     this.context.stdout.write(`Installing ${resolved.name}@${resolved.reference} in the project...
 `);
     const packageManagerInfo = await this.context.engine.ensurePackageManager(resolved);
@@ -23588,16 +14381,17 @@ var UseCommand = class extends BaseCommand {
 };
 
 // sources/commands/deprecated/Hydrate.ts
+var import_clipanion15 = __toESM(require_advanced());
 var import_promises4 = require("fs/promises");
 var import_path12 = __toESM(require("path"));
-var HydrateCommand = class extends Command {
+var HydrateCommand = class extends import_clipanion15.Command {
   static paths = [
     [`hydrate`]
   ];
-  activate = options_exports.Boolean(`--activate`, false, {
+  activate = import_clipanion15.Option.Boolean(`--activate`, false, {
     description: `If true, this release will become the default one for this package manager`
   });
-  fileName = options_exports.String();
+  fileName = import_clipanion15.Option.String();
   async execute() {
     const installFolder = getInstallFolder();
     const fileName = import_path12.default.resolve(this.context.cwd, this.fileName);
@@ -23616,12 +14410,12 @@ var HydrateCommand = class extends Command {
       }
     } });
     if (hasShortEntries || archiveEntries.size < 1)
-      throw new UsageError(`Invalid archive format; did it get generated by 'corepack prepare'?`);
+      throw new import_clipanion15.UsageError(`Invalid archive format; did it get generated by 'corepack prepare'?`);
     const { extract: tarX } = await Promise.resolve().then(() => (init_extract(), extract_exports));
     for (const [name2, references] of archiveEntries) {
       for (const reference of references) {
         if (!isSupportedPackageManager(name2))
-          throw new UsageError(`Unsupported package manager '${name2}'`);
+          throw new import_clipanion15.UsageError(`Unsupported package manager '${name2}'`);
         if (this.activate)
           this.context.stdout.write(`Hydrating ${name2}@${reference} for immediate activation...
 `);
@@ -23641,23 +14435,24 @@ var HydrateCommand = class extends Command {
 };
 
 // sources/commands/deprecated/Prepare.ts
+var import_clipanion16 = __toESM(require_advanced());
 var import_promises5 = require("fs/promises");
 var import_path13 = __toESM(require("path"));
-var PrepareCommand = class extends Command {
+var PrepareCommand = class extends import_clipanion16.Command {
   static paths = [
     [`prepare`]
   ];
-  activate = options_exports.Boolean(`--activate`, false, {
+  activate = import_clipanion16.Option.Boolean(`--activate`, false, {
     description: `If true, this release will become the default one for this package manager`
   });
-  json = options_exports.Boolean(`--json`, false, {
+  json = import_clipanion16.Option.Boolean(`--json`, false, {
     description: `If true, the output will be the path of the generated tarball`
   });
-  output = options_exports.String(`-o,--output`, {
+  output = import_clipanion16.Option.String(`-o,--output`, {
     description: `If true, the installed package managers will also be stored in a tarball`,
     tolerateBoolean: true
   });
-  specs = options_exports.Rest();
+  specs = import_clipanion16.Option.Rest();
   async execute() {
     const specs = this.specs;
     const installLocations = [];
@@ -23665,9 +14460,9 @@ var PrepareCommand = class extends Command {
       const lookup = await loadSpec(this.context.cwd);
       switch (lookup.type) {
         case `NoProject`:
-          throw new UsageError(`Couldn't find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
+          throw new import_clipanion16.UsageError(`Couldn't find a project in the local directory - please specify the package manager to pack, or run this command from a valid project`);
         case `NoSpec`:
-          throw new UsageError(`The local project doesn't feature a 'packageManager' field - please specify the package manager to pack, or update the manifest to reference it`);
+          throw new import_clipanion16.UsageError(`The local project doesn't feature a 'packageManager' field - please specify the package manager to pack, or update the manifest to reference it`);
         default: {
           specs.push(lookup.getSpec());
         }
@@ -23677,7 +14472,7 @@ var PrepareCommand = class extends Command {
       const spec = typeof request === `string` ? parseSpec(request, `CLI arguments`, { enforceExactVersion: false }) : request;
       const resolved = await this.context.engine.resolveDescriptor(spec, { allowTags: true });
       if (resolved === null)
-        throw new UsageError(`Failed to successfully resolve '${spec.range}' to a valid ${spec.name} release`);
+        throw new import_clipanion16.UsageError(`Failed to successfully resolve '${spec.range}' to a valid ${spec.name} release`);
       if (!this.json) {
         if (this.activate) {
           this.context.stdout.write(`Preparing ${spec.name}@${spec.range} for immediate activation...
@@ -23740,13 +14535,13 @@ async function runMain(argv) {
   const [firstArg, ...restArgs] = argv;
   const request = getPackageManagerRequestFromCli(firstArg, engine);
   if (!request) {
-    const cli = new Cli({
+    const cli = new import_clipanion17.Cli({
       binaryLabel: `Corepack`,
       binaryName: `corepack`,
       binaryVersion: version
     });
-    cli.register(builtins_exports.HelpCommand);
-    cli.register(builtins_exports.VersionCommand);
+    cli.register(import_clipanion17.Builtins.HelpCommand);
+    cli.register(import_clipanion17.Builtins.VersionCommand);
     cli.register(CacheCommand);
     cli.register(DisableCommand);
     cli.register(EnableCommand);
@@ -23758,7 +14553,7 @@ async function runMain(argv) {
     cli.register(HydrateCommand);
     cli.register(PrepareCommand);
     const context = {
-      ...Cli.defaultContext,
+      ...import_clipanion17.Cli.defaultContext,
       cwd: process.cwd(),
       engine
     };
@@ -23787,9 +14582,6 @@ async function runMain(argv) {
 });
 /*! Bundled license information:
 
-undici/lib/web/fetch/body.js:
-  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
-
 is-windows/index.js:
   (*!
    * is-windows <https://github.com/jonschlinkert/is-windows>
diff --git a/deps/corepack/package.json b/deps/corepack/package.json
index d800198cb7df0f..279475fb9cec6e 100644
--- a/deps/corepack/package.json
+++ b/deps/corepack/package.json
@@ -1,6 +1,6 @@
 {
   "name": "corepack",
-  "version": "0.34.7",
+  "version": "0.35.0",
   "homepage": "https://github.com/nodejs/corepack#readme",
   "bugs": {
     "url": "https://github.com/nodejs/corepack/issues"
@@ -10,44 +10,43 @@
     "url": "https://github.com/nodejs/corepack.git"
   },
   "engines": {
-    "node": "^20.10.0 || ^22.11.0 || >=24.0.0"
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
   },
   "exports": {
     "./package.json": "./package.json"
   },
   "license": "MIT",
-  "packageManager": "yarn@4.11.0+sha224.209a3e277c6bbc03df6e4206fbfcb0c1621c27ecf0688f79a0c619f0",
+  "packageManager": "yarn@4.14.1+sha224.88b7a7244bbd9040380c417f7eb556d85c67640b651f113cb4c72113",
   "devDependencies": {
     "@types/debug": "^4.1.5",
-    "@types/node": "^20.4.6",
+    "@types/node": "^22.0.0",
     "@types/proxy-from-env": "^1",
     "@types/semver": "^7.1.0",
     "@types/which": "^3.0.0",
     "@yarnpkg/eslint-config": "^3.0.0",
     "@yarnpkg/fslib": "^3.0.0-rc.48",
     "@zkochan/cmd-shim": "^6.0.0",
-    "better-sqlite3": "^11.7.2",
     "clipanion": "patch:clipanion@npm%3A3.2.1#~/.yarn/patches/clipanion-npm-3.2.1-fc9187f56c.patch",
     "debug": "^4.1.1",
-    "esbuild": "^0.27.0",
+    "esbuild": "^0.28.0",
     "eslint": "^9.22.0",
-    "proxy-from-env": "^1.1.0",
     "semver": "^7.6.3",
     "supports-color": "^10.0.0",
     "tar": "^7.5.11",
     "tsx": "^4.16.2",
     "typescript": "^5.7.3",
-    "undici": "^6.24.0",
     "v8-compile-cache": "^2.3.0",
-    "vitest": "^3.0.5",
-    "which": "^5.0.0"
+    "vitest": "^4.0.5",
+    "which": "^7.0.0"
   },
-  "resolutions": {
-    "undici-types": "6.x"
+  "dependenciesMeta": {
+    "esbuild": {
+      "built": true
+    }
   },
   "scripts": {
     "build": "run clean && run build:bundle && tsx ./mkshims.ts",
-    "build:bundle": "esbuild ./sources/_lib.ts --bundle --platform=node --target=node18.17.0 --external:corepack --outfile='./dist/lib/corepack.cjs' --resolve-extensions='.ts,.mjs,.js'",
+    "build:bundle": "esbuild ./sources/_lib.ts --bundle --platform=node --target=node22.22.2 --external:corepack --outfile='./dist/lib/corepack.cjs' --resolve-extensions='.ts,.mjs,.js'",
     "clean": "run rimraf dist shims",
     "corepack": "tsx ./sources/_cli.ts",
     "lint": "eslint .",

From 2ebf53330ddeddc7e49557de8cddc5e7d8180a30 Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Mon, 18 May 2026 21:16:42 -0400
Subject: [PATCH 10/83] tools: update nixpkgs-unstable to
 d233902339c02a9c334e7e593de68855ad2

PR-URL: https://github.com/nodejs/node/pull/63376
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 tools/nix/pkgs.nix | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/nix/pkgs.nix b/tools/nix/pkgs.nix
index f270ea4f608c7c..66f809d8b23382 100644
--- a/tools/nix/pkgs.nix
+++ b/tools/nix/pkgs.nix
@@ -1,10 +1,10 @@
 arg:
 let
   repo = "https://github.com/NixOS/nixpkgs";
-  rev = "b3da656039dc7a6240f27b2ef8cc6a3ef3bccae7";
+  rev = "d233902339c02a9c334e7e593de68855ad26c4cb";
   nixpkgs = import (builtins.fetchTarball {
     url = "${repo}/archive/${rev}.tar.gz";
-    sha256 = "1hyl221q0c2zw3m1nv8vc39dcyrvxmn4crbn13f8p2pmcmg6x2i3";
+    sha256 = "1485vqhb8cwym1m75v61i10j427vazszaklkwj2wmm80k8sijjyz";
   }) arg;
 in
 nixpkgs

From 783b3824831053fb020c17d456505ed76dfaef87 Mon Sep 17 00:00:00 2001
From: ikeyan <kik@nvstl.com>
Date: Tue, 19 May 2026 22:38:22 +0900
Subject: [PATCH 11/83] stream: align `Readable.toWeb` termination with eos

PR-URL: https://github.com/nodejs/node/pull/62394
Reviewed-By: Mattias Buelens <mattias@buelens.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/streams/end-of-stream.js         | 234 +++++++++++-------
 lib/internal/webstreams/adapters.js           | 137 +++++-----
 test/parallel/test-stream-finished.js         |  41 ++-
 ...test-stream-readable-to-web-termination.js |  36 ++-
 ...g-webstreams-adapters-to-readablestream.js | 141 ++++++++++-
 5 files changed, 421 insertions(+), 168 deletions(-)

diff --git a/lib/internal/streams/end-of-stream.js b/lib/internal/streams/end-of-stream.js
index e995755079f8c1..f310cd6936fbe7 100644
--- a/lib/internal/streams/end-of-stream.js
+++ b/lib/internal/streams/end-of-stream.js
@@ -7,6 +7,7 @@ const {
   Promise,
   PromisePrototypeThen,
   ReflectApply,
+  Symbol,
   SymbolDispose,
 } = primordials;
 
@@ -66,6 +67,50 @@ function bindAsyncResource(fn, type) {
   };
 }
 
+/**
+ * Returns the current stream error tracked by eos(), if any.
+ * @param {import('stream').Stream} stream
+ * @returns {Error | null}
+ */
+function getEosErrored(stream) {
+  const errored = isWritableErrored(stream) || isReadableErrored(stream);
+  return typeof errored !== 'boolean' && errored || null;
+}
+
+/**
+ * Returns the error eos() would report from an immediate close, including
+ * premature close detection for unfinished readable or writable sides.
+ * @param {import('stream').Stream} stream
+ * @param {boolean} readable
+ * @param {boolean | null} readableFinished
+ * @param {boolean} writable
+ * @param {boolean | null} writableFinished
+ * @returns {Error | null}
+ */
+function getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished) {
+  const errored = getEosErrored(stream);
+  if (errored) {
+    return errored;
+  }
+
+  if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
+    if (!isReadableFinished(stream, false)) {
+      return new ERR_STREAM_PREMATURE_CLOSE();
+    }
+  }
+  if (writable && !writableFinished) {
+    if (!isWritableFinished(stream, false)) {
+      return new ERR_STREAM_PREMATURE_CLOSE();
+    }
+  }
+
+  return null;
+}
+
+// Internal only: if eos() can settle immediately, invoke the callback before
+// returning cleanup. Callers must tolerate cleanup yet to be assigned.
+const kEosNodeSynchronousCallback = Symbol('kEosNodeSynchronousCallback');
+
 function eos(stream, options, callback) {
   if (arguments.length === 2) {
     callback = options;
@@ -78,14 +123,6 @@ function eos(stream, options, callback) {
   validateFunction(callback, 'callback');
   validateAbortSignal(options.signal, 'options.signal');
 
-  if (AsyncContextFrame.current() || enabledHooksExist()) {
-    // Avoid AsyncResource.bind() because it calls ObjectDefineProperties which
-    // is a bottleneck here.
-    callback = once(bindAsyncResource(callback, 'STREAM_END_OF_STREAM'));
-  } else {
-    callback = once(callback);
-  }
-
   if (isReadableStream(stream) || isWritableStream(stream)) {
     return eosWeb(stream, options, callback);
   }
@@ -97,15 +134,6 @@ function eos(stream, options, callback) {
   const readable = options.readable ?? isReadableNodeStream(stream);
   const writable = options.writable ?? isWritableNodeStream(stream);
 
-  const wState = stream._writableState;
-  const rState = stream._readableState;
-
-  const onlegacyfinish = () => {
-    if (!stream.writable) {
-      onfinish();
-    }
-  };
-
   // TODO (ronag): Improve soft detection to include core modules and
   // common ecosystem modules that do properly emit 'close' but fail
   // this generic check.
@@ -114,8 +142,85 @@ function eos(stream, options, callback) {
     isReadableNodeStream(stream) === readable &&
     isWritableNodeStream(stream) === writable
   );
-
   let writableFinished = isWritableFinished(stream, false);
+  let readableFinished = isReadableFinished(stream, false);
+
+  const wState = stream._writableState;
+  const rState = stream._readableState;
+
+  /**
+   * @type {Error | null | undefined}
+   * undefined: to be determined
+   * null: no error
+   * Error: an error occurred
+   */
+  let immediateResult;
+  if (isClosed(stream)) {
+    immediateResult = getEosOnCloseError(
+      stream,
+      readable,
+      readableFinished,
+      writable,
+      writableFinished,
+    );
+  } else if (wState?.errorEmitted || rState?.errorEmitted) {
+    if (!willEmitClose) {
+      immediateResult = getEosErrored(stream);
+    }
+  } else if (
+    !readable &&
+    (!willEmitClose || isReadable(stream)) &&
+    (writableFinished || isWritable(stream) === false) &&
+    (wState == null || wState.pendingcb === undefined || wState.pendingcb === 0)
+  ) {
+    immediateResult = getEosErrored(stream);
+  } else if (
+    !writable &&
+    (!willEmitClose || isWritable(stream)) &&
+    (readableFinished || isReadable(stream) === false)
+  ) {
+    immediateResult = getEosErrored(stream);
+  } else if ((rState && stream.req && stream.aborted)) {
+    immediateResult = getEosErrored(stream);
+  }
+  let cleanup = () => {
+    callback = nop;
+  };
+  if (immediateResult !== undefined) {
+    if (options.error !== false) {
+      stream.on('error', nop);
+      cleanup = () => {
+        callback = nop;
+        stream.removeListener('error', nop);
+      };
+    }
+  } else if (options.signal?.aborted) {
+    immediateResult = new AbortError(undefined, { cause: options.signal.reason });
+  }
+  if (immediateResult !== undefined && options[kEosNodeSynchronousCallback]) {
+    ReflectApply(callback, stream, immediateResult === null ? [] : [immediateResult]);
+    return cleanup;
+  }
+
+  if (AsyncContextFrame.current() || enabledHooksExist()) {
+    // Avoid AsyncResource.bind() because it calls ObjectDefineProperties which
+    // is a bottleneck here.
+    callback = bindAsyncResource(callback, 'STREAM_END_OF_STREAM');
+  }
+
+  if (immediateResult !== undefined) {
+    process.nextTick(() => ReflectApply(callback, stream, immediateResult === null ? [] : [immediateResult]));
+    return cleanup;
+  }
+
+  callback = once(callback);
+
+  const onlegacyfinish = () => {
+    if (!stream.writable) {
+      onfinish();
+    }
+  };
+
   const onfinish = () => {
     writableFinished = true;
     // Stream should not be destroyed here. If it is that
@@ -134,7 +239,6 @@ function eos(stream, options, callback) {
     }
   };
 
-  let readableFinished = isReadableFinished(stream, false);
   const onend = () => {
     readableFinished = true;
     // Stream should not be destroyed here. If it is that
@@ -157,41 +261,13 @@ function eos(stream, options, callback) {
     callback.call(stream, err);
   };
 
-  let closed = isClosed(stream);
-
   const onclose = () => {
-    closed = true;
-
-    const errored = isWritableErrored(stream) || isReadableErrored(stream);
-
-    if (errored && typeof errored !== 'boolean') {
-      return callback.call(stream, errored);
-    }
-
-    if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
-      if (!isReadableFinished(stream, false))
-        return callback.call(stream,
-                             new ERR_STREAM_PREMATURE_CLOSE());
-    }
-    if (writable && !writableFinished) {
-      if (!isWritableFinished(stream, false))
-        return callback.call(stream,
-                             new ERR_STREAM_PREMATURE_CLOSE());
-    }
-
-    callback.call(stream);
-  };
-
-  const onclosed = () => {
-    closed = true;
-
-    const errored = isWritableErrored(stream) || isReadableErrored(stream);
-
-    if (errored && typeof errored !== 'boolean') {
-      return callback.call(stream, errored);
+    const error = getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished);
+    if (error === null) {
+      callback.call(stream);
+    } else {
+      callback.call(stream, error);
     }
-
-    callback.call(stream);
   };
 
   const onrequest = () => {
@@ -225,30 +301,7 @@ function eos(stream, options, callback) {
   }
   stream.on('close', onclose);
 
-  if (closed) {
-    process.nextTick(onclose);
-  } else if (wState?.errorEmitted || rState?.errorEmitted) {
-    if (!willEmitClose) {
-      process.nextTick(onclosed);
-    }
-  } else if (
-    !readable &&
-    (!willEmitClose || isReadable(stream)) &&
-    (writableFinished || isWritable(stream) === false) &&
-    (wState == null || wState.pendingcb === undefined || wState.pendingcb === 0)
-  ) {
-    process.nextTick(onclosed);
-  } else if (
-    !writable &&
-    (!willEmitClose || isWritable(stream)) &&
-    (readableFinished || isReadable(stream) === false)
-  ) {
-    process.nextTick(onclosed);
-  } else if ((rState && stream.req && stream.aborted)) {
-    process.nextTick(onclosed);
-  }
-
-  const cleanup = () => {
+  cleanup = () => {
     callback = nop;
     stream.removeListener('aborted', onclose);
     stream.removeListener('complete', onfinish);
@@ -263,7 +316,7 @@ function eos(stream, options, callback) {
     stream.removeListener('close', onclose);
   };
 
-  if (options.signal && !closed) {
+  if (options.signal) {
     const abort = () => {
       // Keep it because cleanup removes it.
       const endCallback = callback;
@@ -272,23 +325,27 @@ function eos(stream, options, callback) {
         stream,
         new AbortError(undefined, { cause: options.signal.reason }));
     };
-    if (options.signal.aborted) {
-      process.nextTick(abort);
-    } else {
-      addAbortListener ??= require('internal/events/abort_listener').addAbortListener;
-      const disposable = addAbortListener(options.signal, abort);
-      const originalCallback = callback;
-      callback = once((...args) => {
-        disposable[SymbolDispose]();
-        ReflectApply(originalCallback, stream, args);
-      });
-    }
+    addAbortListener ??= require('internal/events/abort_listener').addAbortListener;
+    const disposable = addAbortListener(options.signal, abort);
+    const originalCallback = callback;
+    callback = once((...args) => {
+      disposable[SymbolDispose]();
+      ReflectApply(originalCallback, stream, args);
+    });
   }
 
   return cleanup;
 }
 
 function eosWeb(stream, options, callback) {
+  if (AsyncContextFrame.current() || enabledHooksExist()) {
+    // Avoid AsyncResource.bind() because it calls ObjectDefineProperties which
+    // is a bottleneck here.
+    callback = once(bindAsyncResource(callback, 'STREAM_END_OF_STREAM'));
+  } else {
+    callback = once(callback);
+  }
+
   let isAborted = false;
   let abort = nop;
   if (options.signal) {
@@ -347,4 +404,5 @@ function finished(stream, opts) {
 module.exports = {
   eos,
   finished,
+  kEosNodeSynchronousCallback,
 };
diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index a57c1241bf82be..6fb78b816db7fd 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -90,7 +90,10 @@ const {
   streamBaseState,
 } = internalBinding('stream_wrap');
 
-const { eos } = require('internal/streams/end-of-stream');
+const {
+  eos,
+  kEosNodeSynchronousCallback,
+} = require('internal/streams/end-of-stream');
 
 const { zlib } = internalBinding('constants');
 const { UV_EOF } = internalBinding('uv');
@@ -136,6 +139,8 @@ function handleKnownInternalErrors(cause) {
   }
 }
 
+const noop = () => {};
+
 /**
  * @typedef {import('../../stream').Writable} Writable
  * @typedef {import('../../stream').Readable} Readable
@@ -443,6 +448,8 @@ function newStreamWritableFromWritableStream(writableStream, options = kEmptyObj
   return writable;
 }
 
+const kErrorSentinelAttached = Symbol('kErrorSentinelAttached');
+
 /**
  * @typedef {import('./queuingstrategies').QueuingStrategy} QueuingStrategy
  * @param {Readable} streamReadable
@@ -469,89 +476,81 @@ function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObj
   }
 
   const isBYOB = options.type === 'bytes';
-
-  if (isDestroyed(streamReadable) || !isReadable(streamReadable)) {
-    const readable = new ReadableStream();
-    readable.cancel();
-    return readable;
-  }
-
-  const objectMode = streamReadable.readableObjectMode;
-  const highWaterMark = streamReadable.readableHighWaterMark;
-
-  const evaluateStrategyOrFallback = (strategy) => {
-    // If the stream is BYOB, we only use highWaterMark
-    if (isBYOB)
-      return { highWaterMark };
-    // If there is a strategy available, use it
-    if (strategy)
-      return strategy;
-
-    if (objectMode) {
-      // When running in objectMode explicitly but no strategy, we just fall
-      // back to CountQueuingStrategy
-      return new CountQueuingStrategy({ highWaterMark });
-    }
-
-    return new ByteLengthQueuingStrategy({ highWaterMark });
-  };
-
-  const strategy = evaluateStrategyOrFallback(options?.strategy);
-
   let controller;
   let wasCanceled = false;
+  let strategy;
 
-  function onData(chunk) {
-    // Copy the Buffer to detach it from the pool.
-    if (Buffer.isBuffer(chunk) && !objectMode)
-      chunk = new Uint8Array(chunk);
-    controller.enqueue(chunk);
-    if (controller.desiredSize <= 0)
-      streamReadable.pause();
-  }
+  /** @type {UnderlyingSource} */
+  const underlyingSource = {
+    __proto__: null,
+    type: isBYOB ? 'bytes' : undefined,
+    start(c) { controller = c; },
+    cancel(reason) {
+      wasCanceled = true;
+      destroy(streamReadable, reason);
+    },
+  };
 
-  streamReadable.pause();
+  const readable = isReadable(streamReadable);
+  const objectMode = streamReadable.readableObjectMode;
+  if (readable) {
+    underlyingSource.pull = function pull() {
+      streamReadable.resume();
+    };
+
+    const highWaterMark = streamReadable.readableHighWaterMark;
+    strategy = isBYOB ? { highWaterMark } :
+      options.strategy ?? new (objectMode ? CountQueuingStrategy : ByteLengthQueuingStrategy)({ highWaterMark });
+  }
+  const readableStream = new ReadableStream(underlyingSource, strategy);
 
-  const cleanup = eos(streamReadable, (error) => {
+  // When adapting a Duplex as a ReadableStream, readable completion should not
+  // wait for a half-open writable side to finish as well.
+  let cleanup = noop;
+  cleanup = eos(streamReadable, {
+    __proto__: null,
+    writable: false,
+    [kEosNodeSynchronousCallback]: true,
+  }, (error) => {
     error = handleKnownInternalErrors(error);
 
+    // If eos calls the callback synchronously, cleanup is still a no-op here.
     cleanup();
-    // This is a protection against non-standard, legacy streams
-    // that happen to emit an error event again after finished is called.
-    streamReadable.on('error', () => {});
-    if (error)
-      return controller.error(error);
-    // Was already canceled
+
+    if (!(kErrorSentinelAttached in streamReadable)) {
+      // This is a protection against non-standard, legacy streams
+      // that happen to emit an error event again after finished is called.
+      streamReadable.on('error', noop);
+      streamReadable[kErrorSentinelAttached] = true;
+    }
     if (wasCanceled) {
       return;
     }
+    wasCanceled = true;
+    if (error)
+      return controller.error(error);
     controller.close();
+    if (isBYOB)
+      controller.byobRequest?.respond(0);
   });
 
-  streamReadable.on('data', onData);
-
-  return new ReadableStream({
-    type: isBYOB ? 'bytes' : undefined,
-    start(c) {
-      controller = c;
-      if (isBYOB) {
-        streamReadable.once('end', () => {
-          // close the controller
-          controller.close();
-          // And unlock the last BYOB read request
-          controller.byobRequest?.respond(0);
-          wasCanceled = true;
-        });
-      }
-    },
-
-    pull() { streamReadable.resume(); },
+  if (wasCanceled) {
+    // `eos` called the callback synchronously
+    cleanup();
+  } else if (readable) {
+    streamReadable.pause();
+
+    streamReadable.on('data', function onData(chunk) {
+      // Copy the Buffer to detach it from the pool.
+      if (Buffer.isBuffer(chunk) && !objectMode)
+        chunk = new Uint8Array(chunk);
+      controller.enqueue(chunk);
+      if (controller.desiredSize <= 0)
+        streamReadable.pause();
+    });
+  }
 
-    cancel(reason) {
-      wasCanceled = true;
-      destroy(streamReadable, reason);
-    },
-  }, strategy);
+  return readableStream;
 }
 
 /**
diff --git a/test/parallel/test-stream-finished.js b/test/parallel/test-stream-finished.js
index b55107a7a6440f..6c2f3cad68e1d8 100644
--- a/test/parallel/test-stream-finished.js
+++ b/test/parallel/test-stream-finished.js
@@ -1,3 +1,4 @@
+// Flags: --expose-internals
 'use strict';
 
 const common = require('../common');
@@ -15,6 +16,7 @@ const EE = require('events');
 const fs = require('fs');
 const { promisify } = require('util');
 const http = require('http');
+const { kEosNodeSynchronousCallback } = require('internal/streams/end-of-stream');
 
 {
   const rs = new Readable({
@@ -95,13 +97,20 @@ const http = require('http');
 
 {
   // Check pre-cancelled
-  const signal = new EventTarget();
-  signal.aborted = true;
+  const signal = AbortSignal.abort();
 
   const rs = Readable.from((function* () {})());
-  finished(rs, { signal }, common.mustCall((err) => {
+  const cleanup = finished(rs, { signal }, common.mustCall((err) => {
+    assert.strictEqual(err.name, 'AbortError');
+    cleanup();
+  }));
+  const unset = Symbol('unset');
+  let cleanup2 = unset;
+  cleanup2 = finished(rs, { signal, [kEosNodeSynchronousCallback]: true }, common.mustCall((err) => {
     assert.strictEqual(err.name, 'AbortError');
+    assert.strictEqual(cleanup2, unset);
   }));
+  cleanup2();
 }
 
 {
@@ -160,8 +169,7 @@ const http = require('http');
   // Promisified pre-aborted works
   const finishedPromise = promisify(finished);
   async function run() {
-    const signal = new EventTarget();
-    signal.aborted = true;
+    const signal = AbortSignal.abort();
     const rs = Readable.from((function* () {})());
     await finishedPromise(rs, { signal });
   }
@@ -592,6 +600,29 @@ testClosed((opts) => new Writable({ write() {}, ...opts }));
   }));
 }
 
+{
+  let serverRes;
+  const server = http.createServer(common.mustCall((req, res) => {
+    serverRes = res;
+    res.write('hello');
+  })).listen(0, common.mustCall(function() {
+    http.get({ port: this.address().port }, common.mustCall((res) => {
+      res.on('aborted', common.mustCall(() => {
+        finished(res, common.mustCall((err) => {
+          assert.strictEqual(err.code, 'ECONNRESET');
+          assert.strictEqual(err.message, 'aborted');
+          server.close();
+        }));
+      }));
+      res.on('error', common.expectsError({
+        code: 'ECONNRESET',
+        message: 'aborted',
+      }));
+      serverRes.destroy();
+    })).on('error', common.mustNotCall());
+  }));
+}
+
 {
   const w = new Writable({
     write(chunk, encoding, callback) {
diff --git a/test/parallel/test-stream-readable-to-web-termination.js b/test/parallel/test-stream-readable-to-web-termination.js
index 13fce9bc715e1e..f30cf721e14cd8 100644
--- a/test/parallel/test-stream-readable-to-web-termination.js
+++ b/test/parallel/test-stream-readable-to-web-termination.js
@@ -1,6 +1,8 @@
 'use strict';
-require('../common');
-const { Readable } = require('stream');
+const common = require('../common');
+const assert = require('assert');
+const { Duplex, Readable } = require('stream');
+const { setTimeout: delay } = require('timers/promises');
 
 {
   const r = Readable.from([]);
@@ -10,3 +12,33 @@ const { Readable } = require('stream');
   const reader = Readable.toWeb(r).getReader();
   reader.read();
 }
+
+{
+  const duplex = new Duplex({
+    read() {
+      this.push(Buffer.from('x'));
+      this.push(null);
+    },
+    write(_chunk, _encoding, callback) {
+      callback();
+    },
+  });
+
+  const reader = Readable.toWeb(duplex).getReader();
+
+  (async () => {
+    const result = await reader.read();
+    assert.deepStrictEqual(result, {
+      value: new Uint8Array(Buffer.from('x')),
+      done: false,
+    });
+
+    const closeResult = await Promise.race([
+      reader.read(),
+      delay(common.platformTimeout(100)).then(() => 'timeout'),
+    ]);
+
+    assert.notStrictEqual(closeResult, 'timeout');
+    assert.deepStrictEqual(closeResult, { value: undefined, done: true });
+  })().then(common.mustCall());
+}
diff --git a/test/parallel/test-whatwg-webstreams-adapters-to-readablestream.js b/test/parallel/test-whatwg-webstreams-adapters-to-readablestream.js
index 66af7b128c4d5a..eb01a39d8dc168 100644
--- a/test/parallel/test-whatwg-webstreams-adapters-to-readablestream.js
+++ b/test/parallel/test-whatwg-webstreams-adapters-to-readablestream.js
@@ -4,6 +4,7 @@
 const common = require('../common');
 
 const assert = require('assert');
+const { once } = require('events');
 
 const {
   newReadableStreamFromStreamReadable,
@@ -11,6 +12,7 @@ const {
 
 const {
   Duplex,
+  PassThrough,
   Readable,
 } = require('stream');
 
@@ -188,11 +190,142 @@ const {
 }
 
 {
-  const readable = new Readable();
+  /**
+   * Runs the same assertion across finalize-before/after and
+   * default/BYOB adapter creation orders.
+   * @param {(readable: Readable) => void | Promise<void>} finalize
+   *   Finalizes the source stream before or after adaptation.
+   * @param {(readAndAssert: () => Promise<void>, reader: ReadableStreamReader) => Promise<void>} postAssert
+   *   Asserts the resulting web stream state for the current case.
+   * @param {() => Readable} [createReadable]
+   *   Creates the source stream for each case.
+   */
+  function testConfluence(finalize, postAssert, createReadable = () => new PassThrough()) {
+    const cases = [false, true].flatMap((finalizeFirst) => [false, true].map((isBYOB) => ({ finalizeFirst, isBYOB })));
+    Promise.all(cases.map(async (case_) => {
+      try {
+        const { isBYOB } = case_;
+        const readable = createReadable();
+        if (case_.finalizeFirst) {
+          await finalize(readable);
+        }
+        /** @type {ReadableStream} */
+        const readableStream = newReadableStreamFromStreamReadable(readable, { type: isBYOB ? 'bytes' : undefined });
+        const reader = readableStream.getReader({ mode: isBYOB ? 'byob' : undefined });
+        if (!case_.finalizeFirst) {
+          await finalize(readable);
+        }
+
+        const readAndAssert = common.mustCall(() => {
+          return reader.read(isBYOB ? new Uint8Array(1) : undefined).then((result) => {
+            assert.deepStrictEqual(result, {
+              value: isBYOB ? new Uint8Array(0) : undefined,
+              done: true,
+            });
+          });
+        });
+        await postAssert(readAndAssert, reader);
+      } catch (cause) {
+        throw new Error(`Case failed: ${JSON.stringify(case_)}`, { cause });
+      }
+    })).then(common.mustCall());
+  }
+  const error = new Error('boom');
+  // Ending the readable without an error => closes the readableStream without an error
+  testConfluence(
+    async (readable) => {
+      readable.resume();
+      readable.end();
+      await once(readable, 'end');
+    },
+    common.mustCall(async (readAndAssert, reader) => {
+      await readAndAssert();
+      await reader.closed;
+    }, 4)
+  );
+  // Prematurely destroying the stream.Readable without an error
+  //   => errors the ReadableStream with a premature close error
+  testConfluence(
+    (readable) => readable.destroy(),
+    common.mustCall(async (readAndAssert, reader) => {
+      const errorPredicate = { code: 'ABORT_ERR' };
+      await assert.rejects(readAndAssert(), errorPredicate);
+      await assert.rejects(reader.closed, errorPredicate);
+    }, 4)
+  );
+  // Asynchronously destroyed readable => errors the ReadableStream with a
+  // premature close error regardless of adapter creation order.
+  class AsyncDestroyReadable extends Readable {
+    _read() {}
+
+    _destroy(error, callback) {
+      setImmediate(callback, error);
+    }
+  }
+  testConfluence(
+    (readable) => readable.destroy(),
+    common.mustCall(async (readAndAssert, reader) => {
+      const errorPredicate = { code: 'ABORT_ERR' };
+      await assert.rejects(readAndAssert(), errorPredicate);
+      await assert.rejects(reader.closed, errorPredicate);
+    }, 4),
+    () => new AsyncDestroyReadable()
+  );
+  // Destroying the readable with an error => errors the readableStream
+  testConfluence(
+    common.mustCall((readable) => {
+      readable.on('error', common.mustCall((reason) => {
+        assert.strictEqual(reason, error);
+      }));
+      readable.destroy(error);
+    }, 4),
+    common.mustCall(async (readAndAssert, reader) => {
+      await assert.rejects(readAndAssert(), error);
+      await assert.rejects(reader.closed, error);
+    }, 4)
+  );
+}
+
+{
+  const readable = new PassThrough();
+  readable.end();
   readable.destroy();
-  const readableStream = newReadableStreamFromStreamReadable(readable);
-  const reader = readableStream.getReader();
-  reader.closed.then(common.mustCall());
+
+  (async () => {
+    await new Promise((resolve) => readable.once('close', resolve));
+    assert.strictEqual(readable.listenerCount('error'), 0);
+
+    const readableStream = newReadableStreamFromStreamReadable(readable);
+    // Only one error listener from the adapter should be added
+    assert.strictEqual(readable.listenerCount('error'), 1);
+    newReadableStreamFromStreamReadable(readable);
+    // No duplicate listeners should be added.
+    assert.strictEqual(readable.listenerCount('error'), 1);
+
+    const readResult = await readableStream.getReader().read();
+    assert.deepStrictEqual(readResult, { value: undefined, done: true });
+  })().then(common.mustCall());
+}
+
+{
+  const readable = new PassThrough();
+  const readableStream = newReadableStreamFromStreamReadable(readable, {
+    type: 'bytes',
+  });
+  const reader = readableStream.getReader({ mode: 'byob' });
+
+  (async () => {
+    const readPromise = reader.read(new Uint8Array(8));
+
+    readable.end();
+    await once(readable, 'end');
+
+    assert.deepStrictEqual(await readPromise, {
+      value: new Uint8Array(0),
+      done: true,
+    });
+    await reader.closed;
+  })().then(common.mustCall());
 }
 
 {

From d2b68406e7e66488a2fca87c6589360cff192e99 Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Tue, 19 May 2026 10:35:54 -0400
Subject: [PATCH 12/83] tools: update gyp-next to 0.22.2

PR-URL: https://github.com/nodejs/node/pull/63374
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 tools/gyp/CHANGELOG.md   | 7 +++++++
 tools/gyp/pyproject.toml | 8 ++++----
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/tools/gyp/CHANGELOG.md b/tools/gyp/CHANGELOG.md
index c7ddd862d1a4a0..c6686c4784a757 100644
--- a/tools/gyp/CHANGELOG.md
+++ b/tools/gyp/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.22.2](https://github.com/nodejs/gyp-next/compare/v0.22.1...v0.22.2) (2026-04-22)
+
+
+### Bug Fixes
+
+* **build:** Use SPDX license expression ([#310](https://github.com/nodejs/gyp-next/issues/310)) ([ce0da4a](https://github.com/nodejs/gyp-next/commit/ce0da4a6dc1068b73e55e6a58a236bf69f2fed4d))
+
 ## [0.22.1](https://github.com/nodejs/gyp-next/compare/v0.22.0...v0.22.1) (2026-04-21)
 
 
diff --git a/tools/gyp/pyproject.toml b/tools/gyp/pyproject.toml
index 239bef7844a659..487cb75002d2e4 100644
--- a/tools/gyp/pyproject.toml
+++ b/tools/gyp/pyproject.toml
@@ -4,20 +4,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gyp-next"
-version = "0.22.1"
+version = "0.22.2"
 authors = [
   { name="Node.js contributors", email="ryzokuken@disroot.org" },
 ]
 description = "A fork of the GYP build system for use in the Node.js projects"
 readme = "README.md"
-license = { file="LICENSE" }
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
 requires-python = ">=3.9"
-dependencies = ["packaging>=24.0", "setuptools>=69.5.1"]
+dependencies = ["packaging>=24.0", "setuptools>=77.0.3"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: BSD License",
     "Natural Language :: English",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",

From 216718affcca542ff689a81620cb9bc0be457c99 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 19 May 2026 16:36:16 +0200
Subject: [PATCH 13/83] tools: bump the eslint group in /tools/eslint with 4
 updates

Bumps the eslint group in /tools/eslint with 4 updates:
[@babel/core](https://github.com/babel/babel/tree/HEAD/packages/babel-core),
[@babel/eslint-parser](https://github.com/babel/babel/tree/HEAD/eslint/babel-eslint-parser),
[@babel/plugin-syntax-import-source](https://github.com/babel/babel/tree/HEAD/packages/babel-plugin-syntax-import-source)
and [eslint](https://github.com/eslint/eslint).

Updates `@babel/core` from 8.0.0-rc.3 to 8.0.0-rc.4
- [Release notes](https://github.com/babel/babel/releases)
- [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md)
- [Commits](https://github.com/babel/babel/commits/v8.0.0-rc.4/packages/babel-core)

Updates `@babel/eslint-parser` from 8.0.0-rc.3 to 8.0.0-rc.4
- [Release notes](https://github.com/babel/babel/releases)
- [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md)
- [Commits](https://github.com/babel/babel/commits/v8.0.0-rc.4/eslint/babel-eslint-parser)

Updates `@babel/plugin-syntax-import-source` from 8.0.0-rc.3 to
8.0.0-rc.4
- [Release notes](https://github.com/babel/babel/releases)
- [Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md)
- [Commits](https://github.com/babel/babel/commits/v8.0.0-rc.4/packages/babel-plugin-syntax-import-source)

Updates `eslint` from 10.2.0 to 10.2.1
- [Release notes](https://github.com/eslint/eslint/releases)
- [Commits](https://github.com/eslint/eslint/compare/v10.2.0...v10.2.1)

---
updated-dependencies:
- dependency-name: "@babel/core"
  dependency-version: 8.0.0-rc.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: eslint
- dependency-name: "@babel/eslint-parser"
  dependency-version: 8.0.0-rc.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: eslint
- dependency-name: "@babel/plugin-syntax-import-source"
  dependency-version: 8.0.0-rc.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: eslint
- dependency-name: eslint
  dependency-version: 10.2.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: eslint
...

PR-URL: https://github.com/nodejs/node/pull/63075
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 tools/eslint/package-lock.json | 241 ++++++++++++++++-----------------
 tools/eslint/package.json      |   8 +-
 2 files changed, 119 insertions(+), 130 deletions(-)

diff --git a/tools/eslint/package-lock.json b/tools/eslint/package-lock.json
index 773eb74fd03f80..5855e2e04ac1f5 100644
--- a/tools/eslint/package-lock.json
+++ b/tools/eslint/package-lock.json
@@ -8,13 +8,13 @@
       "name": "eslint-tools",
       "version": "0.0.0",
       "dependencies": {
-        "@babel/core": "^8.0.0-rc.3",
-        "@babel/eslint-parser": "^8.0.0-rc.3",
-        "@babel/plugin-syntax-import-source": "^8.0.0-rc.3",
+        "@babel/core": "^8.0.0-rc.4",
+        "@babel/eslint-parser": "^8.0.0-rc.4",
+        "@babel/plugin-syntax-import-source": "^8.0.0-rc.4",
         "@eslint/js": "^10.0.1",
         "@eslint/markdown": "^8.0.1",
         "@stylistic/eslint-plugin": "^5.10.0",
-        "eslint": "^10.2.0",
+        "eslint": "^10.2.1",
         "eslint-formatter-tap": "^9.0.1",
         "eslint-plugin-jsdoc": "^62.9.0",
         "eslint-plugin-regexp": "^3.1.0",
@@ -22,12 +22,12 @@
       }
     },
     "node_modules/@babel/code-frame": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-8.0.0-rc.3.tgz",
-      "integrity": "sha512-585nwYQGQKKc+jMIAPeZJ+aGMn4FHmIUUjLZa9zI7mslvYmShnx0u7rFA4gliRip6S2vkwTYrMxPeXadkKW93Q==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-8.0.0-rc.4.tgz",
+      "integrity": "sha512-IKAasu/lBZl6mw5HlYCabqi7jGe5cPr9LhnQNf1YH5PWpeWAgchzwzi+siTBbnKEfw4WeSn2OOmDzHklg/Pz9Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^8.0.0-rc.3",
+        "@babel/helper-validator-identifier": "^8.0.0-rc.4",
         "js-tokens": "^10.0.0"
       },
       "engines": {
@@ -35,29 +35,28 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-8.0.0-rc.3.tgz",
-      "integrity": "sha512-TlS7d9xYz/93xC8ovkRBwTKPodbwPfzTn7TxUgZo4c3LwpPINnScqIlN0QRDE/x1S4C1bmyqxGmAZUIC0buW0A==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-8.0.0-rc.4.tgz",
+      "integrity": "sha512-0bCEZ+LmwXRVvkKuxYirgkFq2dMFAs3WyxVtDnOE1djnS6BnyIP0Gym4oC3JKMY8es8U3dgBdKKxAsA+pJJcYg==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/core": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.0-rc.3.tgz",
-      "integrity": "sha512-ov5mBbHiosqX1eqt8nN0JM7VuhirO6V8lln5rUXNZpNB+a9NnPTVYeDqSTBkf9C6GmFq3fnFlGT8eg3QBI7jJQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^8.0.0-rc.3",
-        "@babel/generator": "^8.0.0-rc.3",
-        "@babel/helper-compilation-targets": "^8.0.0-rc.3",
-        "@babel/helpers": "^8.0.0-rc.3",
-        "@babel/parser": "^8.0.0-rc.3",
-        "@babel/template": "^8.0.0-rc.3",
-        "@babel/traverse": "^8.0.0-rc.3",
-        "@babel/types": "^8.0.0-rc.3",
-        "@jridgewell/remapping": "^2.3.5",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-8.0.0-rc.4.tgz",
+      "integrity": "sha512-VhCk07qH2rgkEW6rdOI8nlRd359a+TdnxXqsl3cynjtvkxbdbHVaW+3NUt+BXv4IYy6tjjZihPo5PWg65c7EJQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^8.0.0-rc.4",
+        "@babel/generator": "^8.0.0-rc.4",
+        "@babel/helper-compilation-targets": "^8.0.0-rc.4",
+        "@babel/helpers": "^8.0.0-rc.4",
+        "@babel/parser": "^8.0.0-rc.4",
+        "@babel/template": "^8.0.0-rc.4",
+        "@babel/traverse": "^8.0.0-rc.4",
+        "@babel/types": "^8.0.0-rc.4",
         "@types/gensync": "^1.0.0",
         "convert-source-map": "^2.0.0",
         "gensync": "^1.0.0-beta.2",
@@ -83,9 +82,9 @@
       }
     },
     "node_modules/@babel/eslint-parser": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-8.0.0-rc.3.tgz",
-      "integrity": "sha512-YsJgMO5TVzHGpX0zNF5WkrKj04QI32kQv0L2r/KKbCOmOt4A/XhM5zctW7WgFiOAEZafWfQyo6dWEwwBjZnHlQ==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-8.0.0-rc.4.tgz",
+      "integrity": "sha512-Caw6OIRvHiAG1aBrbmiZavs0lCtxHxwFlmlY4xcRkdzK+0Cka3aYydMyIbZov77Gf+reZbP4yfcWwlSAx78qRw==",
       "license": "MIT",
       "dependencies": {
         "eslint-scope": "^9.1.0",
@@ -96,18 +95,18 @@
         "node": "^20.19.0 || >=22.12.0"
       },
       "peerDependencies": {
-        "@babel/core": "^8.0.0-rc.3",
+        "@babel/core": "^8.0.0-rc.4",
         "eslint": "^9.0.0 || ^10.0.0"
       }
     },
     "node_modules/@babel/generator": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-8.0.0-rc.3.tgz",
-      "integrity": "sha512-em37/13/nR320G4jab/nIIHZgc2Wz2y/D39lxnTyxB4/D/omPQncl/lSdlnJY1OhQcRGugTSIF2l/69o31C9dA==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-8.0.0-rc.4.tgz",
+      "integrity": "sha512-YZ+FuIgkj7KrIb2a2X1XiY0QYgDxAbVbYP64SjwJzOK3euCsUerzenh2oqdsmKuPSlhzmFOOklnxzHAzXagvpw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^8.0.0-rc.3",
-        "@babel/types": "^8.0.0-rc.3",
+        "@babel/parser": "^8.0.0-rc.4",
+        "@babel/types": "^8.0.0-rc.4",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "@types/jsesc": "^2.5.0",
@@ -118,13 +117,13 @@
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-8.0.0-rc.3.tgz",
-      "integrity": "sha512-UXlT7t103KBJjiphN7Ij9DtELX2Q5uk1xMle7oN/eckxR8dmJyvbFsIm5u+cY0KZyF7qNkAiLsJljEPix1yfKg==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-8.0.0-rc.4.tgz",
+      "integrity": "sha512-pGB7/0uJCdPwKVFd0t3w7S0lN63/V8b20tn5QgdiWYizyTb648hYTyotNYuoHU7HxrQl2FS1ItlJiThzHuE86Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^8.0.0-rc.3",
-        "@babel/helper-validator-option": "^8.0.0-rc.3",
+        "@babel/compat-data": "^8.0.0-rc.4",
+        "@babel/helper-validator-option": "^8.0.0-rc.4",
         "browserslist": "^4.24.0",
         "lru-cache": "^7.14.1",
         "semver": "^7.7.3"
@@ -134,73 +133,73 @@
       }
     },
     "node_modules/@babel/helper-globals": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-8.0.0-rc.3.tgz",
-      "integrity": "sha512-rwtdZPunoa/IAlcZhgDoLxROXPW5evSN7SXMdObS8vNt7Wu6fCf8nLPFcuuhLCzeRoIrGNKx08v/XEQ4riQDGg==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-8.0.0-rc.4.tgz",
+      "integrity": "sha512-gpEp45D4E60hUci5mWeQF9YNisMFaBg9lFsFzx/5qwRL3wbXv6z8/aOeaclec68RqxE9bv3SG7gP2wypyHBbSg==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-8.0.0-rc.3.tgz",
-      "integrity": "sha512-1+lvhojDf75++IwFRWrch4BBaznB2Z99GCfggHFWEKJ8B40iovZ8KqP0kDeb60ThuAa7WxCbtuYHfP5BtJL1kA==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-8.0.0-rc.4.tgz",
+      "integrity": "sha512-yX9iDB1iC6ZQLiIW08DTNpzH6nxMuhdcP3PDsfNoBQbgE/ph3Rjhi6CyyFKFH5haeP15T7Bf/ZBIGjPHEMTlzQ==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       },
       "peerDependencies": {
-        "@babel/core": "^8.0.0-rc.3"
+        "@babel/core": "^8.0.0-rc.4"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.0-rc.3.tgz",
-      "integrity": "sha512-AmwWFx1m8G/a5cXkxLxTiWl+YEoWuoFLUCwqMlNuWO1tqAYITQAbCRPUkyBHv1VOFgfjVOqEj6L3u15J5ZCzTA==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.0-rc.4.tgz",
+      "integrity": "sha512-dluR3v287dp6YPF57kyKKrHPKffUeuxH1zQcF1WD30TeFzWXhDiVi1U6PkqaDB0++H1PeCwRhmYl4DvoerlPIw==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-8.0.0-rc.3.tgz",
-      "integrity": "sha512-8AWCJ2VJJyDFlGBep5GpaaQ9AAaE/FjAcrqI7jyssYhtL7WGV0DOKpJsQqM037xDbpRLHXsY8TwU7zDma7coOw==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-8.0.0-rc.4.tgz",
+      "integrity": "sha512-HTD3bskipk5MSm08twTW6832jzIXUhxMddy4NPPzIMuyMEsrs0ZgwAaMj5ubB5+6hMlUjDu17vNconEmwsmpYg==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-8.0.0-rc.3.tgz",
-      "integrity": "sha512-wpzZ9KycQDqmJct4ee/ihua2KKdW/MXTDidD4Ya7HdUHL+Jp5zBZTj8oNrxc8wp5Qr4sofKgZF1GIyymfdq7+g==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-8.0.0-rc.4.tgz",
+      "integrity": "sha512-OFognYIXIr2hlubLRUohiFcj6c74CT4fL+j23v3tH/I2y/XA+jWN+v+V0jeFZ1dx0oG+CRfhgNjz75F9d6BFyw==",
       "license": "MIT",
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-8.0.0-rc.3.tgz",
-      "integrity": "sha512-dbPuulmsPOwIAXP4pGsKiAv1E50pKYmAJfWXYytCwLpgj6IDNUFAzGuVVemaphYP/WniKsCf42+Cfo4xpc4jjQ==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-8.0.0-rc.4.tgz",
+      "integrity": "sha512-4h9FSYm3mhyM72Lj7pUKygzqN/3/ptKY30ThccjQL7pi5VKSsgjDJMkoguhJJgI8fY+ZS37Jqd/iKtFHBoRIHg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^8.0.0-rc.3",
-        "@babel/types": "^8.0.0-rc.3"
+        "@babel/template": "^8.0.0-rc.4",
+        "@babel/types": "^8.0.0-rc.4"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.0-rc.3.tgz",
-      "integrity": "sha512-B20dvP3MfNc/XS5KKCHy/oyWl5IA6Cn9YjXRdDlCjNmUFrjvLXMNUfQq/QUy9fnG2gYkKKcrto2YaF9B32ToOQ==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.0-rc.4.tgz",
+      "integrity": "sha512-0S/1yefMa15N4i2v3t8Fw9pgMHhf2gF6Lc1UEXI96Ls6FNAjqvHHZouZ2ZS/deqLhbMFtmfVeFac6iTsvFbLwA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^8.0.0-rc.3"
+        "@babel/types": "^8.0.0-rc.4"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -210,46 +209,46 @@
       }
     },
     "node_modules/@babel/plugin-syntax-import-source": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-source/-/plugin-syntax-import-source-8.0.0-rc.3.tgz",
-      "integrity": "sha512-enWWk7TiwxhNMdLgyY1JKYhpsTHoKh5rotU6RHelLGefWCk6vAA1wamfNhu1wWch/tRUm4UCo8imafyzUem1Mg==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-source/-/plugin-syntax-import-source-8.0.0-rc.4.tgz",
+      "integrity": "sha512-RnXuuDACF9qvUagoTW50EvqDM+ySR91Z6nrDuc1IqQLbg2gC2bagvJPAe6zxCF1/Azl8r7SlKjo5dSMjme6kkQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^8.0.0-rc.3"
+        "@babel/helper-plugin-utils": "^8.0.0-rc.4"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       },
       "peerDependencies": {
-        "@babel/core": "^8.0.0-rc.3"
+        "@babel/core": "^8.0.0-rc.4"
       }
     },
     "node_modules/@babel/template": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-8.0.0-rc.3.tgz",
-      "integrity": "sha512-9iet2svxZhCGgmt/b6M3Fbmy2i+OgjhXMDWNqDTBrNvb9Cc60NgETNIaJq6b0wICiCqpsFdIt8NYXMXyCQU6jA==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-8.0.0-rc.4.tgz",
+      "integrity": "sha512-9DXoBFgYSIhNbzx0SxVrS2oWd19YNgFY3l0HN0kVMiJvg123CKSrvbX4TkN51yAn9B1BPo9JxzCX2BtR1LMsiA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^8.0.0-rc.3",
-        "@babel/parser": "^8.0.0-rc.3",
-        "@babel/types": "^8.0.0-rc.3"
+        "@babel/code-frame": "^8.0.0-rc.4",
+        "@babel/parser": "^8.0.0-rc.4",
+        "@babel/types": "^8.0.0-rc.4"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-8.0.0-rc.3.tgz",
-      "integrity": "sha512-3gvZCynaX+zxYZ2v5odaBBcc9eT4Yr7Gf16l3QSEvvBPVyMSZbYhsGAZfO79kjOCNJY2j6rWvNkWl1ZwYa64lQ==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-8.0.0-rc.4.tgz",
+      "integrity": "sha512-IoC3txfExDHZf6YnDeTty4jXSorZI5zBZbPRXqJWtZOEdTDdC6RP5gWAasb6el8UBN7Y/Lp39UZcU05BopJ28Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^8.0.0-rc.3",
-        "@babel/generator": "^8.0.0-rc.3",
-        "@babel/helper-globals": "^8.0.0-rc.3",
-        "@babel/parser": "^8.0.0-rc.3",
-        "@babel/template": "^8.0.0-rc.3",
-        "@babel/types": "^8.0.0-rc.3",
+        "@babel/code-frame": "^8.0.0-rc.4",
+        "@babel/generator": "^8.0.0-rc.4",
+        "@babel/helper-globals": "^8.0.0-rc.4",
+        "@babel/parser": "^8.0.0-rc.4",
+        "@babel/template": "^8.0.0-rc.4",
+        "@babel/types": "^8.0.0-rc.4",
         "obug": "^2.1.1"
       },
       "engines": {
@@ -257,13 +256,13 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "8.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.0-rc.3.tgz",
-      "integrity": "sha512-mOm5ZrYmphGfqVWoH5YYMTITb3cDXsFgmvFlvkvWDMsR9X8RFnt7a0Wb6yNIdoFsiMO9WjYLq+U/FMtqIYAF8Q==",
+      "version": "8.0.0-rc.4",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.0-rc.4.tgz",
+      "integrity": "sha512-bw30DV880P/VYtsjWWdoWmJpb9S2Vn1/PqayyccTELzRQ/HslIO7+BD9rNoZ4AAFOAjC1vrNeBCkAsyh6Ibfww==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^8.0.0-rc.3",
-        "@babel/helper-validator-identifier": "^8.0.0-rc.3"
+        "@babel/helper-string-parser": "^8.0.0-rc.4",
+        "@babel/helper-validator-identifier": "^8.0.0-rc.4"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
@@ -496,16 +495,6 @@
         "@jridgewell/trace-mapping": "^0.3.24"
       }
     },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
     "node_modules/@jridgewell/resolve-uri": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
@@ -725,9 +714,9 @@
       }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.8",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.8.tgz",
-      "integrity": "sha512-PCLz/LXGBsNTErbtB6i5u4eLpHeMfi93aUv5duMmj6caNu6IphS4q6UevDnL36sZQv9lrP11dbPKGMaXPwMKfQ==",
+      "version": "2.10.25",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.25.tgz",
+      "integrity": "sha512-QO/VHsXCQdnzADMfmkeOPvHdIAkoB7i0/rGjINPJEetLx75hNttVWGQ/jycHUDP9zZ9rupbm60WRxcwViB0MiA==",
       "license": "Apache-2.0",
       "bin": {
         "baseline-browser-mapping": "dist/cli.cjs"
@@ -749,9 +738,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.28.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
-      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
       "funding": [
         {
           "type": "opencollective",
@@ -768,11 +757,11 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "baseline-browser-mapping": "^2.9.0",
-        "caniuse-lite": "^1.0.30001759",
-        "electron-to-chromium": "^1.5.263",
-        "node-releases": "^2.0.27",
-        "update-browserslist-db": "^1.2.0"
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -782,9 +771,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001780",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001780.tgz",
-      "integrity": "sha512-llngX0E7nQci5BPJDqoZSbuZ5Bcs9F5db7EtgfwBerX9XGtkkiO4NwfDDIRzHTTwcYC8vC7bmeUEPGrKlR/TkQ==",
+      "version": "1.0.30001791",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001791.tgz",
+      "integrity": "sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ==",
       "funding": [
         {
           "type": "opencollective",
@@ -918,9 +907,9 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.321",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.321.tgz",
-      "integrity": "sha512-L2C7Q279W2D/J4PLZLk7sebOILDSWos7bMsMNN06rK482umHUrh/3lM8G7IlHFOYip2oAg5nha1rCMxr/rs6ZQ==",
+      "version": "1.5.348",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.348.tgz",
+      "integrity": "sha512-QC2X59nRlycQQMc4ZXjSVBX+tSgJfgRtcrYHbIZLgOV2dCvefoQGegLR7lLXKgpPpSuVmJU19LMzGrSa2C7k3Q==",
       "license": "ISC"
     },
     "node_modules/escalade": {
@@ -945,17 +934,17 @@
       }
     },
     "node_modules/eslint": {
-      "version": "10.2.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.2.0.tgz",
-      "integrity": "sha512-+L0vBFYGIpSNIt/KWTpFonPrqYvgKw1eUI5Vn7mEogrQcWtWYtNQ7dNqC+px/J0idT3BAkiWrhfS7k+Tum8TUA==",
+      "version": "10.2.1",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.2.1.tgz",
+      "integrity": "sha512-wiyGaKsDgqXvF40P8mDwiUp/KQjE1FdrIEJsM8PZ3XCiniTMXS3OHWWUe5FI5agoCnr8x4xPrTDZuxsBlNHl+Q==",
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.2",
-        "@eslint/config-array": "^0.23.4",
-        "@eslint/config-helpers": "^0.5.4",
-        "@eslint/core": "^1.2.0",
-        "@eslint/plugin-kit": "^0.7.0",
+        "@eslint/config-array": "^0.23.5",
+        "@eslint/config-helpers": "^0.5.5",
+        "@eslint/core": "^1.2.1",
+        "@eslint/plugin-kit": "^0.7.1",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
         "@humanwhocodes/retry": "^0.4.2",
@@ -2431,9 +2420,9 @@
       "license": "MIT"
     },
     "node_modules/node-releases": {
-      "version": "2.0.36",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
-      "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
+      "version": "2.0.38",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.38.tgz",
+      "integrity": "sha512-3qT/88Y3FbH/Kx4szpQQ4HzUbVrHPKTLVpVocKiLfoYvw9XSGOX2FmD2d6DrXbVYyAQTF2HeF6My8jmzx7/CRw==",
       "license": "MIT"
     },
     "node_modules/object-deep-merge": {
diff --git a/tools/eslint/package.json b/tools/eslint/package.json
index a6cb40841b6d67..a3a6ac0d1c1d7d 100644
--- a/tools/eslint/package.json
+++ b/tools/eslint/package.json
@@ -3,13 +3,13 @@
   "version": "0.0.0",
   "private": true,
   "dependencies": {
-    "@babel/core": "^8.0.0-rc.3",
-    "@babel/eslint-parser": "^8.0.0-rc.3",
-    "@babel/plugin-syntax-import-source": "^8.0.0-rc.3",
+    "@babel/core": "^8.0.0-rc.4",
+    "@babel/eslint-parser": "^8.0.0-rc.4",
+    "@babel/plugin-syntax-import-source": "^8.0.0-rc.4",
     "@eslint/js": "^10.0.1",
     "@eslint/markdown": "^8.0.1",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "eslint": "^10.2.0",
+    "eslint": "^10.2.1",
     "eslint-formatter-tap": "^9.0.1",
     "eslint-plugin-jsdoc": "^62.9.0",
     "eslint-plugin-regexp": "^3.1.0",

From f352556da863c3ad8c32acbe853f3018946b623b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9?= <contact.9a5d6388@renegade334.me.uk>
Date: Tue, 19 May 2026 16:52:32 +0100
Subject: [PATCH 14/83] stream: disallow writing string chunk with 'buffer'
 encoding

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>
PR-URL: https://github.com/nodejs/node/pull/63062
Refs: https://github.com/nodejs/node/pull/33075
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/streams/writable.js              |  3 +++
 src/stream_base.cc                            |  6 +----
 .../parallel/test-stream-base-typechecking.js | 18 ---------------
 .../test-stream-writable-write-error.js       | 22 +++++++++++++------
 4 files changed, 19 insertions(+), 30 deletions(-)
 delete mode 100644 test/parallel/test-stream-base-typechecking.js

diff --git a/lib/internal/streams/writable.js b/lib/internal/streams/writable.js
index 89d384e9f2fb8f..94913461cb6044 100644
--- a/lib/internal/streams/writable.js
+++ b/lib/internal/streams/writable.js
@@ -466,6 +466,9 @@ function _write(stream, chunk, encoding, cb) {
     }
 
     if (typeof chunk === 'string') {
+      if (encoding === 'buffer') {
+        throw new ERR_UNKNOWN_ENCODING(encoding);
+      }
       if ((state[kState] & kDecodeStrings) !== 0) {
         chunk = Buffer.from(chunk, encoding);
         encoding = 'buffer';
diff --git a/src/stream_base.cc b/src/stream_base.cc
index 6a631921341307..370b8f682eadae 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -296,14 +296,10 @@ int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
 
 int StreamBase::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsObject());
+  CHECK(args[1]->IsUint8Array());
 
   Environment* env = Environment::GetCurrent(args);
 
-  if (!args[1]->IsUint8Array()) {
-    node::THROW_ERR_INVALID_ARG_TYPE(env, "Second argument must be a buffer");
-    return 0;
-  }
-
   Local<Object> req_wrap_obj = args[0].As<Object>();
   uv_buf_t buf;
   buf.base = Buffer::Data(args[1]);
diff --git a/test/parallel/test-stream-base-typechecking.js b/test/parallel/test-stream-base-typechecking.js
deleted file mode 100644
index ae8582642344ee..00000000000000
--- a/test/parallel/test-stream-base-typechecking.js
+++ /dev/null
@@ -1,18 +0,0 @@
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-const net = require('net');
-
-const server = net.createServer().listen(0, common.mustCall(() => {
-  const client = net.connect(server.address().port, common.mustCall(() => {
-    assert.throws(() => {
-      client.write('broken', 'buffer');
-    }, {
-      name: 'TypeError',
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'Second argument must be a buffer'
-    });
-    client.destroy();
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-stream-writable-write-error.js b/test/parallel/test-stream-writable-write-error.js
index 069e32e1be8e3e..76f797fb1bd583 100644
--- a/test/parallel/test-stream-writable-write-error.js
+++ b/test/parallel/test-stream-writable-write-error.js
@@ -31,7 +31,7 @@ function test(autoDestroy) {
   {
     const w = new Writable({
       autoDestroy,
-      _write() {}
+      write() {}
     });
     w.end();
     expectError(w, ['asd'], 'ERR_STREAM_WRITE_AFTER_END');
@@ -40,7 +40,7 @@ function test(autoDestroy) {
   {
     const w = new Writable({
       autoDestroy,
-      _write() {}
+      write() {}
     });
     w.destroy();
   }
@@ -48,7 +48,7 @@ function test(autoDestroy) {
   {
     const w = new Writable({
       autoDestroy,
-      _write() {}
+      write() {}
     });
     expectError(w, [null], 'ERR_STREAM_NULL_VALUES', true);
   }
@@ -56,18 +56,26 @@ function test(autoDestroy) {
   {
     const w = new Writable({
       autoDestroy,
-      _write() {}
+      write() {}
     });
     expectError(w, [{}], 'ERR_INVALID_ARG_TYPE', true);
   }
 
   {
     const w = new Writable({
-      decodeStrings: false,
       autoDestroy,
-      _write() {}
+      write() {}
+    });
+    expectError(w, ['asd', 'buffer'], 'ERR_UNKNOWN_ENCODING', true);
+  }
+
+  {
+    const w = new Writable({
+      autoDestroy,
+      decodeStrings: false,
+      write() {}
     });
-    expectError(w, ['asd', 'noencoding'], 'ERR_UNKNOWN_ENCODING', true);
+    expectError(w, ['asd', 'buffer'], 'ERR_UNKNOWN_ENCODING', true);
   }
 }
 

From 21a92e8d862844db7b884fde2c2ed6f6e5a9fbf1 Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Tue, 19 May 2026 12:54:12 -0400
Subject: [PATCH 15/83] deps: update undici to 8.3.0

PR-URL: https://github.com/nodejs/node/pull/63377
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 deps/undici/src/.gitignore                    |    2 +
 deps/undici/src/README.md                     |   13 +-
 .../src/docs/docs/api/GlobalInstallation.md   |   12 +-
 .../undici/src/docs/docs/api/SnapshotAgent.md |   23 +
 deps/undici/src/lib/api/api-pipeline.js       |    4 +
 deps/undici/src/lib/api/api-stream.js         |   56 +-
 deps/undici/src/lib/core/symbols.js           |    1 +
 deps/undici/src/lib/core/util.js              |    4 +-
 deps/undici/src/lib/dispatcher/client-h1.js   |   77 +-
 deps/undici/src/lib/dispatcher/client-h2.js   |  667 +++++----
 deps/undici/src/lib/dispatcher/client.js      |    4 +-
 deps/undici/src/lib/dispatcher/pool-base.js   |   24 +-
 deps/undici/src/lib/dispatcher/pool.js        |   23 +
 deps/undici/src/lib/dispatcher/proxy-agent.js |   25 +-
 .../src/lib/dispatcher/round-robin-pool.js    |   26 +
 .../src/lib/dispatcher/socks5-proxy-agent.js  |   38 +-
 deps/undici/src/lib/handler/retry-handler.js  |   14 +
 deps/undici/src/lib/llhttp/wasm_build_env.txt |    2 +-
 deps/undici/src/lib/mock/mock-utils.js        |    4 +-
 deps/undici/src/lib/mock/snapshot-agent.js    |    2 +
 deps/undici/src/lib/mock/snapshot-recorder.js |   41 +-
 deps/undici/src/lib/web/fetch/body.js         |    9 +-
 deps/undici/src/lib/web/fetch/formdata.js     |   23 +-
 deps/undici/src/lib/web/fetch/index.js        |    2 +
 deps/undici/src/package-lock.json             | 1266 ++++++++---------
 deps/undici/src/package.json                  |    8 +-
 deps/undici/src/types/client.d.ts             |   14 +-
 deps/undici/src/types/dispatcher.d.ts         |    2 -
 deps/undici/src/types/formdata.d.ts           |    6 -
 deps/undici/src/types/snapshot-agent.d.ts     |    4 +
 deps/undici/undici.js                         |  984 ++++++++-----
 src/undici_version.h                          |    2 +-
 32 files changed, 1952 insertions(+), 1430 deletions(-)

diff --git a/deps/undici/src/.gitignore b/deps/undici/src/.gitignore
index 2af62573ea7ee8..fc02456981b799 100644
--- a/deps/undici/src/.gitignore
+++ b/deps/undici/src/.gitignore
@@ -91,3 +91,5 @@ AGENTS.md
 
 # Ignore .githuman
 .githuman
+
+benchmarks/package-lock.json
diff --git a/deps/undici/src/README.md b/deps/undici/src/README.md
index c15ffd0cc86910..b5a1cc17c04fd5 100644
--- a/deps/undici/src/README.md
+++ b/deps/undici/src/README.md
@@ -200,7 +200,9 @@ await fetch('https://example.com', {
 ```
 
 `install()` replaces the global `fetch`, `Headers`, `Response`, `Request`, and
-`FormData` implementations with undici's versions, so they all match.
+`FormData` implementations with undici's versions, so they all match. It also
+installs undici's `WebSocket`, `CloseEvent`, `ErrorEvent`, `MessageEvent`, and
+`EventSource` globals.
 
 Avoid mixing a global `FormData` with `undici.fetch()`, or `undici.FormData`
 with the built-in global `fetch()`.
@@ -283,12 +285,12 @@ const data2 = await getData();
 
 ## Global Installation
 
-Undici provides an `install()` function to add all WHATWG fetch classes to `globalThis`, making them available globally:
+Undici provides an `install()` function to add fetch-related and other web API classes to `globalThis`, making them available globally:
 
 ```js
 import { install } from 'undici'
 
-// Install all WHATWG fetch classes globally
+// Install undici's global web APIs
 install()
 
 // Now you can use fetch classes globally without importing
@@ -316,8 +318,9 @@ The `install()` function adds the following classes to `globalThis`:
 
 When you call `install()`, these globals come from the same undici
 implementation. For example, global `fetch` and global `FormData` will both be
-undici's versions, which is the recommended setup if you want to use undici
-through globals.
+undici's versions, and `WebSocket` and `EventSource` will also come from
+undici, which is the recommended setup if you want to use undici through
+globals.
 
 This is useful for:
 - Polyfilling environments that don't have fetch
diff --git a/deps/undici/src/docs/docs/api/GlobalInstallation.md b/deps/undici/src/docs/docs/api/GlobalInstallation.md
index 2fc5bc2fd86ce3..d2f8f77e7b8b0f 100644
--- a/deps/undici/src/docs/docs/api/GlobalInstallation.md
+++ b/deps/undici/src/docs/docs/api/GlobalInstallation.md
@@ -1,17 +1,17 @@
 # Global Installation
 
-Undici provides an `install()` function to add all WHATWG fetch classes to `globalThis`, making them available globally without requiring imports.
+Undici provides an `install()` function to add fetch-related and other web API classes to `globalThis`, making them available globally without requiring imports.
 
 ## `install()`
 
-Install all WHATWG fetch classes globally on `globalThis`.
+Install undici's global web APIs on `globalThis`.
 
 **Example:**
 
 ```js
 import { install } from 'undici'
 
-// Install all WHATWG fetch classes globally  
+// Install undici's global web APIs
 install()
 
 // Now you can use fetch classes globally without importing
@@ -74,6 +74,8 @@ await fetch('https://example.com', {
 
 After `install()`, `fetch`, `Headers`, `Response`, `Request`, and `FormData`
 all come from the installed `undici` package, so they work as a matching set.
+`WebSocket`, `CloseEvent`, `ErrorEvent`, `MessageEvent`, and `EventSource`
+also come from the installed `undici` package.
 
 If you do not want to install globals, import both from `undici` instead:
 
@@ -135,5 +137,5 @@ test('fetch API test', async () => {
 
 - The `install()` function overwrites any existing global implementations
 - Classes installed are undici's implementations, not Node.js built-ins
-- This provides access to undici's latest features and performance improvements
-- The global installation persists for the lifetime of the process
\ No newline at end of file
+- This provides access to undici's latest fetch, WebSocket, and EventSource features and performance improvements
+- The global installation persists for the lifetime of the process
diff --git a/deps/undici/src/docs/docs/api/SnapshotAgent.md b/deps/undici/src/docs/docs/api/SnapshotAgent.md
index e4c8f2484a5408..1de74fb73f97c3 100644
--- a/deps/undici/src/docs/docs/api/SnapshotAgent.md
+++ b/deps/undici/src/docs/docs/api/SnapshotAgent.md
@@ -27,7 +27,9 @@ new SnapshotAgent([options])
   - **ignoreHeaders** `Array<String>` - Headers to ignore during request matching
   - **excludeHeaders** `Array<String>` - Headers to exclude from snapshots (for security)
   - **matchBody** `Boolean` - Whether to include request body in matching. Default: `true`
+  - **normalizeBody** `Function` - Optional function `(body) => string` to normalize the request body before matching (e.g. strip volatile fields like timestamps). Only used when `matchBody` is `true`.
   - **matchQuery** `Boolean` - Whether to include query parameters in matching. Default: `true`
+  - **normalizeQuery** `Function` - Optional function `(query: URLSearchParams) => string` to normalize query parameters before matching (e.g. strip volatile params like cache-busters). Only used when `matchQuery` is `true`.
   - **caseSensitive** `Boolean` - Whether header matching is case-sensitive. Default: `false`
   - **shouldRecord** `Function` - Callback to determine if a request should be recorded
   - **shouldPlayback** `Function` - Callback to determine if a request should be played back
@@ -108,6 +110,27 @@ await agent.saveSnapshots('./custom-snapshots.json')
 
 ## Advanced Configuration
 
+### Body Matching
+
+By default (`matchBody: true`) the full request body string is included in the snapshot key. Set it to `false` to ignore the body entirely, or use `normalizeBody` to strip volatile fields (like timestamps) before matching:
+
+```javascript
+const agent = new SnapshotAgent({
+  mode: 'playback',
+  snapshotPath: './snapshots.json',
+
+  // Match on everything except the timestamp field
+  normalizeBody: (body) => {
+    if (!body) return ''
+    const parsed = JSON.parse(String(body))
+    delete parsed.timestamp
+    return JSON.stringify(parsed)
+  }
+})
+```
+
+`normalizeBody` receives the raw body (`string | Buffer | null | undefined`) and must return a `string`. It runs at both record and playback time so the hash is consistent. Two requests match the same snapshot whenever their normalized strings are identical.
+
 ### Header Filtering
 
 Control which headers are used for request matching and what gets stored in snapshots:
diff --git a/deps/undici/src/lib/api/api-pipeline.js b/deps/undici/src/lib/api/api-pipeline.js
index 6e61710b90741a..6af3913440a490 100644
--- a/deps/undici/src/lib/api/api-pipeline.js
+++ b/deps/undici/src/lib/api/api-pipeline.js
@@ -13,6 +13,7 @@ const {
   RequestAbortedError
 } = require('../core/errors')
 const util = require('../core/util')
+const { kBodyUsed } = require('../core/symbols')
 const { addSignal, removeSignal } = require('./abort-signal')
 
 function noop () {}
@@ -24,6 +25,9 @@ class PipelineRequest extends Readable {
     super({ autoDestroy: true })
 
     this[kResume] = null
+    // Pipeline request bodies come from a live writable side and cannot be
+    // replayed across redirects or retries, even before any bytes are read.
+    this[kBodyUsed] = true
   }
 
   _read () {
diff --git a/deps/undici/src/lib/api/api-stream.js b/deps/undici/src/lib/api/api-stream.js
index 249d6774f6bea8..f111d70efc17cd 100644
--- a/deps/undici/src/lib/api/api-stream.js
+++ b/deps/undici/src/lib/api/api-stream.js
@@ -1,7 +1,6 @@
 'use strict'
 
 const assert = require('node:assert')
-const { finished } = require('node:stream')
 const { AsyncResource } = require('node:async_hooks')
 const { InvalidArgumentError, InvalidReturnValueError } = require('../core/errors')
 const util = require('../core/util')
@@ -9,6 +8,54 @@ const { addSignal, removeSignal } = require('./abort-signal')
 
 function noop () {}
 
+function getWritableError (stream) {
+  return stream.errored ?? stream.writableErrored ?? stream._writableState?.errored
+}
+
+function createPrematureCloseError () {
+  const err = new Error('Premature close')
+  err.code = 'ERR_STREAM_PREMATURE_CLOSE'
+  return err
+}
+
+function trackWritableLifecycle (stream, callback) {
+  let done = false
+
+  const cleanup = () => {
+    stream.removeListener('close', onClose)
+    stream.removeListener('error', onError)
+    stream.removeListener('finish', onFinish)
+  }
+
+  const finish = (err, fromErrorEvent = false) => {
+    if (done) {
+      return
+    }
+
+    done = true
+    cleanup()
+    callback(err, fromErrorEvent)
+  }
+
+  const onClose = () => {
+    const err = getWritableError(stream)
+    finish(err ?? (!stream.writableFinished ? createPrematureCloseError() : undefined))
+  }
+
+  const onError = (err) => finish(err, true)
+  const onFinish = () => finish()
+
+  stream.on('close', onClose)
+  stream.on('error', onError)
+  stream.on('finish', onFinish)
+
+  if (stream.closed) {
+    process.nextTick(onClose)
+  } else if (stream.writableFinished) {
+    process.nextTick(onFinish)
+  }
+}
+
 class StreamHandler extends AsyncResource {
   constructor (opts, factory, callback) {
     if (!opts || typeof opts !== 'object') {
@@ -117,20 +164,19 @@ class StreamHandler extends AsyncResource {
       throw new InvalidReturnValueError('expected Writable')
     }
 
-    // TODO: Avoid finished. It registers an unnecessary amount of listeners.
-    finished(res, { readable: false }, (err) => {
+    trackWritableLifecycle(res, (err, fromErrorEvent) => {
       const { callback, res, opaque, trailers, abort } = this
 
       this.res = null
       if (err || !res?.readable) {
-        util.destroy(res, err)
+        util.destroy(res, fromErrorEvent ? undefined : err)
       }
 
       this.callback = null
       this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
 
       if (err) {
-        abort()
+        abort(err)
       }
     })
 
diff --git a/deps/undici/src/lib/core/symbols.js b/deps/undici/src/lib/core/symbols.js
index ff37adc0448f1b..8bad25eed9fdb9 100644
--- a/deps/undici/src/lib/core/symbols.js
+++ b/deps/undici/src/lib/core/symbols.js
@@ -62,6 +62,7 @@ module.exports = {
   kListeners: Symbol('listeners'),
   kHTTPContext: Symbol('http context'),
   kMaxConcurrentStreams: Symbol('max concurrent streams'),
+  kHostAuthority: Symbol('host authority'),
   kHTTP2InitialWindowSize: Symbol('http2 initial window size'),
   kHTTP2ConnectionWindowSize: Symbol('http2 connection window size'),
   kEnableConnectProtocol: Symbol('http2session connect protocol'),
diff --git a/deps/undici/src/lib/core/util.js b/deps/undici/src/lib/core/util.js
index 54346a2567c2d2..98337c596c76c7 100644
--- a/deps/undici/src/lib/core/util.js
+++ b/deps/undici/src/lib/core/util.js
@@ -776,7 +776,7 @@ function isValidHeaderValue (characters) {
   return !headerCharRegex.test(characters)
 }
 
-const rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/
+const rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+|\*)?$/
 
 /**
  * @typedef {object} RangeHeader
@@ -799,7 +799,7 @@ function parseRangeHeader (range) {
     ? {
         start: parseInt(m[1]),
         end: m[2] ? parseInt(m[2]) : null,
-        size: m[3] ? parseInt(m[3]) : null
+        size: m[3] && m[3] !== '*' ? parseInt(m[3]) : null
       }
     : null
 }
diff --git a/deps/undici/src/lib/dispatcher/client-h1.js b/deps/undici/src/lib/dispatcher/client-h1.js
index f64d3f11324c7a..f1c52fb5f116ec 100644
--- a/deps/undici/src/lib/dispatcher/client-h1.js
+++ b/deps/undici/src/lib/dispatcher/client-h1.js
@@ -360,16 +360,7 @@ class Parser {
           this.paused = true
           socket.unshift(data)
         } else {
-          const ptr = llhttp.llhttp_get_error_reason(this.ptr)
-          let message = ''
-          if (ptr) {
-            const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
-            message =
-              'Response does not match the HTTP/1.1 protocol (' +
-              Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
-              ')'
-          }
-          throw new HTTPParserError(message, constants.ERROR[ret], data)
+          throw this.createError(ret, data)
         }
       }
     } catch (err) {
@@ -377,6 +368,54 @@ class Parser {
     }
   }
 
+  finish () {
+    assert(currentParser === null)
+    assert(this.ptr != null)
+    assert(!this.paused)
+
+    const { llhttp } = this
+
+    let ret
+
+    try {
+      currentParser = this
+      ret = llhttp.llhttp_finish(this.ptr)
+    } finally {
+      currentParser = null
+    }
+
+    if (ret === constants.ERROR.OK) {
+      return null
+    }
+
+    if (ret === constants.ERROR.PAUSED || ret === constants.ERROR.PAUSED_UPGRADE) {
+      this.paused = true
+      return null
+    }
+
+    return this.createError(ret, EMPTY_BUF)
+  }
+
+  createError (ret, data) {
+    const { llhttp, contentLength, bytesRead } = this
+
+    if (contentLength !== -1 && bytesRead !== contentLength) {
+      return new ResponseContentLengthMismatchError()
+    }
+
+    const ptr = llhttp.llhttp_get_error_reason(this.ptr)
+    let message = ''
+    if (ptr) {
+      const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
+      message =
+        'Response does not match the HTTP/1.1 protocol (' +
+        Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
+        ')'
+    }
+
+    return new HTTPParserError(message, constants.ERROR[ret], data)
+  }
+
   destroy () {
     assert(currentParser === null)
     assert(this.ptr != null)
@@ -888,8 +927,11 @@ function onHttpSocketError (err) {
   // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
   // to the user.
   if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
-    // We treat all incoming data so for as a valid response.
-    parser.onMessageComplete()
+    const parserErr = parser.finish()
+    if (parserErr) {
+      this[kError] = parserErr
+      this[kClient][kOnError](parserErr)
+    }
     return
   }
 
@@ -906,8 +948,10 @@ function onHttpSocketEnd () {
   const parser = this[kParser]
 
   if (parser.statusCode && !parser.shouldKeepAlive) {
-    // We treat all incoming data so far as a valid response.
-    parser.onMessageComplete()
+    const parserErr = parser.finish()
+    if (parserErr) {
+      util.destroy(this, parserErr)
+    }
     return
   }
 
@@ -919,8 +963,7 @@ function onHttpSocketClose () {
 
   if (parser) {
     if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-      // We treat all incoming data so far as a valid response.
-      parser.onMessageComplete()
+      this[kError] = parser.finish() || this[kError]
     }
 
     this[kParser].destroy()
@@ -1382,8 +1425,6 @@ function writeBuffer (abort, body, client, request, socket, contentLength, heade
  * @returns {Promise<void>}
  */
 async function writeBlob (abort, body, client, request, socket, contentLength, header, expectsPayload) {
-  assert(contentLength === body.size, 'blob body must have content length')
-
   try {
     if (contentLength != null && contentLength !== body.size) {
       throw new RequestContentLengthMismatchError()
diff --git a/deps/undici/src/lib/dispatcher/client-h2.js b/deps/undici/src/lib/dispatcher/client-h2.js
index b77013df98da46..ba9157cab5b145 100644
--- a/deps/undici/src/lib/dispatcher/client-h2.js
+++ b/deps/undici/src/lib/dispatcher/client-h2.js
@@ -28,6 +28,7 @@ const {
   kHTTP2Session,
   kHTTP2InitialWindowSize,
   kHTTP2ConnectionWindowSize,
+  kHostAuthority,
   kResume,
   kSize,
   kHTTPContext,
@@ -44,8 +45,7 @@ const kOpenStreams = Symbol('open streams')
 const kRequestStreamId = Symbol('request stream id')
 const kRequestStream = Symbol('request stream')
 const kRequestStreamCleanup = Symbol('request stream cleanup')
-const kRequestStreamOnData = Symbol('request stream on data')
-const kRequestStreamOnCloseError = Symbol('request stream on close error')
+const kRequestStreamState = Symbol('request stream state')
 const kReceivedGoAway = Symbol('received goaway')
 
 let extractBody
@@ -107,8 +107,9 @@ function detachRequestFromStream (request) {
 
 function bindRequestToStream (request, stream, cleanup) {
   const previousCleanup = request[kRequestStreamCleanup]
+  const previousStream = request[kRequestStream]
   detachRequestFromStream(request)
-  previousCleanup?.()
+  previousCleanup?.(previousStream)
   request[kRequestStreamId] = stream.id
   request[kRequestStream] = stream
   request[kRequestStreamCleanup] = cleanup
@@ -116,8 +117,9 @@ function bindRequestToStream (request, stream, cleanup) {
 
 function clearRequestStream (request) {
   const cleanup = request[kRequestStreamCleanup]
+  const stream = request[kRequestStream]
   detachRequestFromStream(request)
-  cleanup?.()
+  cleanup?.(stream)
 }
 
 function canRetryRequestAfterGoAway (request) {
@@ -516,20 +518,18 @@ function closeStreamSession (stream) {
 function onUpgradeStreamClose () {
   this.off('error', noop)
 
-  const failUpgradeStream = this[kRequestStreamOnCloseError]
-  this[kRequestStreamOnCloseError] = null
+  const state = this[kRequestStreamState]
+  this[kRequestStreamState] = null
 
-  failUpgradeStream(new InformationalError('HTTP/2: stream closed before response headers'))
+  failUpgradeStream(state, new InformationalError('HTTP/2: stream closed before response headers'))
   closeStreamSession(this)
 }
 
 function onRequestStreamClose () {
-  const onData = this[kRequestStreamOnData]
-
-  this[kRequestStreamOnData] = null
   this.off('data', onData)
   this.off('error', noop)
   closeStreamSession(this)
+  this[kRequestStreamState] = null
 }
 
 // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
@@ -537,25 +537,17 @@ function shouldSendContentLength (method) {
   return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
 }
 
-function writeH2 (client, request) {
-  const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout]
-  const session = client[kHTTP2Session]
-  const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request
-  let { body } = request
-
-  if (upgrade != null && upgrade !== 'websocket') {
-    util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`))
-    return false
-  }
-
+function buildRequestHeaders (reqHeaders) {
   const headers = {}
+
   for (let n = 0; n < reqHeaders.length; n += 2) {
     const key = reqHeaders[n + 0]
     const val = reqHeaders[n + 1]
+    const current = headers[key]
 
     if (key === 'cookie') {
-      if (headers[key] != null) {
-        headers[key] = Array.isArray(headers[key]) ? (headers[key].push(val), headers[key]) : [headers[key], val]
+      if (current != null) {
+        headers[key] = Array.isArray(current) ? (current.push(val), current) : [current, val]
       } else {
         headers[key] = val
       }
@@ -563,27 +555,140 @@ function writeH2 (client, request) {
       continue
     }
 
-    if (Array.isArray(val)) {
-      for (let i = 0; i < val.length; i++) {
-        if (headers[key]) {
-          headers[key] += `, ${val[i]}`
-        } else {
-          headers[key] = val[i]
-        }
-      }
-    } else if (headers[key]) {
-      headers[key] += `, ${val}`
-    } else {
-      headers[key] = val
+    if (typeof val === 'string') {
+      headers[key] = current ? `${current}, ${val}` : val
+      continue
     }
+
+    for (let i = 0; i < val.length; i++) {
+      headers[key] = headers[key] ? `${headers[key]}, ${val[i]}` : val[i]
+    }
+  }
+
+  return headers
+}
+
+function removeUpgradeStreamListeners (stream) {
+  stream.off('response', onUpgradeResponse)
+  stream.off('error', onUpgradeStreamError)
+  stream.off('end', onUpgradeStreamEnd)
+  stream.off('timeout', onUpgradeStreamTimeout)
+  stream.off('error', noop)
+}
+
+function releaseUpgradeStream (stream) {
+  if (stream == null) {
+    return
+  }
+
+  const state = stream[kRequestStreamState]
+  if (state == null) {
+    return
+  }
+
+  const { request } = state
+
+  if (request[kRequestStream] === stream) {
+    detachRequestFromStream(request)
+  }
+
+  removeUpgradeStreamListeners(stream)
+
+  if (!stream.destroyed && !stream.closed) {
+    stream.once('error', noop)
+  }
+}
+
+function failUpgradeStream (state, err) {
+  if (state == null) {
+    return
+  }
+
+  const { request } = state
+  if (state.responseReceived || request.aborted || request.completed) {
+    return
+  }
+
+  releaseUpgradeStream(state.stream)
+  state.abort(err, true)
+}
+
+function onUpgradeStreamError () {
+  const state = this[kRequestStreamState]
+
+  if (typeof this.rstCode === 'number' && this.rstCode !== 0) {
+    failUpgradeStream(state, new InformationalError(`HTTP/2: "stream error" received - code ${this.rstCode}`))
+  } else {
+    failUpgradeStream(state, new InformationalError('HTTP/2: stream errored before response headers'))
+  }
+}
+
+function onUpgradeStreamEnd () {
+  failUpgradeStream(this[kRequestStreamState], new InformationalError('HTTP/2: stream half-closed (remote)'))
+}
+
+function onUpgradeStreamTimeout () {
+  const state = this[kRequestStreamState]
+  failUpgradeStream(state, new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`))
+}
+
+function onUpgradeResponse (headers, _flags) {
+  const stream = this
+  const state = stream[kRequestStreamState]
+  const { request } = state
+
+  state.responseReceived = true
+
+  const statusCode = headers[HTTP2_HEADER_STATUS]
+  delete headers[HTTP2_HEADER_STATUS]
+
+  request.onRequestUpgrade(statusCode, headers, stream)
+
+  if (request.aborted || request.completed) {
+    return
   }
 
+  removeUpgradeStreamListeners(stream)
+  detachRequestFromStream(request)
+  state.finalizeRequest()
+}
+
+function setupUpgradeStream (stream, state) {
+  const { request, requestTimeout, session } = state
+
+  stream[kHTTP2Stream] = true
+  stream[kHTTP2Session] = session
+  stream[kRequestStreamState] = state
+  state.stream = stream
+
+  bindRequestToStream(request, stream, releaseUpgradeStream)
+  stream.once('response', onUpgradeResponse)
+  stream.on('error', onUpgradeStreamError)
+  stream.once('end', onUpgradeStreamEnd)
+  stream.on('timeout', onUpgradeStreamTimeout)
+  stream.once('close', onUpgradeStreamClose)
+
+  ++session[kOpenStreams]
+  stream.setTimeout(requestTimeout)
+}
+
+function writeH2 (client, request) {
+  const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout]
+  const session = client[kHTTP2Session]
+  const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request
+  let { body } = request
+
+  if (upgrade != null && upgrade !== 'websocket') {
+    util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`))
+    return false
+  }
+
+  const headers = buildRequestHeaders(reqHeaders)
+
   /** @type {import('node:http2').ClientHttp2Stream} */
   let stream = null
 
-  const { hostname, port } = client[kUrl]
-
-  headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}`
+  headers[HTTP2_HEADER_AUTHORITY] = host || client[kHostAuthority]
   headers[HTTP2_HEADER_METHOD] = method
 
   let requestFinalized = false
@@ -662,82 +767,14 @@ function writeH2 (client, request) {
   if (upgrade || method === 'CONNECT') {
     session.ref()
 
-    const setupUpgradeStream = (stream) => {
-      let responseReceived = false
-
-      const removeUpgradeStreamListeners = () => {
-        stream.off('response', onUpgradeResponse)
-        stream.off('error', onUpgradeStreamError)
-        stream.off('end', onUpgradeStreamEnd)
-        stream.off('timeout', onUpgradeStreamTimeout)
-        stream.off('error', noop)
-      }
-
-      const releaseUpgradeStream = () => {
-        if (request[kRequestStream] === stream) {
-          detachRequestFromStream(request)
-        }
-
-        removeUpgradeStreamListeners()
-
-        if (!stream.destroyed && !stream.closed) {
-          stream.once('error', noop)
-        }
-      }
-
-      const failUpgradeStream = (err) => {
-        if (responseReceived || request.aborted || request.completed) {
-          return
-        }
-
-        releaseUpgradeStream()
-        abort(err, true)
-      }
-
-      const onUpgradeStreamError = () => {
-        if (typeof stream.rstCode === 'number' && stream.rstCode !== 0) {
-          failUpgradeStream(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`))
-        } else {
-          failUpgradeStream(new InformationalError('HTTP/2: stream errored before response headers'))
-        }
-      }
-
-      const onUpgradeStreamEnd = () => {
-        failUpgradeStream(new InformationalError('HTTP/2: stream half-closed (remote)'))
-      }
-
-      const onUpgradeStreamTimeout = () => {
-        failUpgradeStream(new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`))
-      }
-
-      const onUpgradeResponse = (headers, _flags) => {
-        responseReceived = true
-
-        const statusCode = headers[HTTP2_HEADER_STATUS]
-        delete headers[HTTP2_HEADER_STATUS]
-
-        request.onRequestUpgrade(statusCode, headers, stream)
-
-        if (request.aborted || request.completed) {
-          return
-        }
-
-        removeUpgradeStreamListeners()
-        detachRequestFromStream(request)
-        finalizeRequest()
-      }
-
-      bindRequestToStream(request, stream, releaseUpgradeStream)
-      stream.once('response', onUpgradeResponse)
-      stream.on('error', onUpgradeStreamError)
-      stream.once('end', onUpgradeStreamEnd)
-      stream.on('timeout', onUpgradeStreamTimeout)
-      stream[kHTTP2Session] = session
-      stream[kRequestStreamOnCloseError] = failUpgradeStream
-      stream.once('close', onUpgradeStreamClose)
-
-      ++session[kOpenStreams]
-      stream.setTimeout(requestTimeout)
+    const upgradeState = {
+      abort,
+      finalizeRequest,
+      request,
+      requestTimeout,
+      responseReceived: false,
+      session,
+      stream: null
     }
 
     if (upgrade === 'websocket') {
@@ -767,8 +804,7 @@ function writeH2 (client, request) {
         session.unref()
         return false
       }
-      stream[kHTTP2Stream] = true
-      setupUpgradeStream(stream)
+      setupUpgradeStream(stream, upgradeState)
       return true
     }
 
@@ -782,8 +818,7 @@ function writeH2 (client, request) {
       session.unref()
       return false
     }
-    stream[kHTTP2Stream] = true
-    setupUpgradeStream(stream)
+    setupUpgradeStream(stream, upgradeState)
 
     return true
   }
@@ -805,7 +840,10 @@ function writeH2 (client, request) {
   const expectsPayload = (
     method === 'PUT' ||
     method === 'POST' ||
-    method === 'PATCH'
+    method === 'PATCH' ||
+    method === 'QUERY' ||
+    method === 'PROPFIND' ||
+    method === 'PROPPATCH'
   )
 
   if (body && typeof body.read === 'function') {
@@ -865,230 +903,251 @@ function writeH2 (client, request) {
   }
 
   // TODO(metcoder95): add support for sending trailers
-  const shouldEndStream = body === null
+  const shouldEndStream = body === null || contentLength === 0
+  const state = {
+    abort,
+    body,
+    client,
+    contentLength,
+    expectsPayload,
+    finalizeRequest,
+    request,
+    requestTimeout,
+    responseReceived: false,
+    session,
+    stream: null
+  }
+
   if (expectContinue) {
     headers[HTTP2_HEADER_EXPECT] = '100-continue'
-    stream = requestStream(headers, { endStream: shouldEndStream, signal })
-    if (stream == null) {
-      return false
-    }
-    stream[kHTTP2Stream] = true
-    bindRequestToStream(request, stream, null)
-  } else {
-    stream = requestStream(headers, {
-      endStream: shouldEndStream,
-      signal
-    })
-    if (stream == null) {
-      return false
-    }
-    stream[kHTTP2Stream] = true
-    bindRequestToStream(request, stream, null)
   }
 
+  stream = requestStream(headers, { endStream: shouldEndStream, signal })
+  if (stream == null) {
+    return false
+  }
+  stream[kHTTP2Stream] = true
+  stream[kRequestStreamState] = state
+  state.stream = stream
+  bindRequestToStream(request, stream, null)
+
   // Increment counter as we have new streams open
   ++session[kOpenStreams]
   stream.setTimeout(requestTimeout)
 
-  // Track whether we received a response (headers)
-  let responseReceived = false
-  const onData = (chunk) => {
-    if (request.aborted || request.completed) {
-      return
-    }
+  stream[kHTTP2Session] = session
+  stream.once('close', onRequestStreamClose)
 
-    if (request.onResponseData(chunk) === false) {
-      stream.pause()
-    }
+  bindRequestToStream(request, stream, releaseRequestStream)
+  if (expectContinue) {
+    stream.once('continue', writeBodyH2)
   }
+  stream.once('response', onResponse)
+  stream.once('end', onEnd)
+  stream.once('error', onError)
+  stream.once('frameError', onFrameError)
+  stream.on('aborted', onAborted)
+  stream.on('timeout', onTimeout)
+  stream.once('trailers', onTrailers)
 
-  const removeRequestStreamListeners = () => {
-    stream.off('error', noop)
-    stream.off('continue', writeBodyH2)
-    stream.off('response', onResponse)
-    stream.off('end', onEnd)
-    stream.off('error', onError)
-    stream.off('frameError', onFrameError)
-    stream.off('aborted', onAborted)
-    stream.off('timeout', onTimeout)
-    stream.off('trailers', onTrailers)
-    stream.off('data', onData)
+  if (!expectContinue) {
+    writeBodyH2.call(stream)
   }
 
-  const releaseRequestStream = () => {
-    if (request[kRequestStream] === stream) {
-      detachRequestFromStream(request)
-    }
+  return true
+}
 
-    removeRequestStreamListeners()
+function removeRequestStreamListeners (stream) {
+  stream.off('error', noop)
+  stream.off('continue', writeBodyH2)
+  stream.off('response', onResponse)
+  stream.off('end', onEnd)
+  stream.off('error', onError)
+  stream.off('frameError', onFrameError)
+  stream.off('aborted', onAborted)
+  stream.off('timeout', onTimeout)
+  stream.off('trailers', onTrailers)
+  stream.off('data', onData)
+}
 
-    if (!stream.destroyed && !stream.closed) {
-      stream.once('error', noop)
-    }
+function releaseRequestStream (stream) {
+  if (stream == null) {
+    return
   }
 
-  const onResponse = (headers) => {
-    stream.off('response', onResponse)
+  const state = stream[kRequestStreamState]
+  if (state == null) {
+    return
+  }
 
-    const statusCode = headers[HTTP2_HEADER_STATUS]
-    delete headers[HTTP2_HEADER_STATUS]
-    request.onResponseStarted()
-    responseReceived = true
+  const { request } = state
 
-    // Due to the stream nature, it is possible we face a race condition
-    // where the stream has been assigned, but the request has been aborted
-    // the request remains in-flight and headers hasn't been received yet
-    // for those scenarios, best effort is to destroy the stream immediately
-    // as there's no value to keep it open.
-    if (request.aborted) {
-      releaseRequestStream()
-      return
-    }
+  if (request[kRequestStream] === stream) {
+    detachRequestFromStream(request)
+  }
 
-    if (request.onResponseStart(Number(statusCode), headers, stream.resume.bind(stream), '') === false) {
-      stream.pause()
-    }
+  removeRequestStreamListeners(stream)
 
-    stream.on('data', onData)
+  if (!stream.destroyed && !stream.closed) {
+    stream.once('error', noop)
   }
+}
 
-  const onEnd = () => {
-    stream.off('end', onEnd)
-
-    releaseRequestStream()
-    // If we received a response, this is a normal completion
-    if (responseReceived) {
-      if (!request.aborted && !request.completed) {
-        request.onResponseEnd({})
-      }
+function onData (chunk) {
+  const stream = this
+  const { request } = stream[kRequestStreamState]
 
-      finalizeRequest()
-    } else {
-      // Stream ended without receiving a response - this is an error
-      // (e.g., server destroyed the stream before sending headers)
-      abort(new InformationalError('HTTP/2: stream half-closed (remote)'), true)
-    }
+  if (request.aborted || request.completed) {
+    return
   }
 
-  stream[kHTTP2Session] = session
-  stream[kRequestStreamOnData] = onData
-  stream.once('close', onRequestStreamClose)
+  if (request.onResponseData(chunk) === false) {
+    stream.pause()
+  }
+}
 
-  const onError = function (err) {
-    stream.off('error', onError)
+function onResponse (headers) {
+  const stream = this
+  const state = stream[kRequestStreamState]
+  const { request } = state
 
-    releaseRequestStream()
-    abort(err)
-  }
+  stream.off('response', onResponse)
 
-  const onFrameError = (type, code) => {
-    stream.off('frameError', onFrameError)
+  const statusCode = headers[HTTP2_HEADER_STATUS]
+  delete headers[HTTP2_HEADER_STATUS]
+  request.onResponseStarted()
+  state.responseReceived = true
 
-    releaseRequestStream()
-    abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
+  // Due to the stream nature, it is possible we face a race condition
+  // where the stream has been assigned, but the request has been aborted
+  // the request remains in-flight and headers hasn't been received yet
+  // for those scenarios, best effort is to destroy the stream immediately
+  // as there's no value to keep it open.
+  if (request.aborted) {
+    releaseRequestStream(stream)
+    return
   }
 
-  const onAborted = () => {
-    stream.off('data', onData)
+  if (request.onResponseStart(Number(statusCode), headers, stream.resume.bind(stream), '') === false) {
+    stream.pause()
   }
 
-  const onTimeout = () => {
-    releaseRequestStream()
+  stream.on('data', onData)
+}
 
-    const err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`)
-    abort(err)
-  }
+function onEnd () {
+  const stream = this
+  const state = stream[kRequestStreamState]
+  const { request } = state
 
-  const onTrailers = (trailers) => {
-    stream.off('trailers', onTrailers)
+  stream.off('end', onEnd)
 
-    if (request.aborted || request.completed) {
-      return
+  releaseRequestStream(stream)
+  // If we received a response, this is a normal completion
+  if (state.responseReceived) {
+    if (!request.aborted && !request.completed) {
+      request.onResponseEnd({})
     }
 
-    releaseRequestStream()
-    request.onResponseEnd(trailers)
-    finalizeRequest()
+    state.finalizeRequest()
+  } else {
+    // Stream ended without receiving a response - this is an error
+    // (e.g., server destroyed the stream before sending headers)
+    state.abort(new InformationalError('HTTP/2: stream half-closed (remote)'), true)
   }
+}
 
-  bindRequestToStream(request, stream, releaseRequestStream)
-  if (expectContinue) {
-    stream.once('continue', writeBodyH2)
-  }
-  stream.once('response', onResponse)
-  stream.once('end', onEnd)
-  stream.once('error', onError)
-  stream.once('frameError', onFrameError)
-  stream.on('aborted', onAborted)
-  stream.on('timeout', onTimeout)
-  stream.once('trailers', onTrailers)
+function onError (err) {
+  const stream = this
+  const state = stream[kRequestStreamState]
 
-  if (!expectContinue) {
-    writeBodyH2()
+  stream.off('error', onError)
+
+  releaseRequestStream(stream)
+  state.abort(err)
+}
+
+function onFrameError (type, code) {
+  const stream = this
+  const state = stream[kRequestStreamState]
+
+  stream.off('frameError', onFrameError)
+
+  releaseRequestStream(stream)
+  state.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
+}
+
+function onAborted () {
+  this.off('data', onData)
+}
+
+function onTimeout () {
+  const stream = this
+  const state = stream[kRequestStreamState]
+
+  releaseRequestStream(stream)
+
+  const err = new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`)
+  state.abort(err)
+}
+
+function onTrailers (trailers) {
+  const stream = this
+  const state = stream[kRequestStreamState]
+  const { request } = state
+
+  stream.off('trailers', onTrailers)
+
+  if (request.aborted || request.completed) {
+    return
   }
 
-  return true
+  releaseRequestStream(stream)
+  request.onResponseEnd(trailers)
+  state.finalizeRequest()
+}
 
-  function writeBodyH2 () {
-    if (!body || contentLength === 0) {
-      writeBuffer(
-        abort,
-        stream,
-        null,
-        client,
-        request,
-        client[kSocket],
-        contentLength,
-        expectsPayload
-      )
-    } else if (util.isBuffer(body)) {
-      writeBuffer(
+function writeBodyH2 () {
+  const stream = this
+  const state = stream[kRequestStreamState]
+  const { abort, body, client, contentLength, expectsPayload, request } = state
+
+  if (!body || contentLength === 0) {
+    writeBuffer(
+      abort,
+      stream,
+      null,
+      client,
+      request,
+      client[kSocket],
+      contentLength,
+      expectsPayload
+    )
+  } else if (util.isBuffer(body)) {
+    writeBuffer(
+      abort,
+      stream,
+      body,
+      client,
+      request,
+      client[kSocket],
+      contentLength,
+      expectsPayload
+    )
+  } else if (util.isBlobLike(body)) {
+    if (typeof body.stream === 'function') {
+      writeIterable(
         abort,
         stream,
-        body,
+        body.stream(),
         client,
         request,
         client[kSocket],
         contentLength,
         expectsPayload
       )
-    } else if (util.isBlobLike(body)) {
-      if (typeof body.stream === 'function') {
-        writeIterable(
-          abort,
-          stream,
-          body.stream(),
-          client,
-          request,
-          client[kSocket],
-          contentLength,
-          expectsPayload
-        )
-      } else {
-        writeBlob(
-          abort,
-          stream,
-          body,
-          client,
-          request,
-          client[kSocket],
-          contentLength,
-          expectsPayload
-        )
-      }
-    } else if (util.isStream(body)) {
-      writeStream(
-        abort,
-        client[kSocket],
-        expectsPayload,
-        stream,
-        body,
-        client,
-        request,
-        contentLength
-      )
-    } else if (util.isIterable(body)) {
-      writeIterable(
+    } else {
+      writeBlob(
         abort,
         stream,
         body,
@@ -1098,9 +1157,31 @@ function writeH2 (client, request) {
         contentLength,
         expectsPayload
       )
-    } else {
-      assert(false)
     }
+  } else if (util.isStream(body)) {
+    writeStream(
+      abort,
+      client[kSocket],
+      expectsPayload,
+      stream,
+      body,
+      client,
+      request,
+      contentLength
+    )
+  } else if (util.isIterable(body)) {
+    writeIterable(
+      abort,
+      stream,
+      body,
+      client,
+      request,
+      client[kSocket],
+      contentLength,
+      expectsPayload
+    )
+  } else {
+    assert(false)
   }
 }
 
@@ -1159,8 +1240,6 @@ function writeStream (abort, socket, expectsPayload, h2stream, body, client, req
 }
 
 async function writeBlob (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
-  assert(contentLength === body.size, 'blob body must have content length')
-
   try {
     if (contentLength != null && contentLength !== body.size) {
       throw new RequestContentLengthMismatchError()
diff --git a/deps/undici/src/lib/dispatcher/client.js b/deps/undici/src/lib/dispatcher/client.js
index 6ef97ba0a369a9..c2195f3dd37503 100644
--- a/deps/undici/src/lib/dispatcher/client.js
+++ b/deps/undici/src/lib/dispatcher/client.js
@@ -52,6 +52,7 @@ const {
   kOnError,
   kHTTPContext,
   kMaxConcurrentStreams,
+  kHostAuthority,
   kHTTP2InitialWindowSize,
   kHTTP2ConnectionWindowSize,
   kResume,
@@ -246,6 +247,7 @@ class Client extends DispatcherBase {
     }
 
     this[kUrl] = util.parseOrigin(url)
+    this[kHostAuthority] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}`
     this[kConnector] = connect
     this[kPipelining] = pipelining != null ? pipelining : 1
     this[kMaxHeadersSize] = maxHeaderSize
@@ -257,7 +259,7 @@ class Client extends DispatcherBase {
     this[kLocalAddress] = localAddress != null ? localAddress : null
     this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
     this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
-    this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
+    this[kHostHeader] = `host: ${this[kHostAuthority]}\r\n`
     this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3
     this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3
     this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength
diff --git a/deps/undici/src/lib/dispatcher/pool-base.js b/deps/undici/src/lib/dispatcher/pool-base.js
index 1395cd7f2772ec..c8a91d42ba5254 100644
--- a/deps/undici/src/lib/dispatcher/pool-base.js
+++ b/deps/undici/src/lib/dispatcher/pool-base.js
@@ -14,6 +14,7 @@ const kOnConnect = Symbol('onConnect')
 const kOnDisconnect = Symbol('onDisconnect')
 const kOnConnectionError = Symbol('onConnectionError')
 const kGetDispatcher = Symbol('get dispatcher')
+const kHasDispatcher = Symbol('has dispatcher')
 const kAddClient = Symbol('add client')
 const kRemoveClient = Symbol('remove client')
 
@@ -162,12 +163,28 @@ class PoolBase extends DispatcherBase {
       this[kQueued]++
     } else if (!dispatcher.dispatch(opts, handler)) {
       dispatcher[kNeedDrain] = true
-      this[kNeedDrain] = !this[kGetDispatcher]()
+      this[kNeedDrain] = !this[kHasDispatcher]()
     }
 
     return !this[kNeedDrain]
   }
 
+  [kHasDispatcher] () {
+    for (let i = 0; i < this[kClients].length; i++) {
+      const dispatcher = this[kClients][i]
+
+      if (
+        !dispatcher[kNeedDrain] &&
+        dispatcher.closed !== true &&
+        dispatcher.destroyed !== true
+      ) {
+        return true
+      }
+    }
+
+    return false
+  }
+
   [kAddClient] (client) {
     client
       .on('drain', this[kOnDrain].bind(this, client))
@@ -196,7 +213,7 @@ class PoolBase extends DispatcherBase {
 
     client.close(() => {})
 
-    this[kNeedDrain] = this[kClients].some(dispatcher => (
+    this[kNeedDrain] = !this[kClients].some(dispatcher => (
       !dispatcher[kNeedDrain] &&
       dispatcher.closed !== true &&
       dispatcher.destroyed !== true
@@ -210,5 +227,6 @@ module.exports = {
   kNeedDrain,
   kAddClient,
   kRemoveClient,
-  kGetDispatcher
+  kGetDispatcher,
+  kHasDispatcher
 }
diff --git a/deps/undici/src/lib/dispatcher/pool.js b/deps/undici/src/lib/dispatcher/pool.js
index f5898b02b3551c..39bf7403236698 100644
--- a/deps/undici/src/lib/dispatcher/pool.js
+++ b/deps/undici/src/lib/dispatcher/pool.js
@@ -6,6 +6,7 @@ const {
   kNeedDrain,
   kAddClient,
   kGetDispatcher,
+  kHasDispatcher,
   kRemoveClient
 } = require('./pool-base')
 const Client = require('./client')
@@ -115,6 +116,28 @@ class Pool extends PoolBase {
       return dispatcher
     }
   }
+
+  [kHasDispatcher] () {
+    const clientTtlOption = this[kOptions].clientTtl
+    for (let i = 0; i < this[kClients].length; i++) {
+      const client = this[kClients][i]
+
+      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
+        this[kRemoveClient](client)
+        i--
+      } else if (!client[kNeedDrain]) {
+        return true
+      }
+    }
+
+    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
+      this[kAddClient](dispatcher)
+      return true
+    }
+
+    return false
+  }
 }
 
 module.exports = Pool
diff --git a/deps/undici/src/lib/dispatcher/proxy-agent.js b/deps/undici/src/lib/dispatcher/proxy-agent.js
index b89b88bde969d2..8522bdd586d1b7 100644
--- a/deps/undici/src/lib/dispatcher/proxy-agent.js
+++ b/deps/undici/src/lib/dispatcher/proxy-agent.js
@@ -18,6 +18,7 @@ const kProxyTls = Symbol('proxy tls settings')
 const kConnectEndpoint = Symbol('connect endpoint function')
 const kConnectEndpointHTTP1 = Symbol('connect endpoint function (http/1.1 only)')
 const kTunnelProxy = Symbol('tunnel proxy')
+const proxyAuthorization = 'proxy-authorization'
 
 function defaultProtocolPort (protocol) {
   return protocol === 'https:' ? 443 : 80
@@ -298,6 +299,10 @@ function buildHeaders (headers) {
     const headersPair = {}
 
     for (let i = 0; i < headers.length; i += 2) {
+      if (isProxyAuthorizationHeader(headers[i])) {
+        throwProxyAuthError()
+      }
+
       headersPair[headers[i]] = headers[i + 1]
     }
 
@@ -316,11 +321,23 @@ function buildHeaders (headers) {
  * It should be removed in the next major version for performance reasons
  */
 function throwIfProxyAuthIsSent (headers) {
-  const existProxyAuth = headers && Object.keys(headers)
-    .find((key) => key.toLowerCase() === 'proxy-authorization')
-  if (existProxyAuth) {
-    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
+  for (const key in headers) {
+    if (isProxyAuthorizationHeader(key)) {
+      throwProxyAuthError()
+    }
   }
 }
 
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isProxyAuthorizationHeader (key) {
+  return key.length === proxyAuthorization.length && key.toLowerCase() === proxyAuthorization
+}
+
+function throwProxyAuthError () {
+  throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
+}
+
 module.exports = ProxyAgent
diff --git a/deps/undici/src/lib/dispatcher/round-robin-pool.js b/deps/undici/src/lib/dispatcher/round-robin-pool.js
index 17daea7a4a3274..b1f4763530f5a2 100644
--- a/deps/undici/src/lib/dispatcher/round-robin-pool.js
+++ b/deps/undici/src/lib/dispatcher/round-robin-pool.js
@@ -6,6 +6,7 @@ const {
   kNeedDrain,
   kAddClient,
   kGetDispatcher,
+  kHasDispatcher,
   kRemoveClient
 } = require('./pool-base')
 const Client = require('./client')
@@ -128,6 +129,31 @@ class RoundRobinPool extends PoolBase {
       return dispatcher
     }
   }
+
+  [kHasDispatcher] () {
+    const clientTtlOption = this[kOptions].clientTtl
+    for (let i = 0; i < this[kClients].length; i++) {
+      const client = this[kClients][i]
+
+      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
+        this[kRemoveClient](client)
+        if (i <= this[kIndex]) {
+          this[kIndex]--
+        }
+        i--
+      } else if (!client[kNeedDrain]) {
+        return true
+      }
+    }
+
+    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
+      this[kAddClient](dispatcher)
+      return true
+    }
+
+    return false
+  }
 }
 
 module.exports = RoundRobinPool
diff --git a/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js b/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js
index c0b681929ac499..3cc5b19f0be214 100644
--- a/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js
+++ b/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js
@@ -1,6 +1,5 @@
 'use strict'
 
-const net = require('node:net')
 const { URL } = require('node:url')
 
 let tls // include tls conditionally since it is not always available
@@ -17,6 +16,7 @@ const debug = debuglog('undici:socks5-proxy')
 const kProxyUrl = Symbol('proxy url')
 const kProxyHeaders = Symbol('proxy headers')
 const kProxyAuth = Symbol('proxy auth')
+const kProxyProtocol = Symbol('proxy protocol')
 const kPools = Symbol('pools')
 const kConnector = Symbol('connector')
 
@@ -52,6 +52,7 @@ class Socks5ProxyAgent extends DispatcherBase {
 
     this[kProxyUrl] = url
     this[kProxyHeaders] = options.headers || {}
+    this[kProxyProtocol] = options.proxyTls ? 'https:' : 'http:'
 
     // Extract auth from URL or options
     this[kProxyAuth] = {
@@ -81,25 +82,20 @@ class Socks5ProxyAgent extends DispatcherBase {
     // Connect to the SOCKS5 proxy
     const socketReady = Promise.withResolvers()
 
-    const onSocketConnect = () => {
-      socket.removeListener('error', onSocketError)
-      socketReady.resolve(socket)
-    }
-
-    const onSocketError = (err) => {
-      socket.removeListener('connect', onSocketConnect)
-      socketReady.reject(err)
-    }
-
-    const socket = net.connect({
+    this[kConnector]({
+      hostname: proxyHost,
       host: proxyHost,
-      port: proxyPort
+      port: proxyPort,
+      protocol: this[kProxyProtocol]
+    }, (err, socket) => {
+      if (err) {
+        socketReady.reject(err)
+      } else {
+        socketReady.resolve(socket)
+      }
     })
 
-    socket.once('connect', onSocketConnect)
-    socket.once('error', onSocketError)
-
-    await socketReady.promise
+    const socket = await socketReady.promise
 
     // Create SOCKS5 client
     const socks5Client = new Socks5Client(socket, this[kProxyAuth])
@@ -177,7 +173,7 @@ class Socks5ProxyAgent extends DispatcherBase {
   /**
    * Dispatch a request through the SOCKS5 proxy
    */
-  async [kDispatch] (opts, handler) {
+  [kDispatch] (opts, handler) {
     const { origin } = opts
 
     debug('dispatching request to', origin, 'via SOCKS5')
@@ -234,8 +230,12 @@ class Socks5ProxyAgent extends DispatcherBase {
       return pool[kDispatch](opts, handler)
     } catch (err) {
       debug('dispatch error:', err)
-      if (typeof handler.onError === 'function') {
+      if (typeof handler.onResponseError === 'function') {
+        handler.onResponseError(null, err)
+        return false
+      } else if (typeof handler.onError === 'function') {
         handler.onError(err)
+        return false
       } else {
         throw err
       }
diff --git a/deps/undici/src/lib/handler/retry-handler.js b/deps/undici/src/lib/handler/retry-handler.js
index ee2f69a2043e69..7ec506e21ebf5b 100644
--- a/deps/undici/src/lib/handler/retry-handler.js
+++ b/deps/undici/src/lib/handler/retry-handler.js
@@ -68,6 +68,8 @@ class RetryHandler {
     this.start = 0
     this.end = null
     this.etag = null
+    this.statusCode = null
+    this.headers = null
   }
 
   onResponseStartWithRetry (controller, statusCode, headers, statusMessage, err) {
@@ -183,6 +185,8 @@ class RetryHandler {
   onResponseStart (controller, statusCode, headers, statusMessage) {
     this.error = null
     this.retryCount += 1
+    this.statusCode = statusCode
+    this.headers = headers
 
     if (statusCode >= 300) {
       const err = new RequestRetryError('Request failed', statusCode, {
@@ -320,6 +324,16 @@ class RetryHandler {
     }
 
     if (!this.error) {
+      // Verify that the received body length matches the expected range
+      // when we have a finite end position (from Content-Length or Content-Range)
+      if (this.end != null && Number.isFinite(this.end)) {
+        if (this.start !== this.end + 1) {
+          throw new RequestRetryError('Content-Range mismatch', this.statusCode, {
+            headers: this.headers,
+            data: { count: this.retryCount }
+          })
+        }
+      }
       this.retryCount = 0
       return this.handler.onResponseEnd?.(controller, trailers)
     }
diff --git a/deps/undici/src/lib/llhttp/wasm_build_env.txt b/deps/undici/src/lib/llhttp/wasm_build_env.txt
index 7440bdcb1b3820..3ba57f70d8d37e 100644
--- a/deps/undici/src/lib/llhttp/wasm_build_env.txt
+++ b/deps/undici/src/lib/llhttp/wasm_build_env.txt
@@ -1,5 +1,5 @@
 
-> undici@8.2.0 build:wasm
+> undici@8.3.0 build:wasm
 > node build/wasm.js --docker
 
 > docker run --rm --platform=linux/x86_64  --user 1001:1001 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/build/lib/llhttp            --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/build,target=/home/node/build/build            --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/deps,target=/home/node/build/deps            -t ghcr.io/nodejs/wasm-builder@sha256:975f391d907e42a75b8c72eb77c782181e941608687d4d8694c3e9df415a0970 node build/wasm.js
diff --git a/deps/undici/src/lib/mock/mock-utils.js b/deps/undici/src/lib/mock/mock-utils.js
index 1022405d239aff..5b6b5bd79cfa56 100644
--- a/deps/undici/src/lib/mock/mock-utils.js
+++ b/deps/undici/src/lib/mock/mock-utils.js
@@ -424,7 +424,9 @@ function buildMockDispatch () {
             throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)${interceptsMessage}`)
           }
           if (checkNetConnect(netConnect, origin)) {
-            originalDispatch.call(this, opts, handler)
+            originalDispatch.call(this, '__mockAgentBodyForDispatch' in opts
+              ? { ...opts, body: opts.__mockAgentBodyForDispatch }
+              : opts, handler)
           } else {
             throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)${interceptsMessage}`)
           }
diff --git a/deps/undici/src/lib/mock/snapshot-agent.js b/deps/undici/src/lib/mock/snapshot-agent.js
index a3aee68cb2db0f..362745c414c158 100644
--- a/deps/undici/src/lib/mock/snapshot-agent.js
+++ b/deps/undici/src/lib/mock/snapshot-agent.js
@@ -55,7 +55,9 @@ class SnapshotAgent extends MockAgent {
       ignoreHeaders: opts.ignoreHeaders,
       excludeHeaders: opts.excludeHeaders,
       matchBody: opts.matchBody,
+      normalizeBody: opts.normalizeBody,
       matchQuery: opts.matchQuery,
+      normalizeQuery: opts.normalizeQuery,
       caseSensitive: opts.caseSensitive,
       shouldRecord: opts.shouldRecord,
       shouldPlayback: opts.shouldPlayback,
diff --git a/deps/undici/src/lib/mock/snapshot-recorder.js b/deps/undici/src/lib/mock/snapshot-recorder.js
index b5d07fae381cd2..57a7e7a41dd0dd 100644
--- a/deps/undici/src/lib/mock/snapshot-recorder.js
+++ b/deps/undici/src/lib/mock/snapshot-recorder.js
@@ -46,7 +46,9 @@ const { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } =
  * @property {Array<string>} [ignoreHeaders=[]] - Headers to ignore for matching
  * @property {Array<string>} [excludeHeaders=[]] - Headers to exclude from matching
  * @property {boolean} [matchBody=true] - Whether to match request body
- * @property {boolean} [matchQuery=true] - Whether to match query properties
+ * @property {(body: string|Buffer|null|undefined) => string} [normalizeBody] - Function to normalize the body before matching (e.g. strip timestamps)
+ * @property {boolean} [matchQuery=true] - Whether to match query parameters
+ * @property {(query: URLSearchParams) => string} [normalizeQuery] - Function to normalize query parameters before matching (e.g. strip volatile params)
  * @property {boolean} [caseSensitive=false] - Whether header matching is case-sensitive
  */
 
@@ -79,6 +81,37 @@ const { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } =
  * @property {string} timestamp - ISO timestamp of when the snapshot was created
  */
 
+/**
+ * Normalizes the URL string used for request matching.
+ *
+ * @param {URL} url - Parsed request URL
+ * @param {boolean} matchQuery - Whether to include query parameters in matching
+ * @param {((query: URLSearchParams) => string)|undefined} normalizeQuery - Optional normalization function
+ * @returns {string} - URL string for hashing
+ */
+function normalizeUrlForMatching (url, matchQuery, normalizeQuery) {
+  if (matchQuery === false) return `${url.origin}${url.pathname}`
+  if (normalizeQuery) {
+    const normalized = String(normalizeQuery(url.searchParams) ?? '')
+    return normalized ? `${url.origin}${url.pathname}?${normalized}` : `${url.origin}${url.pathname}`
+  }
+  return url.toString()
+}
+
+/**
+ * Normalizes the body value used for request matching.
+ *
+ * @param {string|Buffer|null|undefined} body - Raw request body
+ * @param {boolean} matchBody - Whether to include the body in matching
+ * @param {((body: string|Buffer|null|undefined) => string)|undefined} normalizeBody - Optional normalization function
+ * @returns {string} - Body string for hashing
+ */
+function normalizeBodyForMatching (body, matchBody, normalizeBody) {
+  if (matchBody === false) return ''
+  if (normalizeBody) return String(normalizeBody(body) ?? '')
+  return body ? String(body) : ''
+}
+
 /**
  * Formats a request for consistent snapshot storage
  * Caches normalized headers to avoid repeated processing
@@ -99,9 +132,9 @@ function formatRequestKey (opts, headerFilters, matchOptions = {}) {
 
   return {
     method: opts.method || 'GET',
-    url: matchOptions.matchQuery !== false ? url.toString() : `${url.origin}${url.pathname}`,
+    url: normalizeUrlForMatching(url, matchOptions.matchQuery, matchOptions.normalizeQuery),
     headers: filterHeadersForMatching(normalized, headerFilters, matchOptions),
-    body: matchOptions.matchBody !== false && opts.body ? String(opts.body) : ''
+    body: normalizeBodyForMatching(opts.body, matchOptions.matchBody, matchOptions.normalizeBody)
   }
 }
 
@@ -250,7 +283,9 @@ class SnapshotRecorder {
       ignoreHeaders: options.ignoreHeaders || [],
       excludeHeaders: options.excludeHeaders || [],
       matchBody: options.matchBody !== false, // default: true
+      normalizeBody: options.normalizeBody || undefined,
       matchQuery: options.matchQuery !== false, // default: true
+      normalizeQuery: options.normalizeQuery || undefined,
       caseSensitive: options.caseSensitive || false
     }
 
diff --git a/deps/undici/src/lib/web/fetch/body.js b/deps/undici/src/lib/web/fetch/body.js
index 7e08b29fd6c9e9..525bafb2c3c56e 100644
--- a/deps/undici/src/lib/web/fetch/body.js
+++ b/deps/undici/src/lib/web/fetch/body.js
@@ -7,7 +7,7 @@ const {
   fullyReadBody,
   extractMimeType
 } = require('./util')
-const { FormData, setFormDataState } = require('./formdata')
+const { FormData, setFormDataState, getFormDataBoundary } = require('./formdata')
 const { webidl } = require('../webidl')
 const assert = require('node:assert')
 const { isErrored, isDisturbed } = require('node:stream')
@@ -16,11 +16,6 @@ const { serializeAMimeType } = require('./data-url')
 const { multipartFormDataParser } = require('./formdata-parser')
 const { parseJSONFromBytes } = require('../infra')
 const { utf8DecodeBytes } = require('../../encoding')
-const { runtimeFeatures } = require('../../util/runtime-features.js')
-
-const random = runtimeFeatures.has('crypto')
-  ? require('node:crypto').randomInt
-  : (max) => Math.floor(Math.random() * max)
 
 const textEncoder = new TextEncoder()
 function noop () {}
@@ -106,7 +101,7 @@ function extractBody (object, keepalive = false) {
     // Set source to a copy of the bytes held by object.
     source = webidl.util.getCopyOfBytesHeldByBufferSource(object)
   } else if (webidl.is.FormData(object)) {
-    const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
+    const boundary = getFormDataBoundary(object)
     const prefix = `--${boundary}\r\nContent-Disposition: form-data`
 
     /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
diff --git a/deps/undici/src/lib/web/fetch/formdata.js b/deps/undici/src/lib/web/fetch/formdata.js
index c21fb06a3eeb62..226bd32958775b 100644
--- a/deps/undici/src/lib/web/fetch/formdata.js
+++ b/deps/undici/src/lib/web/fetch/formdata.js
@@ -4,10 +4,16 @@ const { iteratorMixin } = require('./util')
 const { kEnumerableProperty } = require('../../core/util')
 const { webidl } = require('../webidl')
 const nodeUtil = require('node:util')
+const { runtimeFeatures } = require('../../util/runtime-features.js')
+
+const random = runtimeFeatures.has('crypto')
+  ? require('node:crypto').randomInt
+  : (max) => Math.floor(Math.random() * max)
 
 // https://xhr.spec.whatwg.org/#formdata
 class FormData {
   #state = []
+  #boundary = null
 
   constructor (form = undefined) {
     webidl.util.markAsUncloneable(this)
@@ -192,11 +198,24 @@ class FormData {
   static setFormDataState (formData, newState) {
     formData.#state = newState
   }
+
+  /**
+   * @param {FormData} formData
+   * @returns {string | null}
+   */
+  static getFormDataBoundary (formData) {
+    const boundary = formData.#boundary
+    if (boundary != null) return boundary
+
+    // eslint-disable-next-line no-return-assign
+    return formData.#boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
+  }
 }
 
-const { getFormDataState, setFormDataState } = FormData
+const { getFormDataState, setFormDataState, getFormDataBoundary } = FormData
 Reflect.deleteProperty(FormData, 'getFormDataState')
 Reflect.deleteProperty(FormData, 'setFormDataState')
+Reflect.deleteProperty(FormData, 'getFormDataBoundary')
 
 iteratorMixin('FormData', FormData, getFormDataState, 'name', 'value')
 
@@ -256,4 +275,4 @@ function makeEntry (name, value, filename) {
 
 webidl.is.FormData = webidl.util.MakeTypeAssertion(FormData)
 
-module.exports = { FormData, makeEntry, setFormDataState }
+module.exports = { FormData, makeEntry, setFormDataState, getFormDataBoundary }
diff --git a/deps/undici/src/lib/web/fetch/index.js b/deps/undici/src/lib/web/fetch/index.js
index 33d7761cecda9f..1959f27c04aa96 100644
--- a/deps/undici/src/lib/web/fetch/index.js
+++ b/deps/undici/src/lib/web/fetch/index.js
@@ -2184,6 +2184,8 @@ async function httpNetworkFetch (
           origin: url.origin,
           method: request.method,
           body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
+          // Preserve the serialized fetch body for MockAgent net-connect fallthroughs.
+          __mockAgentBodyForDispatch: body,
           headers: request.headersList.entries,
           maxRedirections: 0,
           upgrade: request.mode === 'websocket' ? 'websocket' : undefined,
diff --git a/deps/undici/src/package-lock.json b/deps/undici/src/package-lock.json
index 30097844c87d07..dcfc6ca55f2bff 100644
--- a/deps/undici/src/package-lock.json
+++ b/deps/undici/src/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "undici",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "undici",
-      "version": "8.2.0",
+      "version": "8.3.0",
       "license": "MIT",
       "devDependencies": {
         "@fastify/busboy": "3.2.0",
@@ -15,8 +15,8 @@
         "@sinonjs/fake-timers": "^12.0.0",
         "@types/node": "^22.0.0",
         "abort-controller": "^3.0.0",
-        "borp": "^0.20.0",
-        "c8": "^10.0.0",
+        "borp": "^1.0.0",
+        "c8": "^11.0.0",
         "cross-env": "^10.0.0",
         "dns-packet": "^5.4.0",
         "esbuild": "^0.28.0",
@@ -25,7 +25,7 @@
         "husky": "^9.0.7",
         "jest": "^30.0.5",
         "jsondiffpatch": "^0.7.3",
-        "neostandard": "^0.12.0",
+        "neostandard": "^0.13.0",
         "node-forge": "^1.3.1",
         "proxy": "^4.0.0",
         "tsd": "^0.33.0",
@@ -91,9 +91,9 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
-      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.3.tgz",
+      "integrity": "sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -262,9 +262,9 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.29.2",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
-      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.3.tgz",
+      "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -582,9 +582,9 @@
       "license": "Apache-2.0"
     },
     "node_modules/@emnapi/core": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.2.tgz",
-      "integrity": "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -594,9 +594,9 @@
       }
     },
     "node_modules/@emnapi/runtime": {
-      "version": "1.9.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
-      "integrity": "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -1424,17 +1424,17 @@
       }
     },
     "node_modules/@jest/console": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/console/-/console-30.3.0.tgz",
-      "integrity": "sha512-PAwCvFJ4696XP2qZj+LAn1BWjZaJ6RjG6c7/lkMaUJnkyMS34ucuIsfqYvfskVNvUI27R/u4P1HMYFnlVXG/Ww==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/console/-/console-30.4.1.tgz",
+      "integrity": "sha512-v3bhyxUh9Hgmo5p6hAOXe14/R3ZxZDOsvHleh4B07z3m/x4/ngPUXEm9XwK4sF4u+f+P2ORb0Ge+MgpaqRMVDA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "chalk": "^4.1.2",
-        "jest-message-util": "30.3.0",
-        "jest-util": "30.3.0",
+        "jest-message-util": "30.4.1",
+        "jest-util": "30.4.1",
         "slash": "^3.0.0"
       },
       "engines": {
@@ -1442,38 +1442,39 @@
       }
     },
     "node_modules/@jest/core": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/core/-/core-30.3.0.tgz",
-      "integrity": "sha512-U5mVPsBxLSO6xYbf+tgkymLx+iAhvZX43/xI1+ej2ZOPnPdkdO1CzDmFKh2mZBn2s4XZixszHeQnzp1gm/DIxw==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/@jest/core/-/core-30.4.2.tgz",
+      "integrity": "sha512-TZJA6cPJUFxoWhxaLo8t0VX/MZX2wPWr0uIDvLSHIvN4gu9h02vSzqI2kBADG1ExqQlC+cY09xKMSreivvrChQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/console": "30.3.0",
-        "@jest/pattern": "30.0.1",
-        "@jest/reporters": "30.3.0",
-        "@jest/test-result": "30.3.0",
-        "@jest/transform": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/console": "30.4.1",
+        "@jest/pattern": "30.4.0",
+        "@jest/reporters": "30.4.1",
+        "@jest/test-result": "30.4.1",
+        "@jest/transform": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "ansi-escapes": "^4.3.2",
         "chalk": "^4.1.2",
         "ci-info": "^4.2.0",
         "exit-x": "^0.2.2",
+        "fast-json-stable-stringify": "^2.1.0",
         "graceful-fs": "^4.2.11",
-        "jest-changed-files": "30.3.0",
-        "jest-config": "30.3.0",
-        "jest-haste-map": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-regex-util": "30.0.1",
-        "jest-resolve": "30.3.0",
-        "jest-resolve-dependencies": "30.3.0",
-        "jest-runner": "30.3.0",
-        "jest-runtime": "30.3.0",
-        "jest-snapshot": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-validate": "30.3.0",
-        "jest-watcher": "30.3.0",
-        "pretty-format": "30.3.0",
+        "jest-changed-files": "30.4.1",
+        "jest-config": "30.4.2",
+        "jest-haste-map": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-regex-util": "30.4.0",
+        "jest-resolve": "30.4.1",
+        "jest-resolve-dependencies": "30.4.2",
+        "jest-runner": "30.4.2",
+        "jest-runtime": "30.4.2",
+        "jest-snapshot": "30.4.1",
+        "jest-util": "30.4.1",
+        "jest-validate": "30.4.1",
+        "jest-watcher": "30.4.1",
+        "pretty-format": "30.4.1",
         "slash": "^3.0.0"
       },
       "engines": {
@@ -1489,9 +1490,9 @@
       }
     },
     "node_modules/@jest/diff-sequences": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.3.0.tgz",
-      "integrity": "sha512-cG51MVnLq1ecVUaQ3fr6YuuAOitHK1S4WUJHnsPFE/quQr33ADUx1FfrTCpMCRxvy0Yr9BThKpDjSlcTi91tMA==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.4.0.tgz",
+      "integrity": "sha512-zOpzlfUs45l6u7jm39qr87JCHUDsaeCtvL+kQe/Vn9jSnRB4/5IPXISm0h9I1vZW/o00Kn4UTJ2MOlhnUGwv3g==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -1499,39 +1500,39 @@
       }
     },
     "node_modules/@jest/environment": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.3.0.tgz",
-      "integrity": "sha512-SlLSF4Be735yQXyh2+mctBOzNDx5s5uLv88/j8Qn1wH679PDcwy67+YdADn8NJnGjzlXtN62asGH/T4vWOkfaw==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.4.1.tgz",
+      "integrity": "sha512-AK9yNRqgKxiabqMoe4oW+3/TSSeV8vkdC7BGaxZdU0AFXfOpofTLqdru2GXKZghP3sdgwE9XXpnVwfZ8JnFV4w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/fake-timers": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/fake-timers": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
-        "jest-mock": "30.3.0"
+        "jest-mock": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/@jest/expect": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.3.0.tgz",
-      "integrity": "sha512-76Nlh4xJxk2D/9URCn3wFi98d2hb19uWE1idLsTt2ywhvdOldbw3S570hBgn25P4ICUZ/cBjybrBex2g17IDbg==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.4.1.tgz",
+      "integrity": "sha512-ginrj6TMgh2GshLUGCjO94Ptx9HhdZA/I6A9iUfyeLKFtdAjnKzHDgzgP9HYQgbxM1lbXScQ2eUBz2lGeVDPWA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "expect": "30.3.0",
-        "jest-snapshot": "30.3.0"
+        "expect": "30.4.1",
+        "jest-snapshot": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/@jest/expect-utils": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.3.0.tgz",
-      "integrity": "sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.4.1.tgz",
+      "integrity": "sha512-ZBn5CglH8fBsQsvs4VWNzD4aWfUYks+IdOOQU3MEK71ol/BcVm+P+rtb1KpiFBpSWSCE27uOahyyf1vfqOVbcQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1542,27 +1543,27 @@
       }
     },
     "node_modules/@jest/fake-timers": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.3.0.tgz",
-      "integrity": "sha512-WUQDs8SOP9URStX1DzhD425CqbN/HxUYCTwVrT8sTVBfMvFqYt/s61EK5T05qnHu0po6RitXIvP9otZxYDzTGQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.4.1.tgz",
+      "integrity": "sha512-iW5umdmfPeWzehrVhugFQZqCchSCud5S1l2YT0O9ZhjRR0ExclANDZkiSBwzqtnlOn0J1JXvO+HZ6rkuyOVOgQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
-        "@sinonjs/fake-timers": "^15.0.0",
+        "@jest/types": "30.4.1",
+        "@sinonjs/fake-timers": "^15.4.0",
         "@types/node": "*",
-        "jest-message-util": "30.3.0",
-        "jest-mock": "30.3.0",
-        "jest-util": "30.3.0"
+        "jest-message-util": "30.4.1",
+        "jest-mock": "30.4.1",
+        "jest-util": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/@jest/fake-timers/node_modules/@sinonjs/fake-timers": {
-      "version": "15.3.2",
-      "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.3.2.tgz",
-      "integrity": "sha512-mrn35Jl2pCpns+mE3HaZa1yPN5EYCRgiMI+135COjr2hr8Cls9DXqIZ57vZe2cz7y2XVSq92tcs6kGQcT1J8Rw==",
+      "version": "15.4.0",
+      "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.4.0.tgz",
+      "integrity": "sha512-DsG+8/LscQIQg68J6Ef3dv10u6nVyetYn923s3/sus5eaGfTo1of5WMZSLf0UJc9KDuKPilPH0UDJCjvNbDNCA==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -1580,47 +1581,47 @@
       }
     },
     "node_modules/@jest/globals": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.3.0.tgz",
-      "integrity": "sha512-+owLCBBdfpgL3HU+BD5etr1SvbXpSitJK0is1kiYjJxAAJggYMRQz5hSdd5pq1sSggfxPbw2ld71pt4x5wwViA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.4.1.tgz",
+      "integrity": "sha512-ZbuY4cmXC8DkxYjfvT2DbcHWL2T6vmsMhXCDcmTB2T0y0gaezBI77ufq5ZAIdcRkYZ7NEQEDg1xFeKbxUJ5v5Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/environment": "30.3.0",
-        "@jest/expect": "30.3.0",
-        "@jest/types": "30.3.0",
-        "jest-mock": "30.3.0"
+        "@jest/environment": "30.4.1",
+        "@jest/expect": "30.4.1",
+        "@jest/types": "30.4.1",
+        "jest-mock": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/@jest/pattern": {
-      "version": "30.0.1",
-      "resolved": "https://registry.npmjs.org/@jest/pattern/-/pattern-30.0.1.tgz",
-      "integrity": "sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/@jest/pattern/-/pattern-30.4.0.tgz",
+      "integrity": "sha512-RAWn3+f9u8BsHijKJ71uHcFp6vmyEt6VvoWXkl6hKF3qVIuWNmudVjg12DlBPGup/frIl5UcUlH5HfEuvHpEXg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/node": "*",
-        "jest-regex-util": "30.0.1"
+        "jest-regex-util": "30.4.0"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/@jest/reporters": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-30.3.0.tgz",
-      "integrity": "sha512-a09z89S+PkQnL055bVj8+pe2Caed2PBOaczHcXCykW5ngxX9EWx/1uAwncxc/HiU0oZqfwseMjyhxgRjS49qPw==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-30.4.1.tgz",
+      "integrity": "sha512-/SnkPCzEQpUaBH81kjdEdDdo2WZl5hxw+BmLDGWjRkm8o7XlhjwsU36cqwe5PGBE5WYpBvDzRSdXx9rbGuJtNA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@bcoe/v8-coverage": "^0.2.3",
-        "@jest/console": "30.3.0",
-        "@jest/test-result": "30.3.0",
-        "@jest/transform": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/console": "30.4.1",
+        "@jest/test-result": "30.4.1",
+        "@jest/transform": "30.4.1",
+        "@jest/types": "30.4.1",
         "@jridgewell/trace-mapping": "^0.3.25",
         "@types/node": "*",
         "chalk": "^4.1.2",
@@ -1633,9 +1634,9 @@
         "istanbul-lib-report": "^3.0.0",
         "istanbul-lib-source-maps": "^5.0.0",
         "istanbul-reports": "^3.1.3",
-        "jest-message-util": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-worker": "30.3.0",
+        "jest-message-util": "30.4.1",
+        "jest-util": "30.4.1",
+        "jest-worker": "30.4.1",
         "slash": "^3.0.0",
         "string-length": "^4.0.2",
         "v8-to-istanbul": "^9.0.1"
@@ -1660,9 +1661,9 @@
       "license": "MIT"
     },
     "node_modules/@jest/schemas": {
-      "version": "30.0.5",
-      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-30.0.5.tgz",
-      "integrity": "sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-30.4.1.tgz",
+      "integrity": "sha512-i6b4qw5qnP8c5FEeBJg/uZQ4ddrkN6Ca8qISJh0pr7a5hfn3h3v5x60BEbOC7OYAGZNMs1LfFLwnW2CuK8F57Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1673,13 +1674,13 @@
       }
     },
     "node_modules/@jest/snapshot-utils": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.3.0.tgz",
-      "integrity": "sha512-ORbRN9sf5PP82v3FXNSwmO1OTDR2vzR2YTaR+E3VkSBZ8zadQE6IqYdYEeFH1NIkeB2HIGdF02dapb6K0Mj05g==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.4.1.tgz",
+      "integrity": "sha512-ObY4ljvQ95mt6iwKtVLetR/4yXiAgl3H4nJxhztr0MTjrN97TwDYrnCp/kF60Ec9HdhkWTHSu+Hg05aXfngpOA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "chalk": "^4.1.2",
         "graceful-fs": "^4.2.11",
         "natural-compare": "^1.4.0"
@@ -1704,14 +1705,14 @@
       }
     },
     "node_modules/@jest/test-result": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-30.3.0.tgz",
-      "integrity": "sha512-e/52nJGuD74AKTSe0P4y5wFRlaXP0qmrS17rqOMHeSwm278VyNyXE3gFO/4DTGF9w+65ra3lo3VKj0LBrzmgdQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-30.4.1.tgz",
+      "integrity": "sha512-/ZG7pgEiOmmWkN9TplKbOu4id2N5lh7FHwRwlkgBVAzGdRH+OkkQ8wX/kIxg4zmd3ZQvAL1RwL2yWsvNYYECTw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/console": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/console": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/istanbul-lib-coverage": "^2.0.6",
         "collect-v8-coverage": "^1.0.2"
       },
@@ -1720,15 +1721,15 @@
       }
     },
     "node_modules/@jest/test-sequencer": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-30.3.0.tgz",
-      "integrity": "sha512-dgbWy9b8QDlQeRZcv7LNF+/jFiiYHTKho1xirauZ7kVwY7avjFF6uTT0RqlgudB5OuIPagFdVtfFMosjVbk1eA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-30.4.1.tgz",
+      "integrity": "sha512-PeYE+4td5rKjoRPxztObrXU+H8hsjZfxKMXOcmrr34JerSyB/ROOxbbicz8B7A5j9R9VayDnVPvBmedqCsFCdw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/test-result": "30.3.0",
+        "@jest/test-result": "30.4.1",
         "graceful-fs": "^4.2.11",
-        "jest-haste-map": "30.3.0",
+        "jest-haste-map": "30.4.1",
         "slash": "^3.0.0"
       },
       "engines": {
@@ -1736,23 +1737,23 @@
       }
     },
     "node_modules/@jest/transform": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.3.0.tgz",
-      "integrity": "sha512-TLKY33fSLVd/lKB2YI1pH69ijyUblO/BQvCj566YvnwuzoTNr648iE0j22vRvVNk2HsPwByPxATg3MleS3gf5A==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.4.1.tgz",
+      "integrity": "sha512-Wz0LyktlTvRefoymh+n64hQ84KNXsRGcwdoZ8CSa0Ea+fgYcHZlnk+hDP7v2MS7il2bQ5uTEIxf4/NNfhMN4KQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/core": "^7.27.4",
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@jridgewell/trace-mapping": "^0.3.25",
         "babel-plugin-istanbul": "^7.0.1",
         "chalk": "^4.1.2",
         "convert-source-map": "^2.0.0",
         "fast-json-stable-stringify": "^2.1.0",
         "graceful-fs": "^4.2.11",
-        "jest-haste-map": "30.3.0",
-        "jest-regex-util": "30.0.1",
-        "jest-util": "30.3.0",
+        "jest-haste-map": "30.4.1",
+        "jest-regex-util": "30.4.0",
+        "jest-util": "30.4.1",
         "pirates": "^4.0.7",
         "slash": "^3.0.0",
         "write-file-atomic": "^5.0.1"
@@ -1762,14 +1763,14 @@
       }
     },
     "node_modules/@jest/types": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz",
-      "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.4.1.tgz",
+      "integrity": "sha512-f1x/vJXIfjOlEmejYpbkbgw1gOqpPECwMvMEtBqe47j7H2Hg8h8w3o3ikhSXq3MI15kg+oQ0exWO0uCtTNJLoQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/pattern": "30.0.1",
-        "@jest/schemas": "30.0.5",
+        "@jest/pattern": "30.4.0",
+        "@jest/schemas": "30.4.1",
         "@types/istanbul-lib-coverage": "^2.0.6",
         "@types/istanbul-reports": "^3.0.4",
         "@types/node": "*",
@@ -1909,23 +1910,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/@nolyfill/is-core-module": {
-      "version": "1.0.39",
-      "resolved": "https://registry.npmjs.org/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz",
-      "integrity": "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.4.0"
-      }
-    },
-    "node_modules/@package-json/types": {
-      "version": "0.0.12",
-      "resolved": "https://registry.npmjs.org/@package-json/types/-/types-0.0.12.tgz",
-      "integrity": "sha512-uu43FGU34B5VM9mCNjXCwLaGHYjXdNincqKLaraaCW+7S2+SmiBg1Nv8bPnmschrIfZmfKNY9f3fC376MRrObw==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@pkgjs/parseargs": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
@@ -2039,9 +2023,9 @@
       }
     },
     "node_modules/@tybys/wasm-util": {
-      "version": "0.10.1",
-      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
-      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
+      "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -2490,9 +2474,9 @@
       }
     },
     "node_modules/@ungap/structured-clone": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
-      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.1.tgz",
+      "integrity": "sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==",
       "dev": true,
       "license": "ISC"
     },
@@ -2602,9 +2586,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2619,9 +2600,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2636,9 +2614,6 @@
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2653,9 +2628,6 @@
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2670,9 +2642,6 @@
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2687,9 +2656,6 @@
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2704,9 +2670,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -2721,9 +2684,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -3220,16 +3180,16 @@
       }
     },
     "node_modules/babel-jest": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-30.3.0.tgz",
-      "integrity": "sha512-gRpauEU2KRrCox5Z296aeVHR4jQ98BCnu0IO332D/xpHNOsIH/bgSRk9k6GbKIbBw8vFeN6ctuu6tV8WOyVfYQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-30.4.1.tgz",
+      "integrity": "sha512-fATAbM8piYxkiXQp3RBXmZHxZVNJZAVXXfyeyCN2Tida3+qJ8ea9UxhiJ2y4fLO90ZImKt6k9FlcH2+rLkJGhw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/transform": "30.3.0",
+        "@jest/transform": "30.4.1",
         "@types/babel__core": "^7.20.5",
         "babel-plugin-istanbul": "^7.0.1",
-        "babel-preset-jest": "30.3.0",
+        "babel-preset-jest": "30.4.0",
         "chalk": "^4.1.2",
         "graceful-fs": "^4.2.11",
         "slash": "^3.0.0"
@@ -3299,9 +3259,9 @@
       }
     },
     "node_modules/babel-plugin-jest-hoist": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-30.3.0.tgz",
-      "integrity": "sha512-+TRkByhsws6sfPjVaitzadk1I0F5sPvOVUH5tyTSzhePpsGIVrdeunHSw/C36QeocS95OOk8lunc4rlu5Anwsg==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-30.4.0.tgz",
+      "integrity": "sha512-9EdtWM/sSfXLOGLwSn+GS6pIXyBnL07/8gyJlwFXjWy4DxMOyItqyUT29d4lQiS380EZwYlX7/At4PgBS+m2aA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3339,13 +3299,13 @@
       }
     },
     "node_modules/babel-preset-jest": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-30.3.0.tgz",
-      "integrity": "sha512-6ZcUbWHC+dMz2vfzdNwi87Z1gQsLNK2uLuK1Q89R11xdvejcivlYYwDlEv0FHX3VwEXpbBQ9uufB/MUNpZGfhQ==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-30.4.0.tgz",
+      "integrity": "sha512-lBY4jxsNmCnSiu7kquw8ZC9F4+XLMOKypT3RnNHPvU2Kpd4W0xaPuLr5ZkRyOsvLYAY4yaW1ZwTW4xB7NIiZzg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "babel-plugin-jest-hoist": "30.3.0",
+        "babel-plugin-jest-hoist": "30.4.0",
         "babel-preset-current-node-syntax": "^1.2.0"
       },
       "engines": {
@@ -3363,9 +3323,9 @@
       "license": "MIT"
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.18",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.18.tgz",
-      "integrity": "sha512-VSnGQAOLtP5mib/DPyg2/t+Tlv65NTBz83BJBJvmLVHHuKJVaDOBvJJykiT5TR++em5nfAySPccDZDa4oSrn8A==",
+      "version": "2.10.29",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.29.tgz",
+      "integrity": "sha512-Asa2krT+XTPZINCS+2QcyS8WTkObE77RwkydwF7h6DmnKqbvlalz93m/dnphUyCa6SWSP51VgtEUf2FN+gelFQ==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
@@ -3382,9 +3342,9 @@
       "dev": true
     },
     "node_modules/borp": {
-      "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/borp/-/borp-0.20.2.tgz",
-      "integrity": "sha512-WJl/vYU6KoD0SyppDWPCdgrrTt2e+hCqTk5443fOUD92cbHLDLIcVRVRh8FIP0uhJjcZQ82Ky0XhB7Kyh32d/w==",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/borp/-/borp-1.0.0.tgz",
+      "integrity": "sha512-ooi3bLC8hQRGfthud3BWqS1A98X7NuQqAgGgX6mn5l6Gu6aeHJ7sjpS9gQhHLx+ju026hcc0BEPLRg1obxB1gw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3397,6 +3357,156 @@
       },
       "bin": {
         "borp": "borp.js"
+      },
+      "engines": {
+        "node": ">=22.6.0"
+      }
+    },
+    "node_modules/borp/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/borp/node_modules/brace-expansion": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/borp/node_modules/c8": {
+      "version": "10.1.3",
+      "resolved": "https://registry.npmjs.org/c8/-/c8-10.1.3.tgz",
+      "integrity": "sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@bcoe/v8-coverage": "^1.0.1",
+        "@istanbuljs/schema": "^0.1.3",
+        "find-up": "^5.0.0",
+        "foreground-child": "^3.1.1",
+        "istanbul-lib-coverage": "^3.2.0",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.1.6",
+        "test-exclude": "^7.0.1",
+        "v8-to-istanbul": "^9.0.0",
+        "yargs": "^17.7.2",
+        "yargs-parser": "^21.1.1"
+      },
+      "bin": {
+        "c8": "bin/c8.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "monocart-coverage-reports": "^2"
+      },
+      "peerDependenciesMeta": {
+        "monocart-coverage-reports": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/borp/node_modules/c8/node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/borp/node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/borp/node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/borp/node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/borp/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/borp/node_modules/test-exclude": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.2.tgz",
+      "integrity": "sha512-u9E6A+ZDYdp7a4WnarkXPZOx8Ilz46+kby6p1yZ8zsGTz9gYa6FIS7lj2oezzNKmtdyyJNNmmXDppga5GB7kSw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "@istanbuljs/schema": "^0.1.2",
+        "glob": "^10.4.1",
+        "minimatch": "^10.2.2"
+      },
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/brace-expansion": {
@@ -3475,9 +3585,9 @@
       "license": "MIT"
     },
     "node_modules/c8": {
-      "version": "10.1.3",
-      "resolved": "https://registry.npmjs.org/c8/-/c8-10.1.3.tgz",
-      "integrity": "sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA==",
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/c8/-/c8-11.0.0.tgz",
+      "integrity": "sha512-e/uRViGHSVIJv7zsaDKM7VRn2390TgHXqUSvYwPHBQaU6L7E9L0n9JbdkwdYPvshDT0KymBmmlwSpms3yBaMNg==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -3488,7 +3598,7 @@
         "istanbul-lib-coverage": "^3.2.0",
         "istanbul-lib-report": "^3.0.1",
         "istanbul-reports": "^3.1.6",
-        "test-exclude": "^7.0.1",
+        "test-exclude": "^8.0.0",
         "v8-to-istanbul": "^9.0.0",
         "yargs": "^17.7.2",
         "yargs-parser": "^21.1.1"
@@ -3497,7 +3607,7 @@
         "c8": "bin/c8.js"
       },
       "engines": {
-        "node": ">=18"
+        "node": "20 || >=22"
       },
       "peerDependencies": {
         "monocart-coverage-reports": "^2"
@@ -3656,9 +3766,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001788",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001788.tgz",
-      "integrity": "sha512-6q8HFp+lOQtcf7wBK+uEenxymVWkGKkjFpCvw5W25cmMwEDU45p1xQFBQv8JDlMMry7eNxyBaR+qxgmTUZkIRQ==",
+      "version": "1.0.30001792",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001792.tgz",
+      "integrity": "sha512-hVLMUZFgR4JJ6ACt1uEESvQN1/dBVqPAKY0hgrV70eN3391K6juAfTjKZLKvOMsx8PxA7gsY1/tLMMTcfFLLpw==",
       "dev": true,
       "funding": [
         {
@@ -3842,16 +3952,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/comment-parser": {
-      "version": "1.4.6",
-      "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.6.tgz",
-      "integrity": "sha512-ObxuY6vnbWTN6Od72xfwN9DbzC7Y2vv8u1Soi9ahRKL37gb6y1qk6/dgjs+3JWuXJHWvsg3BXIwzd/rkmAwavg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12.0.0"
-      }
-    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -4158,9 +4258,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.336",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.336.tgz",
-      "integrity": "sha512-AbH9q9J455r/nLmdNZes0G0ZKcRX73FicwowalLs6ijwOmCJSRRrLX63lcAlzy9ux3dWK1w1+1nsBJEWN11hcQ==",
+      "version": "1.5.354",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.354.tgz",
+      "integrity": "sha512-JaBHwWcfIdmSAfWM5l3uwjGd431j8YEMikZ+K/2nXVuBqJKyZ0f+2h4n4JY5AyNiZmnY9qQr2RU3v9DxDmHMNg==",
       "dev": true,
       "license": "ISC"
     },
@@ -4607,66 +4707,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/eslint-import-context": {
-      "version": "0.1.9",
-      "resolved": "https://registry.npmjs.org/eslint-import-context/-/eslint-import-context-0.1.9.tgz",
-      "integrity": "sha512-K9Hb+yRaGAGUbwjhFNHvSmmkZs9+zbuoe3kFQ4V1wYjrepUFYM2dZAfNtjbbj3qsPfUfsA68Bx/ICWQMi+C8Eg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-tsconfig": "^4.10.1",
-        "stable-hash-x": "^0.2.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint-import-context"
-      },
-      "peerDependencies": {
-        "unrs-resolver": "^1.0.0"
-      },
-      "peerDependenciesMeta": {
-        "unrs-resolver": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-import-resolver-typescript": {
-      "version": "3.10.1",
-      "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.10.1.tgz",
-      "integrity": "sha512-A1rHYb06zjMGAxdLSkN2fXPBwuSaQ0iO5M/hdyS0Ajj1VBaRp0sPD3dn1FhME3c/JluGFbwSxyCfqdSbtQLAHQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@nolyfill/is-core-module": "1.0.39",
-        "debug": "^4.4.0",
-        "get-tsconfig": "^4.10.0",
-        "is-bun-module": "^2.0.0",
-        "stable-hash": "^0.0.5",
-        "tinyglobby": "^0.2.13",
-        "unrs-resolver": "^1.6.2"
-      },
-      "engines": {
-        "node": "^14.18.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint-import-resolver-typescript"
-      },
-      "peerDependencies": {
-        "eslint": "*",
-        "eslint-plugin-import": "*",
-        "eslint-plugin-import-x": "*"
-      },
-      "peerDependenciesMeta": {
-        "eslint-plugin-import": {
-          "optional": true
-        },
-        "eslint-plugin-import-x": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/eslint-plugin-es-x": {
       "version": "7.8.0",
       "resolved": "https://registry.npmjs.org/eslint-plugin-es-x/-/eslint-plugin-es-x-7.8.0.tgz",
@@ -4689,96 +4729,6 @@
         "eslint": ">=8"
       }
     },
-    "node_modules/eslint-plugin-import-x": {
-      "version": "4.16.2",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-import-x/-/eslint-plugin-import-x-4.16.2.tgz",
-      "integrity": "sha512-rM9K8UBHcWKpzQzStn1YRN2T5NvdeIfSVoKu/lKF41znQXHAUcBbYXe5wd6GNjZjTrP7viQ49n1D83x/2gYgIw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@package-json/types": "^0.0.12",
-        "@typescript-eslint/types": "^8.56.0",
-        "comment-parser": "^1.4.1",
-        "debug": "^4.4.1",
-        "eslint-import-context": "^0.1.9",
-        "is-glob": "^4.0.3",
-        "minimatch": "^9.0.3 || ^10.1.2",
-        "semver": "^7.7.2",
-        "stable-hash-x": "^0.2.0",
-        "unrs-resolver": "^1.9.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint-plugin-import-x"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/utils": "^8.56.0",
-        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "eslint-import-resolver-node": "*"
-      },
-      "peerDependenciesMeta": {
-        "@typescript-eslint/utils": {
-          "optional": true
-        },
-        "eslint-import-resolver-node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/eslint-plugin-import-x/node_modules/balanced-match": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
-      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "18 || 20 || >=22"
-      }
-    },
-    "node_modules/eslint-plugin-import-x/node_modules/brace-expansion": {
-      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^4.0.2"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      }
-    },
-    "node_modules/eslint-plugin-import-x/node_modules/minimatch": {
-      "version": "10.2.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
-      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "brace-expansion": "^5.0.5"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/eslint-plugin-import-x/node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/eslint-plugin-n": {
       "version": "17.24.0",
       "resolved": "https://registry.npmjs.org/eslint-plugin-n/-/eslint-plugin-n-17.24.0.tgz",
@@ -5106,27 +5056,27 @@
       }
     },
     "node_modules/expect": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/expect/-/expect-30.3.0.tgz",
-      "integrity": "sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/expect/-/expect-30.4.1.tgz",
+      "integrity": "sha512-PMARsyh/JtqC20HoGqlFcIlQAyqUtW4PlI1rup1uhYJtKuwAjbvWi3GQMAn+STdHum/dk8xrKfUM1+5SAwpolA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/expect-utils": "30.3.0",
+        "@jest/expect-utils": "30.4.1",
         "@jest/get-type": "30.1.0",
-        "jest-matcher-utils": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-mock": "30.3.0",
-        "jest-util": "30.3.0"
+        "jest-matcher-utils": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-mock": "30.4.1",
+        "jest-util": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/fast-check": {
-      "version": "4.6.0",
-      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-4.6.0.tgz",
-      "integrity": "sha512-h7H6Dm0Fy+H4ciQYFxFjXnXkzR2kr9Fb22c0UBpHnm59K2zpr2t13aPTHlltFiNT6zuxp6HMPAVVvgur4BLdpA==",
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-4.8.0.tgz",
+      "integrity": "sha512-GOJ158CUMnN6cSahsv4+ExARvIDuzzinFjkp0E9WtiBa5zcVeLozVkWaE4IzFcc+Y48Wp1EDlUZsXRyAztQcSg==",
       "dev": true,
       "funding": [
         {
@@ -6037,29 +5987,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/is-bun-module": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-bun-module/-/is-bun-module-2.0.0.tgz",
-      "integrity": "sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "semver": "^7.7.1"
-      }
-    },
-    "node_modules/is-bun-module/node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/is-callable": {
       "version": "1.2.7",
       "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
@@ -6482,9 +6409,9 @@
       }
     },
     "node_modules/istanbul-lib-instrument/node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.0.tgz",
+      "integrity": "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -6573,16 +6500,16 @@
       }
     },
     "node_modules/jest": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest/-/jest-30.3.0.tgz",
-      "integrity": "sha512-AkXIIFcaazymvey2i/+F94XRnM6TsVLZDhBMLsd1Sf/W0wzsvvpjeyUrCZD6HGG4SDYPgDJDBKeiJTBb10WzMg==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest/-/jest-30.4.2.tgz",
+      "integrity": "sha512-Yi1jqNC/Oq0N4hBgNH/YvBpP1P57QqundgytzYqy3yqAa7NZPNjSoi4SGbRAXDMdBzNE6xBCi5U7RgfrvMEUVQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/core": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/core": "30.4.2",
+        "@jest/types": "30.4.1",
         "import-local": "^3.2.0",
-        "jest-cli": "30.3.0"
+        "jest-cli": "30.4.2"
       },
       "bin": {
         "jest": "bin/jest.js"
@@ -6600,14 +6527,14 @@
       }
     },
     "node_modules/jest-changed-files": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-30.3.0.tgz",
-      "integrity": "sha512-B/7Cny6cV5At6M25EWDgf9S617lHivamL8vl6KEpJqkStauzcG4e+WPfDgMMF+H4FVH4A2PLRyvgDJan4441QA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-30.4.1.tgz",
+      "integrity": "sha512-IuctmYrxi21iOSOaIXpJWalHyPAsVv0GeBHKDn8C1CA4W5htHn7INL+wdnL4Bo0+olEndvAFkmb++tIQJG+vvg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "execa": "^5.1.1",
-        "jest-util": "30.3.0",
+        "jest-util": "30.4.1",
         "p-limit": "^3.1.0"
       },
       "engines": {
@@ -6705,29 +6632,29 @@
       }
     },
     "node_modules/jest-circus": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-30.3.0.tgz",
-      "integrity": "sha512-PyXq5szeSfR/4f1lYqCmmQjh0vqDkURUYi9N6whnHjlRz4IUQfMcXkGLeEoiJtxtyPqgUaUUfyQlApXWBSN1RA==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-30.4.2.tgz",
+      "integrity": "sha512-rvHH7VlY6LgbJXJTQ87GW62g1FntOtbhh0zT+v04kC+pgL6aBKyYINXxWukCpj3dcIBMw5/XUbtDS9dU9JTXeQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/environment": "30.3.0",
-        "@jest/expect": "30.3.0",
-        "@jest/test-result": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/environment": "30.4.1",
+        "@jest/expect": "30.4.1",
+        "@jest/test-result": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "chalk": "^4.1.2",
         "co": "^4.6.0",
         "dedent": "^1.6.0",
         "is-generator-fn": "^2.1.0",
-        "jest-each": "30.3.0",
-        "jest-matcher-utils": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-runtime": "30.3.0",
-        "jest-snapshot": "30.3.0",
-        "jest-util": "30.3.0",
+        "jest-each": "30.4.1",
+        "jest-matcher-utils": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-runtime": "30.4.2",
+        "jest-snapshot": "30.4.1",
+        "jest-util": "30.4.1",
         "p-limit": "^3.1.0",
-        "pretty-format": "30.3.0",
+        "pretty-format": "30.4.1",
         "pure-rand": "^7.0.0",
         "slash": "^3.0.0",
         "stack-utils": "^2.0.6"
@@ -6754,21 +6681,21 @@
       "license": "MIT"
     },
     "node_modules/jest-cli": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-30.3.0.tgz",
-      "integrity": "sha512-l6Tqx+j1fDXJEW5bqYykDQQ7mQg+9mhWXtnj+tQZrTWYHyHoi6Be8HPumDSA+UiX2/2buEgjA58iJzdj146uCw==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-30.4.2.tgz",
+      "integrity": "sha512-jfA2ocvVHMXS2QijrJ0d31ektP+d/W0T5RpcTX2Pq+3sVqHlsXVCM2+FmwpL+bdY8OfHpIg9xMxLF17Zg0U49Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/core": "30.3.0",
-        "@jest/test-result": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/core": "30.4.2",
+        "@jest/test-result": "30.4.1",
+        "@jest/types": "30.4.1",
         "chalk": "^4.1.2",
         "exit-x": "^0.2.2",
         "import-local": "^3.2.0",
-        "jest-config": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-validate": "30.3.0",
+        "jest-config": "30.4.2",
+        "jest-util": "30.4.1",
+        "jest-validate": "30.4.1",
         "yargs": "^17.7.2"
       },
       "bin": {
@@ -6787,33 +6714,33 @@
       }
     },
     "node_modules/jest-config": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-30.3.0.tgz",
-      "integrity": "sha512-WPMAkMAtNDY9P/oKObtsRG/6KTrhtgPJoBTmk20uDn4Uy6/3EJnnaZJre/FMT1KVRx8cve1r7/FlMIOfRVWL4w==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-30.4.2.tgz",
+      "integrity": "sha512-rNHAShJQqQwFNoL0hbf3BphSBOWnpOUAKvidLS/AjNVLPfoj5mSf4jQMfW3cYOs6hXeZC7nF7mDHaBnbxELOzg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/core": "^7.27.4",
         "@jest/get-type": "30.1.0",
-        "@jest/pattern": "30.0.1",
-        "@jest/test-sequencer": "30.3.0",
-        "@jest/types": "30.3.0",
-        "babel-jest": "30.3.0",
+        "@jest/pattern": "30.4.0",
+        "@jest/test-sequencer": "30.4.1",
+        "@jest/types": "30.4.1",
+        "babel-jest": "30.4.1",
         "chalk": "^4.1.2",
         "ci-info": "^4.2.0",
         "deepmerge": "^4.3.1",
         "glob": "^10.5.0",
         "graceful-fs": "^4.2.11",
-        "jest-circus": "30.3.0",
-        "jest-docblock": "30.2.0",
-        "jest-environment-node": "30.3.0",
-        "jest-regex-util": "30.0.1",
-        "jest-resolve": "30.3.0",
-        "jest-runner": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-validate": "30.3.0",
+        "jest-circus": "30.4.2",
+        "jest-docblock": "30.4.0",
+        "jest-environment-node": "30.4.1",
+        "jest-regex-util": "30.4.0",
+        "jest-resolve": "30.4.1",
+        "jest-runner": "30.4.2",
+        "jest-util": "30.4.1",
+        "jest-validate": "30.4.1",
         "parse-json": "^5.2.0",
-        "pretty-format": "30.3.0",
+        "pretty-format": "30.4.1",
         "slash": "^3.0.0",
         "strip-json-comments": "^3.1.1"
       },
@@ -6838,25 +6765,25 @@
       }
     },
     "node_modules/jest-diff": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.3.0.tgz",
-      "integrity": "sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.4.1.tgz",
+      "integrity": "sha512-CRpFK0RtLriVDGcPPAnR6HMVI8bSR2jnUIgralhauzYQZIb4RH9AtEInTuQr65LmmGggGcRT6HIASxwqsVsmlA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/diff-sequences": "30.3.0",
+        "@jest/diff-sequences": "30.4.0",
         "@jest/get-type": "30.1.0",
         "chalk": "^4.1.2",
-        "pretty-format": "30.3.0"
+        "pretty-format": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/jest-docblock": {
-      "version": "30.2.0",
-      "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-30.2.0.tgz",
-      "integrity": "sha512-tR/FFgZKS1CXluOQzZvNH3+0z9jXr3ldGSD8bhyuxvlVUwbeLOGynkunvlTMxchC5urrKndYiwCFC0DLVjpOCA==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-30.4.0.tgz",
+      "integrity": "sha512-ZPMabUZCx5MpbZ2eBYSvZ0J8fvo3dR9oM+eeUpb3aKNQFuS2tu3Duw1TNlMoP8k3WQgKGJuhcMFvwcVuq6T7oA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -6867,36 +6794,36 @@
       }
     },
     "node_modules/jest-each": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-30.3.0.tgz",
-      "integrity": "sha512-V8eMndg/aZ+3LnCJgSm13IxS5XSBM22QSZc9BtPK8Dek6pm+hfUNfwBdvsB3d342bo1q7wnSkC38zjX259qZNA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-30.4.1.tgz",
+      "integrity": "sha512-/8MJbH6fuj48TstjrMf+u/pd06Qezz5xOXvZA6442heNOWr8bdeoGZX2d9fCn028CoMgYmroH9//zky5GfyYmA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jest/get-type": "30.1.0",
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "chalk": "^4.1.2",
-        "jest-util": "30.3.0",
-        "pretty-format": "30.3.0"
+        "jest-util": "30.4.1",
+        "pretty-format": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/jest-environment-node": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-30.3.0.tgz",
-      "integrity": "sha512-4i6HItw/JSiJVsC5q0hnKIe/hbYfZLVG9YJ/0pU9Hz2n/9qZe3Rhn5s5CUZA5ORZlcdT/vmAXRMyONXJwPrmYQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-30.4.1.tgz",
+      "integrity": "sha512-4FZYVOk85hz2AyT6BbarKy9u37g6DbrDyCdFhsnDdXqyrueYQvB+0zO4f/kqLCRD0BsPRXPMNJeQwihKZV8naw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/environment": "30.3.0",
-        "@jest/fake-timers": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/environment": "30.4.1",
+        "@jest/fake-timers": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
-        "jest-mock": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-validate": "30.3.0"
+        "jest-mock": "30.4.1",
+        "jest-util": "30.4.1",
+        "jest-validate": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
@@ -6913,20 +6840,20 @@
       }
     },
     "node_modules/jest-haste-map": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.3.0.tgz",
-      "integrity": "sha512-mMi2oqG4KRU0R9QEtscl87JzMXfUhbKaFqOxmjb2CKcbHcUGFrJCBWHmnTiUqi6JcnzoBlO4rWfpdl2k/RfLCA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.4.1.tgz",
+      "integrity": "sha512-rFrcONd8jeFsyw+Z9CrScJgglRf2+NFmNam8dKu7n+SoHqNYT47mn0DdEcVUZJpvh7Iz6/si7f7yUH7GJHVgnw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "anymatch": "^3.1.3",
         "fb-watchman": "^2.0.2",
         "graceful-fs": "^4.2.11",
-        "jest-regex-util": "30.0.1",
-        "jest-util": "30.3.0",
-        "jest-worker": "30.3.0",
+        "jest-regex-util": "30.4.0",
+        "jest-util": "30.4.1",
+        "jest-worker": "30.4.1",
         "picomatch": "^4.0.3",
         "walker": "^1.0.8"
       },
@@ -6938,49 +6865,50 @@
       }
     },
     "node_modules/jest-leak-detector": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-30.3.0.tgz",
-      "integrity": "sha512-cuKmUUGIjfXZAiGJ7TbEMx0bcqNdPPI6P1V+7aF+m/FUJqFDxkFR4JqkTu8ZOiU5AaX/x0hZ20KaaIPXQzbMGQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-30.4.1.tgz",
+      "integrity": "sha512-IpmyiioeHxiWDhesHnUFmOxcTzwCwKpgACgWajtAP+nYQXiY7DakTxB6Bx9JFiRMljr0AX1PvnQdaU1KFoz6NQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jest/get-type": "30.1.0",
-        "pretty-format": "30.3.0"
+        "pretty-format": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/jest-matcher-utils": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.3.0.tgz",
-      "integrity": "sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.4.1.tgz",
+      "integrity": "sha512-zvYfX5CaeEkFrrLS9suWe9rvJrm9J1Iv3ua8kIBv9GEPzcnsfBf0bob37la7s67fs0nlBC3EuvkOLnXQKxtx4A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jest/get-type": "30.1.0",
         "chalk": "^4.1.2",
-        "jest-diff": "30.3.0",
-        "pretty-format": "30.3.0"
+        "jest-diff": "30.4.1",
+        "pretty-format": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/jest-message-util": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.3.0.tgz",
-      "integrity": "sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.4.1.tgz",
+      "integrity": "sha512-kwCKIvq0MCW1HzLoGola9Te6JUdzgV0loyKJ3Qghrkz9i5/RRIHsL95BMQc2HBBhlBKC4j22K9p11TGHH8RBpQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@types/stack-utils": "^2.0.3",
         "chalk": "^4.1.2",
         "graceful-fs": "^4.2.11",
+        "jest-util": "30.4.1",
         "picomatch": "^4.0.3",
-        "pretty-format": "30.3.0",
+        "pretty-format": "30.4.1",
         "slash": "^3.0.0",
         "stack-utils": "^2.0.6"
       },
@@ -6989,15 +6917,15 @@
       }
     },
     "node_modules/jest-mock": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.3.0.tgz",
-      "integrity": "sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.4.1.tgz",
+      "integrity": "sha512-/i8SVb8/NSB7RfNi8gfqu8gxLV23KaL5EpAttyb9iz8qWRIqXRLflycz/32wXsYkOnaUlx8NAKnJYtpsmXUmfw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
-        "jest-util": "30.3.0"
+        "jest-util": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
@@ -7022,9 +6950,9 @@
       }
     },
     "node_modules/jest-regex-util": {
-      "version": "30.0.1",
-      "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-30.0.1.tgz",
-      "integrity": "sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==",
+      "version": "30.4.0",
+      "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-30.4.0.tgz",
+      "integrity": "sha512-mWlvLviKIgIQ8VCuM1xRdD0TWp3zlzionlmDBjuXVBs+VkmXq6FgW9T4Emr7oGz/Rk6feDCGyiugolcQEyp3mg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -7032,18 +6960,18 @@
       }
     },
     "node_modules/jest-resolve": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-30.3.0.tgz",
-      "integrity": "sha512-NRtTAHQlpd15F9rUR36jqwelbrDV/dY4vzNte3S2kxCKUJRYNd5/6nTSbYiak1VX5g8IoFF23Uj5TURkUW8O5g==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-30.4.1.tgz",
+      "integrity": "sha512-Zry8Yq/yJcNAZ7dJ5F2heic8AheXvbFZ7XI5V+h28nrYZ7Qoyy4dItq8OodjnYD270mvX+ZudmrNV9cysqhW5Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "chalk": "^4.1.2",
         "graceful-fs": "^4.2.11",
-        "jest-haste-map": "30.3.0",
+        "jest-haste-map": "30.4.1",
         "jest-pnp-resolver": "^1.2.3",
-        "jest-util": "30.3.0",
-        "jest-validate": "30.3.0",
+        "jest-util": "30.4.1",
+        "jest-validate": "30.4.1",
         "slash": "^3.0.0",
         "unrs-resolver": "^1.7.11"
       },
@@ -7052,46 +6980,46 @@
       }
     },
     "node_modules/jest-resolve-dependencies": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-30.3.0.tgz",
-      "integrity": "sha512-9ev8s3YN6Hsyz9LV75XUwkCVFlwPbaFn6Wp75qnI0wzAINYWY8Fb3+6y59Rwd3QaS3kKXffHXsZMziMavfz/nw==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-30.4.2.tgz",
+      "integrity": "sha512-gDiVh1I+GxYzz9oXlyw+1wv6VOYX1WYxMOfjsA3iGKePV2oxmbHhwxfkALxNxYy1ciw6APWwkW2zZONwP97aEQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "jest-regex-util": "30.0.1",
-        "jest-snapshot": "30.3.0"
+        "jest-regex-util": "30.4.0",
+        "jest-snapshot": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
       }
     },
     "node_modules/jest-runner": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-30.3.0.tgz",
-      "integrity": "sha512-gDv6C9LGKWDPLia9TSzZwf4h3kMQCqyTpq+95PODnTRDO0g9os48XIYYkS6D236vjpBir2fF63YmJFtqkS5Duw==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-30.4.2.tgz",
+      "integrity": "sha512-2dw0PslVYXxffXGpLo+Ejad+KcI1Qkjn7f4X4619gf21oCUmL+SPfjqIa/losUem3yEOvfNZe/F1HWUcNpODcg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/console": "30.3.0",
-        "@jest/environment": "30.3.0",
-        "@jest/test-result": "30.3.0",
-        "@jest/transform": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/console": "30.4.1",
+        "@jest/environment": "30.4.1",
+        "@jest/test-result": "30.4.1",
+        "@jest/transform": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "chalk": "^4.1.2",
         "emittery": "^0.13.1",
         "exit-x": "^0.2.2",
         "graceful-fs": "^4.2.11",
-        "jest-docblock": "30.2.0",
-        "jest-environment-node": "30.3.0",
-        "jest-haste-map": "30.3.0",
-        "jest-leak-detector": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-resolve": "30.3.0",
-        "jest-runtime": "30.3.0",
-        "jest-util": "30.3.0",
-        "jest-watcher": "30.3.0",
-        "jest-worker": "30.3.0",
+        "jest-docblock": "30.4.0",
+        "jest-environment-node": "30.4.1",
+        "jest-haste-map": "30.4.1",
+        "jest-leak-detector": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-resolve": "30.4.1",
+        "jest-runtime": "30.4.2",
+        "jest-util": "30.4.1",
+        "jest-watcher": "30.4.1",
+        "jest-worker": "30.4.1",
         "p-limit": "^3.1.0",
         "source-map-support": "0.5.13"
       },
@@ -7100,32 +7028,32 @@
       }
     },
     "node_modules/jest-runtime": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-30.3.0.tgz",
-      "integrity": "sha512-CgC+hIBJbuh78HEffkhNKcbXAytQViplcl8xupqeIWyKQF50kCQA8J7GeJCkjisC6hpnC9Muf8jV5RdtdFbGng==",
+      "version": "30.4.2",
+      "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-30.4.2.tgz",
+      "integrity": "sha512-3/5e8iPz2k/VLqlr8DgTftYyLUv8Su3FkCAO2/Od81UsUTpSxOrS6O5x5KkoQwyUjmpYyDJKeyAvg2T2nvpNkQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/environment": "30.3.0",
-        "@jest/fake-timers": "30.3.0",
-        "@jest/globals": "30.3.0",
+        "@jest/environment": "30.4.1",
+        "@jest/fake-timers": "30.4.1",
+        "@jest/globals": "30.4.1",
         "@jest/source-map": "30.0.1",
-        "@jest/test-result": "30.3.0",
-        "@jest/transform": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/test-result": "30.4.1",
+        "@jest/transform": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "chalk": "^4.1.2",
         "cjs-module-lexer": "^2.1.0",
         "collect-v8-coverage": "^1.0.2",
         "glob": "^10.5.0",
         "graceful-fs": "^4.2.11",
-        "jest-haste-map": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-mock": "30.3.0",
-        "jest-regex-util": "30.0.1",
-        "jest-resolve": "30.3.0",
-        "jest-snapshot": "30.3.0",
-        "jest-util": "30.3.0",
+        "jest-haste-map": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-mock": "30.4.1",
+        "jest-regex-util": "30.4.0",
+        "jest-resolve": "30.4.1",
+        "jest-snapshot": "30.4.1",
+        "jest-util": "30.4.1",
         "slash": "^3.0.0",
         "strip-bom": "^4.0.0"
       },
@@ -7134,9 +7062,9 @@
       }
     },
     "node_modules/jest-snapshot": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.3.0.tgz",
-      "integrity": "sha512-f14c7atpb4O2DeNhwcvS810Y63wEn8O1HqK/luJ4F6M4NjvxmAKQwBUWjbExUtMxWJQ0wVgmCKymeJK6NZMnfQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.4.1.tgz",
+      "integrity": "sha512-tEOkkfOMppUyeiHwjZswOQ3lcnoTnws/q5FnGIaeIh/jmoU0ZlgMYRR8sTlTj+nNGCoJ0RDq6SfxGxCsyMTPmw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -7145,20 +7073,20 @@
         "@babel/plugin-syntax-jsx": "^7.27.1",
         "@babel/plugin-syntax-typescript": "^7.27.1",
         "@babel/types": "^7.27.3",
-        "@jest/expect-utils": "30.3.0",
+        "@jest/expect-utils": "30.4.1",
         "@jest/get-type": "30.1.0",
-        "@jest/snapshot-utils": "30.3.0",
-        "@jest/transform": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/snapshot-utils": "30.4.1",
+        "@jest/transform": "30.4.1",
+        "@jest/types": "30.4.1",
         "babel-preset-current-node-syntax": "^1.2.0",
         "chalk": "^4.1.2",
-        "expect": "30.3.0",
+        "expect": "30.4.1",
         "graceful-fs": "^4.2.11",
-        "jest-diff": "30.3.0",
-        "jest-matcher-utils": "30.3.0",
-        "jest-message-util": "30.3.0",
-        "jest-util": "30.3.0",
-        "pretty-format": "30.3.0",
+        "jest-diff": "30.4.1",
+        "jest-matcher-utils": "30.4.1",
+        "jest-message-util": "30.4.1",
+        "jest-util": "30.4.1",
+        "pretty-format": "30.4.1",
         "semver": "^7.7.2",
         "synckit": "^0.11.8"
       },
@@ -7167,9 +7095,9 @@
       }
     },
     "node_modules/jest-snapshot/node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.0.tgz",
+      "integrity": "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -7180,13 +7108,13 @@
       }
     },
     "node_modules/jest-util": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.3.0.tgz",
-      "integrity": "sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.4.1.tgz",
+      "integrity": "sha512-vjQb1sACEiv13DKJMDToJpzVW0joCsIQrmbg0fi7CyOOt+g9jTuQl2A216pWRBYhOVt53XbL/2LbMKg1BECWOw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "chalk": "^4.1.2",
         "ci-info": "^4.2.0",
@@ -7198,18 +7126,18 @@
       }
     },
     "node_modules/jest-validate": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-30.3.0.tgz",
-      "integrity": "sha512-I/xzC8h5G+SHCb2P2gWkJYrNiTbeL47KvKeW5EzplkyxzBRBw1ssSHlI/jXec0ukH2q7x2zAWQm7015iusg62Q==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-30.4.1.tgz",
+      "integrity": "sha512-PDWi4SOwLnwqNDfHZjOcsEFyZ4fc/2W2gVL3DEoyqnB6jCQMLRtfBong8s6omIw3lI0HWOus12xfnFmQtjW3fw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@jest/get-type": "30.1.0",
-        "@jest/types": "30.3.0",
+        "@jest/types": "30.4.1",
         "camelcase": "^6.3.0",
         "chalk": "^4.1.2",
         "leven": "^3.1.0",
-        "pretty-format": "30.3.0"
+        "pretty-format": "30.4.1"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
@@ -7229,19 +7157,19 @@
       }
     },
     "node_modules/jest-watcher": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-30.3.0.tgz",
-      "integrity": "sha512-PJ1d9ThtTR8aMiBWUdcownq9mDdLXsQzJayTk4kmaBRHKvwNQn+ANveuhEBUyNI2hR1TVhvQ8D5kHubbzBHR/w==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-30.4.1.tgz",
+      "integrity": "sha512-/l9UonmvCwjHH7d2h3iAwIloLc1H0S8mJZ/LNK3i86hqwPAz8otUJjP9MfYtz9Tt77Su5FD2xGjZn8d31IZHlw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/test-result": "30.3.0",
-        "@jest/types": "30.3.0",
+        "@jest/test-result": "30.4.1",
+        "@jest/types": "30.4.1",
         "@types/node": "*",
         "ansi-escapes": "^4.3.2",
         "chalk": "^4.1.2",
         "emittery": "^0.13.1",
-        "jest-util": "30.3.0",
+        "jest-util": "30.4.1",
         "string-length": "^4.0.2"
       },
       "engines": {
@@ -7249,15 +7177,15 @@
       }
     },
     "node_modules/jest-worker": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.3.0.tgz",
-      "integrity": "sha512-DrCKkaQwHexjRUFTmPzs7sHQe0TSj9nvDALKGdwmK5mW9v7j90BudWirKAJHt3QQ9Dhrg1F7DogPzhChppkJpQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.4.1.tgz",
+      "integrity": "sha512-SHynN/q/QD++iNyvMdy+WMmbCGk8jIsNcRxycXbWubSOhvo6T+j2afcfUSl+3hYsiBebOTo0cT7c2H7CXugu1g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/node": "*",
         "@ungap/structured-clone": "^1.3.0",
-        "jest-util": "30.3.0",
+        "jest-util": "30.4.1",
         "merge-stream": "^2.0.0",
         "supports-color": "^8.1.1"
       },
@@ -7779,55 +7707,53 @@
       "license": "MIT"
     },
     "node_modules/neostandard": {
-      "version": "0.12.2",
-      "resolved": "https://registry.npmjs.org/neostandard/-/neostandard-0.12.2.tgz",
-      "integrity": "sha512-VZU8EZpSaNadp3rKEwBhVD1Kw8jE3AftQLkCyOaM7bWemL1LwsYRsBnAmXy2LjG9zO8t66qJdqB7ccwwORyrAg==",
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/neostandard/-/neostandard-0.13.0.tgz",
+      "integrity": "sha512-R3iglFr+Dla/8qFBqsMxBvcYBOgP6rAGw7uRHKMpM3bUP0wLDRzUstxtEI9RfEwn7xszE/UUnh8H090Ru4Z52A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@humanwhocodes/gitignore-to-minimatch": "^1.0.2",
         "@stylistic/eslint-plugin": "2.11.0",
-        "eslint-import-resolver-typescript": "^3.10.1",
-        "eslint-plugin-import-x": "^4.16.1",
-        "eslint-plugin-n": "^17.20.0",
+        "eslint-plugin-n": "^17.23.2",
         "eslint-plugin-promise": "^7.2.1",
         "eslint-plugin-react": "^7.37.5",
-        "find-up": "^5.0.0",
-        "globals": "^15.15.0",
-        "peowly": "^1.3.2",
-        "typescript-eslint": "^8.35.1"
+        "find-up": "^8.0.0",
+        "globals": "^17.3.0",
+        "peowly": "^1.3.3",
+        "typescript-eslint": "^8.56.0"
       },
       "bin": {
         "neostandard": "cli.mjs"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "peerDependencies": {
         "eslint": "^9.0.0"
       }
     },
     "node_modules/neostandard/node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-8.0.0.tgz",
+      "integrity": "sha512-JGG8pvDi2C+JxidYdIwQDyS/CgcrIdh18cvgxcBge3wSHRQOrooMD3GlFBcmMJAN9M42SAZjDp5zv1dglJjwww==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
+        "locate-path": "^8.0.0",
+        "unicorn-magic": "^0.3.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/neostandard/node_modules/globals": {
-      "version": "15.15.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz",
-      "integrity": "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==",
+      "version": "17.6.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.6.0.tgz",
+      "integrity": "sha512-sepffkT8stwnIYbsMBpoCHJuJM5l98FUF2AnE07hfvE0m/qp3R586hw4jF4uadbhvg1ooIdzuu7CsfD2jzCaNA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -7838,47 +7764,34 @@
       }
     },
     "node_modules/neostandard/node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-8.0.0.tgz",
+      "integrity": "sha512-XT9ewWAC43tiAV7xDAPflMkG0qOPn2QjHqlgX8FOqmWa/rxnyYDulF9T0F7tRy1u+TVTmK/M//6VIOye+2zDXg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "p-locate": "^5.0.0"
+        "p-locate": "^6.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/neostandard/node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+    "node_modules/neostandard/node_modules/unicorn-magic": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/neostandard/node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/node-exports-info": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.0.tgz",
@@ -7916,9 +7829,9 @@
       "license": "MIT"
     },
     "node_modules/node-releases": {
-      "version": "2.0.37",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz",
-      "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==",
+      "version": "2.0.44",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.44.tgz",
+      "integrity": "sha512-5WUyunoPMsvvEhS8AxHtRzP+oA8UCkJ7YRxatWKjngndhDGLiqEVAQKWjFAiAiuL8zMRGzGSJxFnLetoa43qGQ==",
       "dev": true,
       "license": "MIT"
     },
@@ -8525,15 +8438,16 @@
       }
     },
     "node_modules/pretty-format": {
-      "version": "30.3.0",
-      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.3.0.tgz",
-      "integrity": "sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==",
+      "version": "30.4.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.4.1.tgz",
+      "integrity": "sha512-K6KiKMHTL4jjX4u3Kir2EW07nRfcqVTXIImx50wbjHQTcZPgg+gjVeNTIT3l3L1Rd4UefxfogquC9J37SoFyyw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@jest/schemas": "30.0.5",
+        "@jest/schemas": "30.4.1",
         "ansi-styles": "^5.2.0",
-        "react-is": "^18.3.1"
+        "react-is-18": "npm:react-is@^18.3.1",
+        "react-is-19": "npm:react-is@^19.2.5"
       },
       "engines": {
         "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
@@ -8670,6 +8584,22 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/react-is-18": {
+      "name": "react-is",
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/react-is-19": {
+      "name": "react-is",
+      "version": "19.2.6",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.6.tgz",
+      "integrity": "sha512-XjBR15BhXuylgWGuslhDKqlSayuqvqBX91BP8pauG8kd1zY8kotkNWbXksTCNRarse4kuGbe2kIY05ARtwNIvw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/read-pkg": {
       "version": "5.2.0",
       "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz",
@@ -9325,23 +9255,6 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
-    "node_modules/stable-hash": {
-      "version": "0.0.5",
-      "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
-      "integrity": "sha512-+L3ccpzibovGXFK+Ap/f8LOS0ahMrHTf3xu7mMLSpEGU0EO9ucaysSylKo9eRDFNhWve/y275iPmIZ4z39a9iA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/stable-hash-x": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/stable-hash-x/-/stable-hash-x-0.2.0.tgz",
-      "integrity": "sha512-o3yWv49B/o4QZk5ZcsALc6t0+eCelPc44zZsLtCQnZPDwFpDYSWcDnrv2TtMmMbQ7uKo3J0HTURCqckw23czNQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      }
-    },
     "node_modules/stack-utils": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
@@ -9738,18 +9651,18 @@
       }
     },
     "node_modules/test-exclude": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.2.tgz",
-      "integrity": "sha512-u9E6A+ZDYdp7a4WnarkXPZOx8Ilz46+kby6p1yZ8zsGTz9gYa6FIS7lj2oezzNKmtdyyJNNmmXDppga5GB7kSw==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-8.0.0.tgz",
+      "integrity": "sha512-ZOffsNrXYggvU1mDGHk54I96r26P8SyMjO5slMKSc7+IWmtB/MQKnEC2fP51imB3/pT6YK5cT5E8f+Dd9KdyOQ==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
         "@istanbuljs/schema": "^0.1.2",
-        "glob": "^10.4.1",
+        "glob": "^13.0.6",
         "minimatch": "^10.2.2"
       },
       "engines": {
-        "node": ">=18"
+        "node": "20 || >=22"
       }
     },
     "node_modules/test-exclude/node_modules/balanced-match": {
@@ -9775,6 +9688,34 @@
         "node": "18 || 20 || >=22"
       }
     },
+    "node_modules/test-exclude/node_modules/glob": {
+      "version": "13.0.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
+      "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "minimatch": "^10.2.2",
+        "minipass": "^7.1.3",
+        "path-scurry": "^2.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/test-exclude/node_modules/lru-cache": {
+      "version": "11.3.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.3.5.tgz",
+      "integrity": "sha512-NxVFwLAnrd9i7KUBxC4DrUhmgjzOs+1Qm50D3oF1/oL+r1NpZ4gA7xvG0/zJ8evR7zIKn4vLf7qTNduWFtCrRw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
     "node_modules/test-exclude/node_modules/minimatch": {
       "version": "10.2.5",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
@@ -9791,6 +9732,23 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/test-exclude/node_modules/path-scurry": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.16",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
@@ -10103,9 +10061,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.2.tgz",
-      "integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
diff --git a/deps/undici/src/package.json b/deps/undici/src/package.json
index 082c56a4783ae1..b9d007ade7cf0c 100644
--- a/deps/undici/src/package.json
+++ b/deps/undici/src/package.json
@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -115,8 +115,8 @@
     "@sinonjs/fake-timers": "^12.0.0",
     "@types/node": "^22.0.0",
     "abort-controller": "^3.0.0",
-    "borp": "^0.20.0",
-    "c8": "^10.0.0",
+    "borp": "^1.0.0",
+    "c8": "^11.0.0",
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
@@ -125,7 +125,7 @@
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.12.0",
+    "neostandard": "^0.13.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",
diff --git a/deps/undici/src/types/client.d.ts b/deps/undici/src/types/client.d.ts
index 13b7bf5899454d..530a94583898a9 100644
--- a/deps/undici/src/types/client.d.ts
+++ b/deps/undici/src/types/client.d.ts
@@ -3,7 +3,7 @@ import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 import TClientStats from './client-stats'
 
-type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>
 
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
@@ -20,12 +20,12 @@ export class Client extends Dispatcher {
   readonly stats: TClientStats
 
   // Override dispatcher APIs.
-  override connect (
-    options: ClientConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
-    options: ClientConnectOptions,
-    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>
+  ): Promise<Dispatcher.ConnectData<TOpaque>>
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>,
+    callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void
   ): void
 }
 
diff --git a/deps/undici/src/types/dispatcher.d.ts b/deps/undici/src/types/dispatcher.d.ts
index 40a75de6743506..f732ec45cc97f7 100644
--- a/deps/undici/src/types/dispatcher.d.ts
+++ b/deps/undici/src/types/dispatcher.d.ts
@@ -121,8 +121,6 @@ declare namespace Dispatcher {
     bodyTimeout?: number | null;
     /** Whether the request should stablish a keep-alive or not. Default `false` */
     reset?: boolean;
-    /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
-    throwOnError?: boolean;
     /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
     expectContinue?: boolean;
   }
diff --git a/deps/undici/src/types/formdata.d.ts b/deps/undici/src/types/formdata.d.ts
index 5244e04559fe5a..b9819a7e725d49 100644
--- a/deps/undici/src/types/formdata.d.ts
+++ b/deps/undici/src/types/formdata.d.ts
@@ -4,12 +4,6 @@
 import { File } from 'node:buffer'
 import { SpecIterableIterator } from './fetch'
 
-declare module 'node:buffer' {
-  interface File {
-    readonly [Symbol.toStringTag]: string
-  }
-}
-
 /**
  * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
  */
diff --git a/deps/undici/src/types/snapshot-agent.d.ts b/deps/undici/src/types/snapshot-agent.d.ts
index f1d1ccdbb4d2f2..9696b604f5a7c8 100644
--- a/deps/undici/src/types/snapshot-agent.d.ts
+++ b/deps/undici/src/types/snapshot-agent.d.ts
@@ -30,7 +30,9 @@ declare namespace SnapshotRecorder {
     ignoreHeaders?: string[]
     excludeHeaders?: string[]
     matchBody?: boolean
+    normalizeBody?: (body: string | Buffer | null | undefined) => string
     matchQuery?: boolean
+    normalizeQuery?: (query: URLSearchParams) => string
     caseSensitive?: boolean
     shouldRecord?: (requestOpts: any) => boolean
     shouldPlayback?: (requestOpts: any) => boolean
@@ -98,7 +100,9 @@ declare namespace SnapshotAgent {
     ignoreHeaders?: string[]
     excludeHeaders?: string[]
     matchBody?: boolean
+    normalizeBody?: (body: string | Buffer | null | undefined) => string
     matchQuery?: boolean
+    normalizeQuery?: (query: URLSearchParams) => string
     caseSensitive?: boolean
     shouldRecord?: (requestOpts: any) => boolean
     shouldPlayback?: (requestOpts: any) => boolean
diff --git a/deps/undici/undici.js b/deps/undici/undici.js
index 86f020015b22c2..20e38982a91d47 100644
--- a/deps/undici/undici.js
+++ b/deps/undici/undici.js
@@ -556,6 +556,7 @@ var require_symbols = __commonJS({
       kListeners: /* @__PURE__ */ Symbol("listeners"),
       kHTTPContext: /* @__PURE__ */ Symbol("http context"),
       kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"),
+      kHostAuthority: /* @__PURE__ */ Symbol("host authority"),
       kHTTP2InitialWindowSize: /* @__PURE__ */ Symbol("http2 initial window size"),
       kHTTP2ConnectionWindowSize: /* @__PURE__ */ Symbol("http2 connection window size"),
       kEnableConnectProtocol: /* @__PURE__ */ Symbol("http2session connect protocol"),
@@ -901,6 +902,7 @@ var require_pool_base = __commonJS({
     var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect");
     var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError");
     var kGetDispatcher = /* @__PURE__ */ Symbol("get dispatcher");
+    var kHasDispatcher = /* @__PURE__ */ Symbol("has dispatcher");
     var kAddClient = /* @__PURE__ */ Symbol("add client");
     var kRemoveClient = /* @__PURE__ */ Symbol("remove client");
     var PoolBase = class extends DispatcherBase {
@@ -1026,10 +1028,19 @@ var require_pool_base = __commonJS({
           this[kQueued]++;
         } else if (!dispatcher.dispatch(opts, handler)) {
           dispatcher[kNeedDrain] = true;
-          this[kNeedDrain] = !this[kGetDispatcher]();
+          this[kNeedDrain] = !this[kHasDispatcher]();
         }
         return !this[kNeedDrain];
       }
+      [kHasDispatcher]() {
+        for (let i = 0; i < this[kClients].length; i++) {
+          const dispatcher = this[kClients][i];
+          if (!dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true) {
+            return true;
+          }
+        }
+        return false;
+      }
       [kAddClient](client) {
         client.on("drain", this[kOnDrain].bind(this, client)).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
         this[kClients].push(client);
@@ -1049,7 +1060,7 @@ var require_pool_base = __commonJS({
         }
         client.close(() => {
         });
-        this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
+        this[kNeedDrain] = !this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
       }
     };
     module2.exports = {
@@ -1058,7 +1069,8 @@ var require_pool_base = __commonJS({
       kNeedDrain,
       kAddClient,
       kRemoveClient,
-      kGetDispatcher
+      kGetDispatcher,
+      kHasDispatcher
     };
   }
 });
@@ -2283,14 +2295,14 @@ var require_util = __commonJS({
       return !headerCharRegex.test(characters);
     }
     __name(isValidHeaderValue, "isValidHeaderValue");
-    var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/;
+    var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+|\*)?$/;
     function parseRangeHeader(range) {
       if (range == null || range === "") return { start: 0, end: null, size: null };
       const m = range ? range.match(rangeHeaderRegex) : null;
       return m ? {
         start: parseInt(m[1]),
         end: m[2] ? parseInt(m[2]) : null,
-        size: m[3] ? parseInt(m[3]) : null
+        size: m[3] && m[3] !== "*" ? parseInt(m[3]) : null
       } : null;
     }
     __name(parseRangeHeader, "parseRangeHeader");
@@ -6040,6 +6052,86 @@ var require_util2 = __commonJS({
   }
 });
 
+// lib/util/runtime-features.js
+var require_runtime_features = __commonJS({
+  "lib/util/runtime-features.js"(exports2, module2) {
+    "use strict";
+    var lazyLoaders = {
+      __proto__: null,
+      "node:crypto": /* @__PURE__ */ __name(() => require("node:crypto"), "node:crypto"),
+      "node:sqlite": /* @__PURE__ */ __name(() => require("node:sqlite"), "node:sqlite")
+    };
+    function detectRuntimeFeatureByNodeModule(moduleName) {
+      try {
+        lazyLoaders[moduleName]();
+        return true;
+      } catch (err) {
+        if (err.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && err.code !== "ERR_NO_CRYPTO") {
+          throw err;
+        }
+        return false;
+      }
+    }
+    __name(detectRuntimeFeatureByNodeModule, "detectRuntimeFeatureByNodeModule");
+    var runtimeFeaturesAsNodeModule = (
+      /** @type {const} */
+      ["crypto", "sqlite"]
+    );
+    function detectRuntimeFeature(feature) {
+      if (runtimeFeaturesAsNodeModule.includes(
+        /** @type {RuntimeFeatureByNodeModule} */
+        feature
+      )) {
+        return detectRuntimeFeatureByNodeModule(`node:${feature}`);
+      }
+      throw new TypeError(`unknown feature: ${feature}`);
+    }
+    __name(detectRuntimeFeature, "detectRuntimeFeature");
+    var RuntimeFeatures = class {
+      static {
+        __name(this, "RuntimeFeatures");
+      }
+      /** @type {Map<Feature, boolean>} */
+      #map = /* @__PURE__ */ new Map();
+      /**
+       * Clears all cached feature detections.
+       */
+      clear() {
+        this.#map.clear();
+      }
+      /**
+       * @param {Feature} feature
+       * @returns {boolean}
+       */
+      has(feature) {
+        return this.#map.get(feature) ?? this.#detectRuntimeFeature(feature);
+      }
+      /**
+       * @param {Feature} feature
+       * @param {boolean} value
+       */
+      set(feature, value) {
+        if (runtimeFeaturesAsNodeModule.includes(feature) === false) {
+          throw new TypeError(`unknown feature: ${feature}`);
+        }
+        this.#map.set(feature, value);
+      }
+      /**
+       * @param {Feature} feature
+       * @returns {boolean}
+       */
+      #detectRuntimeFeature(feature) {
+        const result = detectRuntimeFeature(feature);
+        this.#map.set(feature, result);
+        return result;
+      }
+    };
+    var instance = new RuntimeFeatures();
+    module2.exports.runtimeFeatures = instance;
+    module2.exports.default = instance;
+  }
+});
+
 // lib/web/fetch/formdata.js
 var require_formdata = __commonJS({
   "lib/web/fetch/formdata.js"(exports2, module2) {
@@ -6048,11 +6140,14 @@ var require_formdata = __commonJS({
     var { kEnumerableProperty } = require_util();
     var { webidl } = require_webidl();
     var nodeUtil = require("node:util");
+    var { runtimeFeatures } = require_runtime_features();
+    var random = runtimeFeatures.has("crypto") ? require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
     var FormData = class _FormData {
       static {
         __name(this, "FormData");
       }
       #state = [];
+      #boundary = null;
       constructor(form = void 0) {
         webidl.util.markAsUncloneable(this);
         if (form !== void 0) {
@@ -6167,10 +6262,20 @@ var require_formdata = __commonJS({
       static setFormDataState(formData, newState) {
         formData.#state = newState;
       }
+      /**
+       * @param {FormData} formData
+       * @returns {string | null}
+       */
+      static getFormDataBoundary(formData) {
+        const boundary = formData.#boundary;
+        if (boundary != null) return boundary;
+        return formData.#boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
+      }
     };
-    var { getFormDataState, setFormDataState } = FormData;
+    var { getFormDataState, setFormDataState, getFormDataBoundary } = FormData;
     Reflect.deleteProperty(FormData, "getFormDataState");
     Reflect.deleteProperty(FormData, "setFormDataState");
+    Reflect.deleteProperty(FormData, "getFormDataBoundary");
     iteratorMixin("FormData", FormData, getFormDataState, "name", "value");
     Object.defineProperties(FormData.prototype, {
       append: kEnumerableProperty,
@@ -6202,7 +6307,7 @@ var require_formdata = __commonJS({
     }
     __name(makeEntry, "makeEntry");
     webidl.is.FormData = webidl.util.MakeTypeAssertion(FormData);
-    module2.exports = { FormData, makeEntry, setFormDataState };
+    module2.exports = { FormData, makeEntry, setFormDataState, getFormDataBoundary };
   }
 });
 
@@ -6548,86 +6653,6 @@ var require_formdata_parser = __commonJS({
   }
 });
 
-// lib/util/runtime-features.js
-var require_runtime_features = __commonJS({
-  "lib/util/runtime-features.js"(exports2, module2) {
-    "use strict";
-    var lazyLoaders = {
-      __proto__: null,
-      "node:crypto": /* @__PURE__ */ __name(() => require("node:crypto"), "node:crypto"),
-      "node:sqlite": /* @__PURE__ */ __name(() => require("node:sqlite"), "node:sqlite")
-    };
-    function detectRuntimeFeatureByNodeModule(moduleName) {
-      try {
-        lazyLoaders[moduleName]();
-        return true;
-      } catch (err) {
-        if (err.code !== "ERR_UNKNOWN_BUILTIN_MODULE" && err.code !== "ERR_NO_CRYPTO") {
-          throw err;
-        }
-        return false;
-      }
-    }
-    __name(detectRuntimeFeatureByNodeModule, "detectRuntimeFeatureByNodeModule");
-    var runtimeFeaturesAsNodeModule = (
-      /** @type {const} */
-      ["crypto", "sqlite"]
-    );
-    function detectRuntimeFeature(feature) {
-      if (runtimeFeaturesAsNodeModule.includes(
-        /** @type {RuntimeFeatureByNodeModule} */
-        feature
-      )) {
-        return detectRuntimeFeatureByNodeModule(`node:${feature}`);
-      }
-      throw new TypeError(`unknown feature: ${feature}`);
-    }
-    __name(detectRuntimeFeature, "detectRuntimeFeature");
-    var RuntimeFeatures = class {
-      static {
-        __name(this, "RuntimeFeatures");
-      }
-      /** @type {Map<Feature, boolean>} */
-      #map = /* @__PURE__ */ new Map();
-      /**
-       * Clears all cached feature detections.
-       */
-      clear() {
-        this.#map.clear();
-      }
-      /**
-       * @param {Feature} feature
-       * @returns {boolean}
-       */
-      has(feature) {
-        return this.#map.get(feature) ?? this.#detectRuntimeFeature(feature);
-      }
-      /**
-       * @param {Feature} feature
-       * @param {boolean} value
-       */
-      set(feature, value) {
-        if (runtimeFeaturesAsNodeModule.includes(feature) === false) {
-          throw new TypeError(`unknown feature: ${feature}`);
-        }
-        this.#map.set(feature, value);
-      }
-      /**
-       * @param {Feature} feature
-       * @returns {boolean}
-       */
-      #detectRuntimeFeature(feature) {
-        const result = detectRuntimeFeature(feature);
-        this.#map.set(feature, result);
-        return result;
-      }
-    };
-    var instance = new RuntimeFeatures();
-    module2.exports.runtimeFeatures = instance;
-    module2.exports.default = instance;
-  }
-});
-
 // lib/web/fetch/body.js
 var require_body = __commonJS({
   "lib/web/fetch/body.js"(exports2, module2) {
@@ -6639,7 +6664,7 @@ var require_body = __commonJS({
       fullyReadBody,
       extractMimeType
     } = require_util2();
-    var { FormData, setFormDataState } = require_formdata();
+    var { FormData, setFormDataState, getFormDataBoundary } = require_formdata();
     var { webidl } = require_webidl();
     var assert = require("node:assert");
     var { isErrored, isDisturbed } = require("node:stream");
@@ -6648,8 +6673,6 @@ var require_body = __commonJS({
     var { multipartFormDataParser } = require_formdata_parser();
     var { parseJSONFromBytes } = require_infra();
     var { utf8DecodeBytes } = require_encoding();
-    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() {
     }
@@ -6693,7 +6716,7 @@ var require_body = __commonJS({
       } else if (webidl.is.BufferSource(object)) {
         source = webidl.util.getCopyOfBytesHeldByBufferSource(object);
       } else if (webidl.is.FormData(object)) {
-        const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
+        const boundary = getFormDataBoundary(object);
         const prefix = `--${boundary}\r
 Content-Disposition: form-data`;
         const formdataEscape = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "formdataEscape");
@@ -7211,19 +7234,47 @@ var require_client_h1 = __commonJS({
               this.paused = true;
               socket.unshift(data);
             } else {
-              const ptr = llhttp.llhttp_get_error_reason(this.ptr);
-              let message = "";
-              if (ptr) {
-                const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
-                message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
-              }
-              throw new HTTPParserError(message, constants.ERROR[ret], data);
+              throw this.createError(ret, data);
             }
           }
         } catch (err) {
           util.destroy(socket, err);
         }
       }
+      finish() {
+        assert(currentParser === null);
+        assert(this.ptr != null);
+        assert(!this.paused);
+        const { llhttp } = this;
+        let ret;
+        try {
+          currentParser = this;
+          ret = llhttp.llhttp_finish(this.ptr);
+        } finally {
+          currentParser = null;
+        }
+        if (ret === constants.ERROR.OK) {
+          return null;
+        }
+        if (ret === constants.ERROR.PAUSED || ret === constants.ERROR.PAUSED_UPGRADE) {
+          this.paused = true;
+          return null;
+        }
+        return this.createError(ret, EMPTY_BUF);
+      }
+      createError(ret, data) {
+        const { llhttp, contentLength, bytesRead } = this;
+        if (contentLength !== -1 && bytesRead !== contentLength) {
+          return new ResponseContentLengthMismatchError();
+        }
+        const ptr = llhttp.llhttp_get_error_reason(this.ptr);
+        let message = "";
+        if (ptr) {
+          const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
+          message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
+        }
+        return new HTTPParserError(message, constants.ERROR[ret], data);
+      }
       destroy() {
         assert(currentParser === null);
         assert(this.ptr != null);
@@ -7607,7 +7658,11 @@ var require_client_h1 = __commonJS({
       assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
       const parser = this[kParser];
       if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
-        parser.onMessageComplete();
+        const parserErr = parser.finish();
+        if (parserErr) {
+          this[kError] = parserErr;
+          this[kClient][kOnError](parserErr);
+        }
         return;
       }
       this[kError] = err;
@@ -7621,7 +7676,10 @@ var require_client_h1 = __commonJS({
     function onHttpSocketEnd() {
       const parser = this[kParser];
       if (parser.statusCode && !parser.shouldKeepAlive) {
-        parser.onMessageComplete();
+        const parserErr = parser.finish();
+        if (parserErr) {
+          util.destroy(this, parserErr);
+        }
         return;
       }
       util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
@@ -7631,7 +7689,7 @@ var require_client_h1 = __commonJS({
       const parser = this[kParser];
       if (parser) {
         if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-          parser.onMessageComplete();
+          this[kError] = parser.finish() || this[kError];
         }
         this[kParser].destroy();
         this[kParser] = null;
@@ -7920,7 +7978,6 @@ upgrade: ${upgrade}\r
     }
     __name(writeBuffer, "writeBuffer");
     async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) {
-      assert(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
           throw new RequestContentLengthMismatchError();
@@ -8149,6 +8206,7 @@ var require_client_h2 = __commonJS({
       kHTTP2Session,
       kHTTP2InitialWindowSize,
       kHTTP2ConnectionWindowSize,
+      kHostAuthority,
       kResume,
       kSize,
       kHTTPContext,
@@ -8164,8 +8222,7 @@ var require_client_h2 = __commonJS({
     var kRequestStreamId = /* @__PURE__ */ Symbol("request stream id");
     var kRequestStream = /* @__PURE__ */ Symbol("request stream");
     var kRequestStreamCleanup = /* @__PURE__ */ Symbol("request stream cleanup");
-    var kRequestStreamOnData = /* @__PURE__ */ Symbol("request stream on data");
-    var kRequestStreamOnCloseError = /* @__PURE__ */ Symbol("request stream on close error");
+    var kRequestStreamState = /* @__PURE__ */ Symbol("request stream state");
     var kReceivedGoAway = /* @__PURE__ */ Symbol("received goaway");
     var extractBody;
     var http2;
@@ -8214,8 +8271,9 @@ var require_client_h2 = __commonJS({
     __name(detachRequestFromStream, "detachRequestFromStream");
     function bindRequestToStream(request, stream, cleanup) {
       const previousCleanup = request[kRequestStreamCleanup];
+      const previousStream = request[kRequestStream];
       detachRequestFromStream(request);
-      previousCleanup?.();
+      previousCleanup?.(previousStream);
       request[kRequestStreamId] = stream.id;
       request[kRequestStream] = stream;
       request[kRequestStreamCleanup] = cleanup;
@@ -8223,8 +8281,9 @@ var require_client_h2 = __commonJS({
     __name(bindRequestToStream, "bindRequestToStream");
     function clearRequestStream(request) {
       const cleanup = request[kRequestStreamCleanup];
+      const stream = request[kRequestStream];
       detachRequestFromStream(request);
-      cleanup?.();
+      cleanup?.(stream);
     }
     __name(clearRequestStream, "clearRequestStream");
     function canRetryRequestAfterGoAway(request) {
@@ -8530,62 +8589,148 @@ var require_client_h2 = __commonJS({
     __name(closeStreamSession, "closeStreamSession");
     function onUpgradeStreamClose() {
       this.off("error", noop);
-      const failUpgradeStream = this[kRequestStreamOnCloseError];
-      this[kRequestStreamOnCloseError] = null;
-      failUpgradeStream(new InformationalError("HTTP/2: stream closed before response headers"));
+      const state = this[kRequestStreamState];
+      this[kRequestStreamState] = null;
+      failUpgradeStream(state, new InformationalError("HTTP/2: stream closed before response headers"));
       closeStreamSession(this);
     }
     __name(onUpgradeStreamClose, "onUpgradeStreamClose");
     function onRequestStreamClose() {
-      const onData = this[kRequestStreamOnData];
-      this[kRequestStreamOnData] = null;
       this.off("data", onData);
       this.off("error", noop);
       closeStreamSession(this);
+      this[kRequestStreamState] = null;
     }
     __name(onRequestStreamClose, "onRequestStreamClose");
     function shouldSendContentLength(method) {
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
     __name(shouldSendContentLength, "shouldSendContentLength");
-    function writeH2(client, request) {
-      const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout];
-      const session = client[kHTTP2Session];
-      const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
-      let { body } = request;
-      if (upgrade != null && upgrade !== "websocket") {
-        util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
-        return false;
-      }
+    function buildRequestHeaders(reqHeaders) {
       const headers = {};
       for (let n = 0; n < reqHeaders.length; n += 2) {
         const key = reqHeaders[n + 0];
         const val = reqHeaders[n + 1];
+        const current = headers[key];
         if (key === "cookie") {
-          if (headers[key] != null) {
-            headers[key] = Array.isArray(headers[key]) ? (headers[key].push(val), headers[key]) : [headers[key], val];
+          if (current != null) {
+            headers[key] = Array.isArray(current) ? (current.push(val), current) : [current, val];
           } else {
             headers[key] = val;
           }
           continue;
         }
-        if (Array.isArray(val)) {
-          for (let i = 0; i < val.length; i++) {
-            if (headers[key]) {
-              headers[key] += `, ${val[i]}`;
-            } else {
-              headers[key] = val[i];
-            }
-          }
-        } else if (headers[key]) {
-          headers[key] += `, ${val}`;
-        } else {
-          headers[key] = val;
+        if (typeof val === "string") {
+          headers[key] = current ? `${current}, ${val}` : val;
+          continue;
+        }
+        for (let i = 0; i < val.length; i++) {
+          headers[key] = headers[key] ? `${headers[key]}, ${val[i]}` : val[i];
         }
       }
+      return headers;
+    }
+    __name(buildRequestHeaders, "buildRequestHeaders");
+    function removeUpgradeStreamListeners(stream) {
+      stream.off("response", onUpgradeResponse);
+      stream.off("error", onUpgradeStreamError);
+      stream.off("end", onUpgradeStreamEnd);
+      stream.off("timeout", onUpgradeStreamTimeout);
+      stream.off("error", noop);
+    }
+    __name(removeUpgradeStreamListeners, "removeUpgradeStreamListeners");
+    function releaseUpgradeStream(stream) {
+      if (stream == null) {
+        return;
+      }
+      const state = stream[kRequestStreamState];
+      if (state == null) {
+        return;
+      }
+      const { request } = state;
+      if (request[kRequestStream] === stream) {
+        detachRequestFromStream(request);
+      }
+      removeUpgradeStreamListeners(stream);
+      if (!stream.destroyed && !stream.closed) {
+        stream.once("error", noop);
+      }
+    }
+    __name(releaseUpgradeStream, "releaseUpgradeStream");
+    function failUpgradeStream(state, err) {
+      if (state == null) {
+        return;
+      }
+      const { request } = state;
+      if (state.responseReceived || request.aborted || request.completed) {
+        return;
+      }
+      releaseUpgradeStream(state.stream);
+      state.abort(err, true);
+    }
+    __name(failUpgradeStream, "failUpgradeStream");
+    function onUpgradeStreamError() {
+      const state = this[kRequestStreamState];
+      if (typeof this.rstCode === "number" && this.rstCode !== 0) {
+        failUpgradeStream(state, new InformationalError(`HTTP/2: "stream error" received - code ${this.rstCode}`));
+      } else {
+        failUpgradeStream(state, new InformationalError("HTTP/2: stream errored before response headers"));
+      }
+    }
+    __name(onUpgradeStreamError, "onUpgradeStreamError");
+    function onUpgradeStreamEnd() {
+      failUpgradeStream(this[kRequestStreamState], new InformationalError("HTTP/2: stream half-closed (remote)"));
+    }
+    __name(onUpgradeStreamEnd, "onUpgradeStreamEnd");
+    function onUpgradeStreamTimeout() {
+      const state = this[kRequestStreamState];
+      failUpgradeStream(state, new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`));
+    }
+    __name(onUpgradeStreamTimeout, "onUpgradeStreamTimeout");
+    function onUpgradeResponse(headers, _flags) {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      const { request } = state;
+      state.responseReceived = true;
+      const statusCode = headers[HTTP2_HEADER_STATUS];
+      delete headers[HTTP2_HEADER_STATUS];
+      request.onRequestUpgrade(statusCode, headers, stream);
+      if (request.aborted || request.completed) {
+        return;
+      }
+      removeUpgradeStreamListeners(stream);
+      detachRequestFromStream(request);
+      state.finalizeRequest();
+    }
+    __name(onUpgradeResponse, "onUpgradeResponse");
+    function setupUpgradeStream(stream, state) {
+      const { request, requestTimeout, session } = state;
+      stream[kHTTP2Stream] = true;
+      stream[kHTTP2Session] = session;
+      stream[kRequestStreamState] = state;
+      state.stream = stream;
+      bindRequestToStream(request, stream, releaseUpgradeStream);
+      stream.once("response", onUpgradeResponse);
+      stream.on("error", onUpgradeStreamError);
+      stream.once("end", onUpgradeStreamEnd);
+      stream.on("timeout", onUpgradeStreamTimeout);
+      stream.once("close", onUpgradeStreamClose);
+      ++session[kOpenStreams];
+      stream.setTimeout(requestTimeout);
+    }
+    __name(setupUpgradeStream, "setupUpgradeStream");
+    function writeH2(client, request) {
+      const requestTimeout = request.bodyTimeout ?? client[kBodyTimeout];
+      const session = client[kHTTP2Session];
+      const { method, path, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
+      let { body } = request;
+      if (upgrade != null && upgrade !== "websocket") {
+        util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
+        return false;
+      }
+      const headers = buildRequestHeaders(reqHeaders);
       let stream = null;
-      const { hostname, port } = client[kUrl];
-      headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`;
+      headers[HTTP2_HEADER_AUTHORITY] = host || client[kHostAuthority];
       headers[HTTP2_HEADER_METHOD] = method;
       let requestFinalized = false;
       const finalizeRequest = /* @__PURE__ */ __name((resetPendingIdx = false) => {
@@ -8639,67 +8784,15 @@ var require_client_h2 = __commonJS({
       }
       if (upgrade || method === "CONNECT") {
         session.ref();
-        const setupUpgradeStream = /* @__PURE__ */ __name((stream2) => {
-          let responseReceived2 = false;
-          const removeUpgradeStreamListeners = /* @__PURE__ */ __name(() => {
-            stream2.off("response", onUpgradeResponse);
-            stream2.off("error", onUpgradeStreamError);
-            stream2.off("end", onUpgradeStreamEnd);
-            stream2.off("timeout", onUpgradeStreamTimeout);
-            stream2.off("error", noop);
-          }, "removeUpgradeStreamListeners");
-          const releaseUpgradeStream = /* @__PURE__ */ __name(() => {
-            if (request[kRequestStream] === stream2) {
-              detachRequestFromStream(request);
-            }
-            removeUpgradeStreamListeners();
-            if (!stream2.destroyed && !stream2.closed) {
-              stream2.once("error", noop);
-            }
-          }, "releaseUpgradeStream");
-          const failUpgradeStream = /* @__PURE__ */ __name((err) => {
-            if (responseReceived2 || request.aborted || request.completed) {
-              return;
-            }
-            releaseUpgradeStream();
-            abort(err, true);
-          }, "failUpgradeStream");
-          const onUpgradeStreamError = /* @__PURE__ */ __name(() => {
-            if (typeof stream2.rstCode === "number" && stream2.rstCode !== 0) {
-              failUpgradeStream(new InformationalError(`HTTP/2: "stream error" received - code ${stream2.rstCode}`));
-            } else {
-              failUpgradeStream(new InformationalError("HTTP/2: stream errored before response headers"));
-            }
-          }, "onUpgradeStreamError");
-          const onUpgradeStreamEnd = /* @__PURE__ */ __name(() => {
-            failUpgradeStream(new InformationalError("HTTP/2: stream half-closed (remote)"));
-          }, "onUpgradeStreamEnd");
-          const onUpgradeStreamTimeout = /* @__PURE__ */ __name(() => {
-            failUpgradeStream(new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`));
-          }, "onUpgradeStreamTimeout");
-          const onUpgradeResponse = /* @__PURE__ */ __name((headers2, _flags) => {
-            responseReceived2 = true;
-            const statusCode = headers2[HTTP2_HEADER_STATUS];
-            delete headers2[HTTP2_HEADER_STATUS];
-            request.onRequestUpgrade(statusCode, headers2, stream2);
-            if (request.aborted || request.completed) {
-              return;
-            }
-            removeUpgradeStreamListeners();
-            detachRequestFromStream(request);
-            finalizeRequest();
-          }, "onUpgradeResponse");
-          bindRequestToStream(request, stream2, releaseUpgradeStream);
-          stream2.once("response", onUpgradeResponse);
-          stream2.on("error", onUpgradeStreamError);
-          stream2.once("end", onUpgradeStreamEnd);
-          stream2.on("timeout", onUpgradeStreamTimeout);
-          stream2[kHTTP2Session] = session;
-          stream2[kRequestStreamOnCloseError] = failUpgradeStream;
-          stream2.once("close", onUpgradeStreamClose);
-          ++session[kOpenStreams];
-          stream2.setTimeout(requestTimeout);
-        }, "setupUpgradeStream");
+        const upgradeState = {
+          abort,
+          finalizeRequest,
+          request,
+          requestTimeout,
+          responseReceived: false,
+          session,
+          stream: null
+        };
         if (upgrade === "websocket") {
           if (session[kEnableConnectProtocol] === false) {
             util.errorRequest(client, request, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server"));
@@ -8719,8 +8812,7 @@ var require_client_h2 = __commonJS({
             session.unref();
             return false;
           }
-          stream[kHTTP2Stream] = true;
-          setupUpgradeStream(stream);
+          setupUpgradeStream(stream, upgradeState);
           return true;
         }
         stream = requestStream(headers, { endStream: false, signal });
@@ -8728,13 +8820,12 @@ var require_client_h2 = __commonJS({
           session.unref();
           return false;
         }
-        stream[kHTTP2Stream] = true;
-        setupUpgradeStream(stream);
+        setupUpgradeStream(stream, upgradeState);
         return true;
       }
       headers[HTTP2_HEADER_PATH] = path;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
-      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
+      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (body && typeof body.read === "function") {
         body.read(0);
       }
@@ -8772,115 +8863,35 @@ var require_client_h2 = __commonJS({
         }
         channels.sendHeaders.publish({ request, headers: header, socket: session[kSocket] });
       }
-      const shouldEndStream = body === null;
+      const shouldEndStream = body === null || contentLength === 0;
+      const state = {
+        abort,
+        body,
+        client,
+        contentLength,
+        expectsPayload,
+        finalizeRequest,
+        request,
+        requestTimeout,
+        responseReceived: false,
+        session,
+        stream: null
+      };
       if (expectContinue) {
         headers[HTTP2_HEADER_EXPECT] = "100-continue";
-        stream = requestStream(headers, { endStream: shouldEndStream, signal });
-        if (stream == null) {
-          return false;
-        }
-        stream[kHTTP2Stream] = true;
-        bindRequestToStream(request, stream, null);
-      } else {
-        stream = requestStream(headers, {
-          endStream: shouldEndStream,
-          signal
-        });
-        if (stream == null) {
-          return false;
-        }
-        stream[kHTTP2Stream] = true;
-        bindRequestToStream(request, stream, null);
       }
+      stream = requestStream(headers, { endStream: shouldEndStream, signal });
+      if (stream == null) {
+        return false;
+      }
+      stream[kHTTP2Stream] = true;
+      stream[kRequestStreamState] = state;
+      state.stream = stream;
+      bindRequestToStream(request, stream, null);
       ++session[kOpenStreams];
       stream.setTimeout(requestTimeout);
-      let responseReceived = false;
-      const onData = /* @__PURE__ */ __name((chunk) => {
-        if (request.aborted || request.completed) {
-          return;
-        }
-        if (request.onResponseData(chunk) === false) {
-          stream.pause();
-        }
-      }, "onData");
-      const removeRequestStreamListeners = /* @__PURE__ */ __name(() => {
-        stream.off("error", noop);
-        stream.off("continue", writeBodyH2);
-        stream.off("response", onResponse);
-        stream.off("end", onEnd);
-        stream.off("error", onError);
-        stream.off("frameError", onFrameError);
-        stream.off("aborted", onAborted);
-        stream.off("timeout", onTimeout);
-        stream.off("trailers", onTrailers);
-        stream.off("data", onData);
-      }, "removeRequestStreamListeners");
-      const releaseRequestStream = /* @__PURE__ */ __name(() => {
-        if (request[kRequestStream] === stream) {
-          detachRequestFromStream(request);
-        }
-        removeRequestStreamListeners();
-        if (!stream.destroyed && !stream.closed) {
-          stream.once("error", noop);
-        }
-      }, "releaseRequestStream");
-      const onResponse = /* @__PURE__ */ __name((headers2) => {
-        stream.off("response", onResponse);
-        const statusCode = headers2[HTTP2_HEADER_STATUS];
-        delete headers2[HTTP2_HEADER_STATUS];
-        request.onResponseStarted();
-        responseReceived = true;
-        if (request.aborted) {
-          releaseRequestStream();
-          return;
-        }
-        if (request.onResponseStart(Number(statusCode), headers2, stream.resume.bind(stream), "") === false) {
-          stream.pause();
-        }
-        stream.on("data", onData);
-      }, "onResponse");
-      const onEnd = /* @__PURE__ */ __name(() => {
-        stream.off("end", onEnd);
-        releaseRequestStream();
-        if (responseReceived) {
-          if (!request.aborted && !request.completed) {
-            request.onResponseEnd({});
-          }
-          finalizeRequest();
-        } else {
-          abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
-        }
-      }, "onEnd");
       stream[kHTTP2Session] = session;
-      stream[kRequestStreamOnData] = onData;
       stream.once("close", onRequestStreamClose);
-      const onError = /* @__PURE__ */ __name(function(err) {
-        stream.off("error", onError);
-        releaseRequestStream();
-        abort(err);
-      }, "onError");
-      const onFrameError = /* @__PURE__ */ __name((type, code) => {
-        stream.off("frameError", onFrameError);
-        releaseRequestStream();
-        abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
-      }, "onFrameError");
-      const onAborted = /* @__PURE__ */ __name(() => {
-        stream.off("data", onData);
-      }, "onAborted");
-      const onTimeout = /* @__PURE__ */ __name(() => {
-        releaseRequestStream();
-        const err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`);
-        abort(err);
-      }, "onTimeout");
-      const onTrailers = /* @__PURE__ */ __name((trailers) => {
-        stream.off("trailers", onTrailers);
-        if (request.aborted || request.completed) {
-          return;
-        }
-        releaseRequestStream();
-        request.onResponseEnd(trailers);
-        finalizeRequest();
-      }, "onTrailers");
       bindRequestToStream(request, stream, releaseRequestStream);
       if (expectContinue) {
         stream.once("continue", writeBodyH2);
@@ -8893,69 +8904,169 @@ var require_client_h2 = __commonJS({
       stream.on("timeout", onTimeout);
       stream.once("trailers", onTrailers);
       if (!expectContinue) {
-        writeBodyH2();
+        writeBodyH2.call(stream);
       }
       return true;
-      function writeBodyH2() {
-        if (!body || contentLength === 0) {
-          writeBuffer(
-            abort,
-            stream,
-            null,
-            client,
-            request,
-            client[kSocket],
-            contentLength,
-            expectsPayload
-          );
-        } else if (util.isBuffer(body)) {
-          writeBuffer(
+    }
+    __name(writeH2, "writeH2");
+    function removeRequestStreamListeners(stream) {
+      stream.off("error", noop);
+      stream.off("continue", writeBodyH2);
+      stream.off("response", onResponse);
+      stream.off("end", onEnd);
+      stream.off("error", onError);
+      stream.off("frameError", onFrameError);
+      stream.off("aborted", onAborted);
+      stream.off("timeout", onTimeout);
+      stream.off("trailers", onTrailers);
+      stream.off("data", onData);
+    }
+    __name(removeRequestStreamListeners, "removeRequestStreamListeners");
+    function releaseRequestStream(stream) {
+      if (stream == null) {
+        return;
+      }
+      const state = stream[kRequestStreamState];
+      if (state == null) {
+        return;
+      }
+      const { request } = state;
+      if (request[kRequestStream] === stream) {
+        detachRequestFromStream(request);
+      }
+      removeRequestStreamListeners(stream);
+      if (!stream.destroyed && !stream.closed) {
+        stream.once("error", noop);
+      }
+    }
+    __name(releaseRequestStream, "releaseRequestStream");
+    function onData(chunk) {
+      const stream = this;
+      const { request } = stream[kRequestStreamState];
+      if (request.aborted || request.completed) {
+        return;
+      }
+      if (request.onResponseData(chunk) === false) {
+        stream.pause();
+      }
+    }
+    __name(onData, "onData");
+    function onResponse(headers) {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      const { request } = state;
+      stream.off("response", onResponse);
+      const statusCode = headers[HTTP2_HEADER_STATUS];
+      delete headers[HTTP2_HEADER_STATUS];
+      request.onResponseStarted();
+      state.responseReceived = true;
+      if (request.aborted) {
+        releaseRequestStream(stream);
+        return;
+      }
+      if (request.onResponseStart(Number(statusCode), headers, stream.resume.bind(stream), "") === false) {
+        stream.pause();
+      }
+      stream.on("data", onData);
+    }
+    __name(onResponse, "onResponse");
+    function onEnd() {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      const { request } = state;
+      stream.off("end", onEnd);
+      releaseRequestStream(stream);
+      if (state.responseReceived) {
+        if (!request.aborted && !request.completed) {
+          request.onResponseEnd({});
+        }
+        state.finalizeRequest();
+      } else {
+        state.abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
+      }
+    }
+    __name(onEnd, "onEnd");
+    function onError(err) {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      stream.off("error", onError);
+      releaseRequestStream(stream);
+      state.abort(err);
+    }
+    __name(onError, "onError");
+    function onFrameError(type, code) {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      stream.off("frameError", onFrameError);
+      releaseRequestStream(stream);
+      state.abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
+    }
+    __name(onFrameError, "onFrameError");
+    function onAborted() {
+      this.off("data", onData);
+    }
+    __name(onAborted, "onAborted");
+    function onTimeout() {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      releaseRequestStream(stream);
+      const err = new InformationalError(`HTTP/2: "stream timeout after ${state.requestTimeout}"`);
+      state.abort(err);
+    }
+    __name(onTimeout, "onTimeout");
+    function onTrailers(trailers) {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      const { request } = state;
+      stream.off("trailers", onTrailers);
+      if (request.aborted || request.completed) {
+        return;
+      }
+      releaseRequestStream(stream);
+      request.onResponseEnd(trailers);
+      state.finalizeRequest();
+    }
+    __name(onTrailers, "onTrailers");
+    function writeBodyH2() {
+      const stream = this;
+      const state = stream[kRequestStreamState];
+      const { abort, body, client, contentLength, expectsPayload, request } = state;
+      if (!body || contentLength === 0) {
+        writeBuffer(
+          abort,
+          stream,
+          null,
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        );
+      } else if (util.isBuffer(body)) {
+        writeBuffer(
+          abort,
+          stream,
+          body,
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        );
+      } else if (util.isBlobLike(body)) {
+        if (typeof body.stream === "function") {
+          writeIterable(
             abort,
             stream,
-            body,
+            body.stream(),
             client,
             request,
             client[kSocket],
             contentLength,
             expectsPayload
           );
-        } else if (util.isBlobLike(body)) {
-          if (typeof body.stream === "function") {
-            writeIterable(
-              abort,
-              stream,
-              body.stream(),
-              client,
-              request,
-              client[kSocket],
-              contentLength,
-              expectsPayload
-            );
-          } else {
-            writeBlob(
-              abort,
-              stream,
-              body,
-              client,
-              request,
-              client[kSocket],
-              contentLength,
-              expectsPayload
-            );
-          }
-        } else if (util.isStream(body)) {
-          writeStream(
-            abort,
-            client[kSocket],
-            expectsPayload,
-            stream,
-            body,
-            client,
-            request,
-            contentLength
-          );
-        } else if (util.isIterable(body)) {
-          writeIterable(
+        } else {
+          writeBlob(
             abort,
             stream,
             body,
@@ -8965,13 +9076,34 @@ var require_client_h2 = __commonJS({
             contentLength,
             expectsPayload
           );
-        } else {
-          assert(false);
         }
+      } else if (util.isStream(body)) {
+        writeStream(
+          abort,
+          client[kSocket],
+          expectsPayload,
+          stream,
+          body,
+          client,
+          request,
+          contentLength
+        );
+      } else if (util.isIterable(body)) {
+        writeIterable(
+          abort,
+          stream,
+          body,
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        );
+      } else {
+        assert(false);
       }
-      __name(writeBodyH2, "writeBodyH2");
     }
-    __name(writeH2, "writeH2");
+    __name(writeBodyH2, "writeBodyH2");
     function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
       try {
         if (body != null && util.isBuffer(body)) {
@@ -9019,7 +9151,6 @@ var require_client_h2 = __commonJS({
     }
     __name(writeStream, "writeStream");
     async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
-      assert(contentLength === body.size, "blob body must have content length");
       try {
         if (contentLength != null && contentLength !== body.size) {
           throw new RequestContentLengthMismatchError();
@@ -9144,6 +9275,7 @@ var require_client = __commonJS({
       kOnError,
       kHTTPContext,
       kMaxConcurrentStreams,
+      kHostAuthority,
       kHTTP2InitialWindowSize,
       kHTTP2ConnectionWindowSize,
       kResume,
@@ -9300,6 +9432,7 @@ var require_client = __commonJS({
           }, callback), "connect");
         }
         this[kUrl] = util.parseOrigin(url);
+        this[kHostAuthority] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
         this[kConnector] = connect2;
         this[kPipelining] = pipelining != null ? pipelining : 1;
         this[kMaxHeadersSize] = maxHeaderSize;
@@ -9311,7 +9444,7 @@ var require_client = __commonJS({
         this[kLocalAddress] = localAddress != null ? localAddress : null;
         this[kResuming] = 0;
         this[kNeedDrain] = 0;
-        this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
+        this[kHostHeader] = `host: ${this[kHostAuthority]}\r
 `;
         this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
         this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
@@ -9635,6 +9768,7 @@ var require_pool = __commonJS({
       kNeedDrain,
       kAddClient,
       kGetDispatcher,
+      kHasDispatcher,
       kRemoveClient
     } = require_pool_base();
     var Client = require_client();
@@ -9729,6 +9863,24 @@ var require_pool = __commonJS({
           return dispatcher;
         }
       }
+      [kHasDispatcher]() {
+        const clientTtlOption = this[kOptions].clientTtl;
+        for (let i = 0; i < this[kClients].length; i++) {
+          const client = this[kClients][i];
+          if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && Date.now() - client.ttl > clientTtlOption) {
+            this[kRemoveClient](client);
+            i--;
+          } else if (!client[kNeedDrain]) {
+            return true;
+          }
+        }
+        if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+          const dispatcher = this[kFactory](this[kUrl], this[kOptions]);
+          this[kAddClient](dispatcher);
+          return true;
+        }
+        return false;
+      }
     };
     module2.exports = Pool;
   }
@@ -10531,7 +10683,6 @@ var require_socks5_client = __commonJS({
 var require_socks5_proxy_agent = __commonJS({
   "lib/dispatcher/socks5-proxy-agent.js"(exports2, module2) {
     "use strict";
-    var net = require("node:net");
     var { URL: URL2 } = require("node:url");
     var tls;
     var DispatcherBase = require_dispatcher_base();
@@ -10545,6 +10696,7 @@ var require_socks5_proxy_agent = __commonJS({
     var kProxyUrl = /* @__PURE__ */ Symbol("proxy url");
     var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers");
     var kProxyAuth = /* @__PURE__ */ Symbol("proxy auth");
+    var kProxyProtocol = /* @__PURE__ */ Symbol("proxy protocol");
     var kPools = /* @__PURE__ */ Symbol("pools");
     var kConnector = /* @__PURE__ */ Symbol("connector");
     var experimentalWarningEmitted = false;
@@ -10570,6 +10722,7 @@ var require_socks5_proxy_agent = __commonJS({
         }
         this[kProxyUrl] = url;
         this[kProxyHeaders] = options.headers || {};
+        this[kProxyProtocol] = options.proxyTls ? "https:" : "http:";
         this[kProxyAuth] = {
           username: options.username || (url.username ? decodeURIComponent(url.username) : null),
           password: options.password || (url.password ? decodeURIComponent(url.password) : null)
@@ -10588,21 +10741,19 @@ var require_socks5_proxy_agent = __commonJS({
         const proxyPort = parseInt(this[kProxyUrl].port) || 1080;
         debug("creating SOCKS5 connection to", proxyHost, proxyPort);
         const socketReady = Promise.withResolvers();
-        const onSocketConnect = /* @__PURE__ */ __name(() => {
-          socket.removeListener("error", onSocketError);
-          socketReady.resolve(socket);
-        }, "onSocketConnect");
-        const onSocketError = /* @__PURE__ */ __name((err) => {
-          socket.removeListener("connect", onSocketConnect);
-          socketReady.reject(err);
-        }, "onSocketError");
-        const socket = net.connect({
+        this[kConnector]({
+          hostname: proxyHost,
           host: proxyHost,
-          port: proxyPort
+          port: proxyPort,
+          protocol: this[kProxyProtocol]
+        }, (err, socket2) => {
+          if (err) {
+            socketReady.reject(err);
+          } else {
+            socketReady.resolve(socket2);
+          }
         });
-        socket.once("connect", onSocketConnect);
-        socket.once("error", onSocketError);
-        await socketReady.promise;
+        const socket = await socketReady.promise;
         const socks5Client = new Socks5Client(socket, this[kProxyAuth]);
         socks5Client.on("error", (err) => {
           debug("SOCKS5 error:", err);
@@ -10655,7 +10806,7 @@ var require_socks5_proxy_agent = __commonJS({
       /**
        * Dispatch a request through the SOCKS5 proxy
        */
-      async [kDispatch](opts, handler) {
+      [kDispatch](opts, handler) {
         const { origin } = opts;
         debug("dispatching request to", origin, "via SOCKS5");
         try {
@@ -10700,8 +10851,12 @@ var require_socks5_proxy_agent = __commonJS({
           return pool[kDispatch](opts, handler);
         } catch (err) {
           debug("dispatch error:", err);
-          if (typeof handler.onError === "function") {
+          if (typeof handler.onResponseError === "function") {
+            handler.onResponseError(null, err);
+            return false;
+          } else if (typeof handler.onError === "function") {
             handler.onError(err);
+            return false;
           } else {
             throw err;
           }
@@ -10749,6 +10904,7 @@ var require_proxy_agent = __commonJS({
     var kConnectEndpoint = /* @__PURE__ */ Symbol("connect endpoint function");
     var kConnectEndpointHTTP1 = /* @__PURE__ */ Symbol("connect endpoint function (http/1.1 only)");
     var kTunnelProxy = /* @__PURE__ */ Symbol("tunnel proxy");
+    var proxyAuthorization = "proxy-authorization";
     function defaultProtocolPort(protocol) {
       return protocol === "https:" ? 443 : 80;
     }
@@ -10982,6 +11138,9 @@ var require_proxy_agent = __commonJS({
       if (Array.isArray(headers)) {
         const headersPair = {};
         for (let i = 0; i < headers.length; i += 2) {
+          if (isProxyAuthorizationHeader(headers[i])) {
+            throwProxyAuthError();
+          }
           headersPair[headers[i]] = headers[i + 1];
         }
         return headersPair;
@@ -10990,12 +11149,21 @@ var require_proxy_agent = __commonJS({
     }
     __name(buildHeaders, "buildHeaders");
     function throwIfProxyAuthIsSent(headers) {
-      const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
-      if (existProxyAuth) {
-        throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
+      for (const key in headers) {
+        if (isProxyAuthorizationHeader(key)) {
+          throwProxyAuthError();
+        }
       }
     }
     __name(throwIfProxyAuthIsSent, "throwIfProxyAuthIsSent");
+    function isProxyAuthorizationHeader(key) {
+      return key.length === proxyAuthorization.length && key.toLowerCase() === proxyAuthorization;
+    }
+    __name(isProxyAuthorizationHeader, "isProxyAuthorizationHeader");
+    function throwProxyAuthError() {
+      throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
+    }
+    __name(throwProxyAuthError, "throwProxyAuthError");
     module2.exports = ProxyAgent;
   }
 });
@@ -13944,6 +14112,8 @@ var require_fetch = __commonJS({
               origin: url.origin,
               method: request.method,
               body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body2,
+              // Preserve the serialized fetch body for MockAgent net-connect fallthroughs.
+              __mockAgentBodyForDispatch: body2,
               headers: request.headersList.entries,
               maxRedirections: 0,
               upgrade: request.mode === "websocket" ? "websocket" : void 0,
@@ -17267,7 +17437,6 @@ var require_api_stream = __commonJS({
   "lib/api/api-stream.js"(exports2, module2) {
     "use strict";
     var assert = require("node:assert");
-    var { finished } = require("node:stream");
     var { AsyncResource } = require("node:async_hooks");
     var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
     var util = require_util();
@@ -17275,6 +17444,47 @@ var require_api_stream = __commonJS({
     function noop() {
     }
     __name(noop, "noop");
+    function getWritableError(stream2) {
+      return stream2.errored ?? stream2.writableErrored ?? stream2._writableState?.errored;
+    }
+    __name(getWritableError, "getWritableError");
+    function createPrematureCloseError() {
+      const err = new Error("Premature close");
+      err.code = "ERR_STREAM_PREMATURE_CLOSE";
+      return err;
+    }
+    __name(createPrematureCloseError, "createPrematureCloseError");
+    function trackWritableLifecycle(stream2, callback) {
+      let done = false;
+      const cleanup = /* @__PURE__ */ __name(() => {
+        stream2.removeListener("close", onClose);
+        stream2.removeListener("error", onError);
+        stream2.removeListener("finish", onFinish);
+      }, "cleanup");
+      const finish = /* @__PURE__ */ __name((err, fromErrorEvent = false) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        cleanup();
+        callback(err, fromErrorEvent);
+      }, "finish");
+      const onClose = /* @__PURE__ */ __name(() => {
+        const err = getWritableError(stream2);
+        finish(err ?? (!stream2.writableFinished ? createPrematureCloseError() : void 0));
+      }, "onClose");
+      const onError = /* @__PURE__ */ __name((err) => finish(err, true), "onError");
+      const onFinish = /* @__PURE__ */ __name(() => finish(), "onFinish");
+      stream2.on("close", onClose);
+      stream2.on("error", onError);
+      stream2.on("finish", onFinish);
+      if (stream2.closed) {
+        process.nextTick(onClose);
+      } else if (stream2.writableFinished) {
+        process.nextTick(onFinish);
+      }
+    }
+    __name(trackWritableLifecycle, "trackWritableLifecycle");
     var StreamHandler = class extends AsyncResource {
       static {
         __name(this, "StreamHandler");
@@ -17358,16 +17568,16 @@ var require_api_stream = __commonJS({
         if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
           throw new InvalidReturnValueError("expected Writable");
         }
-        finished(res, { readable: false }, (err) => {
+        trackWritableLifecycle(res, (err, fromErrorEvent) => {
           const { callback, res: res2, opaque: opaque2, trailers, abort } = this;
           this.res = null;
           if (err || !res2?.readable) {
-            util.destroy(res2, err);
+            util.destroy(res2, fromErrorEvent ? void 0 : err);
           }
           this.callback = null;
           this.runInAsyncScope(callback, null, err || null, { opaque: opaque2, trailers });
           if (err) {
-            abort();
+            abort(err);
           }
         });
         res.on("drain", () => controller.resume());
@@ -17457,6 +17667,7 @@ var require_api_pipeline = __commonJS({
       RequestAbortedError
     } = require_errors();
     var util = require_util();
+    var { kBodyUsed } = require_symbols();
     var { addSignal, removeSignal } = require_abort_signal();
     function noop() {
     }
@@ -17469,6 +17680,7 @@ var require_api_pipeline = __commonJS({
       constructor() {
         super({ autoDestroy: true });
         this[kResume] = null;
+        this[kBodyUsed] = true;
       }
       _read() {
         const { [kResume]: resume } = this;
diff --git a/src/undici_version.h b/src/undici_version.h
index 7514ec8d4c236b..c2e57bda323fa5 100644
--- a/src/undici_version.h
+++ b/src/undici_version.h
@@ -2,5 +2,5 @@
 // Refer to tools/dep_updaters/update-undici.sh
 #ifndef SRC_UNDICI_VERSION_H_
 #define SRC_UNDICI_VERSION_H_
-#define UNDICI_VERSION "8.2.0"
+#define UNDICI_VERSION "8.3.0"
 #endif  // SRC_UNDICI_VERSION_H_

From 7acaa0fc912d7545c2a94c35fa067070977d9951 Mon Sep 17 00:00:00 2001
From: Anshika Jain <anshikajain196872@gmail.com>
Date: Tue, 19 May 2026 23:19:19 +0530
Subject: [PATCH 16/83] crypto: align verifyOneShot accepted types

Signed-off-by: anshikakalpana <anshikajain196872@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63280
Fixes: https://github.com/nodejs/node/issues/62903
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 doc/api/crypto.md                        |  6 ++--
 lib/internal/crypto/sig.js               | 16 +---------
 test/parallel/test-crypto-sign-verify.js | 40 ++++++++++++++++++++++--
 3 files changed, 42 insertions(+), 20 deletions(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 91cb32a1b9816f..adaf8f64b56733 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -6132,7 +6132,7 @@ changes:
 <!--lint disable maximum-line-length remark-lint-->
 
 * `algorithm` {string | null | undefined}
-* `data` {ArrayBuffer|Buffer|TypedArray|DataView}
+* `data` {ArrayBuffer|Buffer|SharedArrayBuffer|TypedArray|DataView|string}
 * `key` {Object|string|ArrayBuffer|Buffer|TypedArray|DataView|KeyObject|CryptoKey}
 * `callback` {Function}
   * `err` {Error}
@@ -6264,9 +6264,9 @@ changes:
 <!--lint disable maximum-line-length remark-lint-->
 
 * `algorithm` {string|null|undefined}
-* `data` {ArrayBuffer| Buffer|TypedArray|DataView}
+* `data` {ArrayBuffer|Buffer|SharedArrayBuffer|TypedArray|DataView|string}
 * `key` {Object|string|ArrayBuffer|Buffer|TypedArray|DataView|KeyObject|CryptoKey}
-* `signature` {ArrayBuffer|Buffer|TypedArray|DataView}
+* `signature` {ArrayBuffer|Buffer|SharedArrayBuffer|TypedArray|DataView}
 * `callback` {Function}
   * `err` {Error}
   * `result` {boolean}
diff --git a/lib/internal/crypto/sig.js b/lib/internal/crypto/sig.js
index a27ce4b190e111..3830ecc0b128d2 100644
--- a/lib/internal/crypto/sig.js
+++ b/lib/internal/crypto/sig.js
@@ -265,14 +265,6 @@ function verifyOneShot(algorithm, data, key, signature, callback) {
 
   data = getArrayBufferOrView(data, 'data');
 
-  if (!isArrayBufferView(data)) {
-    throw new ERR_INVALID_ARG_TYPE(
-      'data',
-      ['Buffer', 'TypedArray', 'DataView'],
-      data,
-    );
-  }
-
   // Options specific to RSA
   const rsaPadding = getPadding(key);
   const pssSaltLength = getSaltLength(key);
@@ -283,13 +275,7 @@ function verifyOneShot(algorithm, data, key, signature, callback) {
   // Options specific to Ed448 and ML-DSA
   const context = getContext(key);
 
-  if (!isArrayBufferView(signature)) {
-    throw new ERR_INVALID_ARG_TYPE(
-      'signature',
-      ['Buffer', 'TypedArray', 'DataView'],
-      signature,
-    );
-  }
+  signature = getArrayBufferOrView(signature, 'signature');
 
   const {
     data: keyData,
diff --git a/test/parallel/test-crypto-sign-verify.js b/test/parallel/test-crypto-sign-verify.js
index a33eeca328ce8d..a6a0d339d2432d 100644
--- a/test/parallel/test-crypto-sign-verify.js
+++ b/test/parallel/test-crypto-sign-verify.js
@@ -619,8 +619,8 @@ if (hasOpenSSL(3, 2)) {
   assert.throws(() => crypto.sign(null, data, input), errObj);
   assert.throws(() => crypto.verify(null, data, input, sig), errObj);
 
-  errObj.message = 'The "signature" argument must be an instance of ' +
-                   'Buffer, TypedArray, or DataView.' +
+  errObj.message = 'The "signature" argument must be of type string or an instance of ' +
+                   'ArrayBuffer, Buffer, TypedArray, or DataView.' +
                    common.invalidArgTypeHelper(input);
   assert.throws(() => crypto.verify(null, data, 'test', input), errObj);
 });
@@ -1019,3 +1019,39 @@ if (!process.features.openssl_is_boringssl) {
     message: /key\.format/,
   });
 }
+
+// crypto.verify accepts ArrayBuffer and SharedArrayBuffer for data and signature
+{
+  const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 2048 });
+  const dataBuffer = Buffer.from('Hello world');
+
+  // Data as ArrayBuffer
+  {
+    const ab = dataBuffer.buffer.slice(dataBuffer.byteOffset, dataBuffer.byteOffset + dataBuffer.byteLength);
+    const sig = crypto.sign('SHA256', dataBuffer, privateKey);
+    assert.strictEqual(crypto.verify('SHA256', ab, publicKey, sig), true);
+  }
+
+  // Data as SharedArrayBuffer
+  {
+    const sab = new SharedArrayBuffer(dataBuffer.length);
+    new Uint8Array(sab).set(dataBuffer);
+    const sig = crypto.sign('SHA256', dataBuffer, privateKey);
+    assert.strictEqual(crypto.verify('SHA256', sab, publicKey, sig), true);
+  }
+
+  // Signature as ArrayBuffer
+  {
+    const sig = crypto.sign('SHA256', dataBuffer, privateKey);
+    const sigAB = sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+    assert.strictEqual(crypto.verify('SHA256', dataBuffer, publicKey, sigAB), true);
+  }
+
+  // Signature as SharedArrayBuffer
+  {
+    const sig = crypto.sign('SHA256', dataBuffer, privateKey);
+    const sigSAB = new SharedArrayBuffer(sig.length);
+    new Uint8Array(sigSAB).set(sig);
+    assert.strictEqual(crypto.verify('SHA256', dataBuffer, publicKey, sigSAB), true);
+  }
+}

From 57ee68239c501e3bc01fa3ba30e9e83178ab8074 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Tue, 19 May 2026 10:49:31 -0700
Subject: [PATCH 17/83] test: deflake watch mode worker test

Trigger watch restarts by appending whitespace instead of rewriting
watched modules. This avoids transient empty or partial ESM dependency
contents while the restarted worker is loading.

Use a separate temporary directory for each subtest so concurrent
subtests do not share worker and dependency file names.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63384
Refs: https://github.com/nodejs/reliability/blob/main/reports/2026-05-17.md#jstest-failure
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 test/sequential/test-watch-mode-worker.mjs | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/test/sequential/test-watch-mode-worker.mjs b/test/sequential/test-watch-mode-worker.mjs
index b7bc1a94a87ba4..41cdf05782cd38 100644
--- a/test/sequential/test-watch-mode-worker.mjs
+++ b/test/sequential/test-watch-mode-worker.mjs
@@ -5,7 +5,7 @@ import path from 'node:path';
 import { execPath } from 'node:process';
 import { describe, it } from 'node:test';
 import { spawn } from 'node:child_process';
-import { writeFileSync, readFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { inspect } from 'node:util';
 import { pathToFileURL } from 'node:url';
 import { createInterface } from 'node:readline';
@@ -13,9 +13,9 @@ import { createInterface } from 'node:readline';
 if (common.isIBMi)
   common.skip('IBMi does not support `fs.watch()`');
 
-function restart(file, content = readFileSync(file)) {
-  writeFileSync(file, content);
-  const timer = setInterval(() => writeFileSync(file, content), common.platformTimeout(250));
+function restart(file) {
+  appendFileSync(file, '\n');
+  const timer = setInterval(() => appendFileSync(file, '\n'), common.platformTimeout(250));
   return () => clearInterval(timer);
 }
 
@@ -26,6 +26,12 @@ function createTmpFile(content = 'console.log(\'running\');', ext = '.js', basen
   return file;
 }
 
+function createTmpDir() {
+  const dir = path.join(tmpdir.path, `${tmpFiles++}`);
+  mkdirSync(dir);
+  return dir;
+}
+
 async function runWriteSucceed({
   file,
   watchedFile,
@@ -78,10 +84,10 @@ async function runWriteSucceed({
 }
 
 tmpdir.refresh();
-const dir = tmpdir.path;
 
 describe('watch mode', { concurrency: !process.env.TEST_PARALLEL, timeout: 60_000 }, () => {
   it('should watch changes to worker - cjs', async () => {
+    const dir = createTmpDir();
     const worker = path.join(dir, 'worker.js');
 
     writeFileSync(worker, `
@@ -109,6 +115,7 @@ const w = new Worker(${JSON.stringify(worker)});
   });
 
   it('should watch changes to worker dependencies - cjs', async () => {
+    const dir = createTmpDir();
     const dep = path.join(dir, 'dep.js');
     const worker = path.join(dir, 'worker.js');
 
@@ -142,6 +149,7 @@ const w = new Worker(${JSON.stringify(worker)});
   });
 
   it('should watch changes to nested worker dependencies - cjs', async () => {
+    const dir = createTmpDir();
     const subDep = path.join(dir, 'sub-dep.js');
     const dep = path.join(dir, 'dep.js');
     const worker = path.join(dir, 'worker.js');
@@ -181,6 +189,7 @@ const w = new Worker(${JSON.stringify(worker)});
   });
 
   it('should watch changes to worker - esm', async () => {
+    const dir = createTmpDir();
     const worker = path.join(dir, 'worker.mjs');
 
     writeFileSync(worker, `
@@ -208,6 +217,7 @@ new Worker(new URL(${JSON.stringify(pathToFileURL(worker))}));
   });
 
   it('should watch changes to worker dependencies - esm', async () => {
+    const dir = createTmpDir();
     const dep = path.join(dir, 'dep.mjs');
     const worker = path.join(dir, 'worker.mjs');
 
@@ -241,6 +251,7 @@ new Worker(new URL(${JSON.stringify(pathToFileURL(worker))}));
   });
 
   it('should watch changes to nested worker dependencies - esm', async () => {
+    const dir = createTmpDir();
     const subDep = path.join(dir, 'sub-dep.mjs');
     const dep = path.join(dir, 'dep.mjs');
     const worker = path.join(dir, 'worker.mjs');

From b1387e6aedc5e05d11939efd3bb5b8c3caf5fc22 Mon Sep 17 00:00:00 2001
From: Daijiro Wachi <daijiro.wachi@gmail.com>
Date: Wed, 20 May 2026 03:30:44 +0900
Subject: [PATCH 18/83] lib: use `Object.freeze` to avoid defensive cloning in
 `SourceMap`

PR-URL: https://github.com/nodejs/node/pull/62830
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
---
 doc/api/module.md                     | 11 +++++++++++
 lib/internal/source_map/source_map.js | 14 ++++++--------
 test/parallel/test-source-map-api.js  | 13 +++++++++++++
 3 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/doc/api/module.md b/doc/api/module.md
index 5ab07802e0588f..451c8b3348a47a 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -1962,10 +1962,20 @@ generated code.
 
 #### `sourceMap.payload`
 
+<!-- YAML
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/62830
+    description: The object is frozen.
+-->
+
 * Returns: {Object}
 
 Getter for the payload used to construct the [`SourceMap`][] instance.
 
+The returned object is frozen with [`Object.freeze()`][], and the same
+reference is returned on every access. Do not mutate the returned object.
+
 #### `sourceMap.findEntry(lineOffset, columnOffset)`
 
 * `lineOffset` {number} The zero-indexed line number offset in
@@ -2050,6 +2060,7 @@ returned object contains the following keys:
 [`NODE_COMPILE_CACHE_PORTABLE=1`]: cli.md#node_compile_cache_portable1
 [`NODE_DISABLE_COMPILE_CACHE=1`]: cli.md#node_disable_compile_cache1
 [`NODE_V8_COVERAGE=dir`]: cli.md#node_v8_coveragedir
+[`Object.freeze()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
 [`SourceMap`]: #class-modulesourcemap
 [`initialize`]: #initialize
 [`module.constants.compileCacheStatus`]: #moduleconstantscompilecachestatus
diff --git a/lib/internal/source_map/source_map.js b/lib/internal/source_map/source_map.js
index dbfc05e8925d46..42e7bca3c4c5c0 100644
--- a/lib/internal/source_map/source_map.js
+++ b/lib/internal/source_map/source_map.js
@@ -71,6 +71,7 @@ const {
   ArrayPrototypePush,
   ArrayPrototypeSlice,
   ArrayPrototypeSort,
+  ObjectFreeze,
   ObjectPrototypeHasOwnProperty,
   StringPrototypeCharAt,
   Symbol,
@@ -144,7 +145,7 @@ class SourceMap {
     this.#payload = cloneSourceMapV3(payload);
     this.#parseMappingPayload();
     if (ArrayIsArray(lineLengths) && lineLengths.length) {
-      this.#lineLengths = lineLengths;
+      this.#lineLengths = ObjectFreeze(ArrayPrototypeSlice(lineLengths));
     }
   }
 
@@ -152,7 +153,7 @@ class SourceMap {
    * @returns {object} raw source map v3 payload.
    */
   get payload() {
-    return cloneSourceMapV3(this.#payload);
+    return this.#payload;
   }
 
   get [kMappings]() {
@@ -163,10 +164,7 @@ class SourceMap {
    * @returns {number[] | undefined} line lengths of generated source code
    */
   get lineLengths() {
-    if (this.#lineLengths) {
-      return ArrayPrototypeSlice(this.#lineLengths);
-    }
-    return undefined;
+    return this.#lineLengths;
   }
 
   #parseMappingPayload = () => {
@@ -366,10 +364,10 @@ function cloneSourceMapV3(payload) {
   for (const key in payload) {
     if (ObjectPrototypeHasOwnProperty(payload, key) &&
         ArrayIsArray(payload[key])) {
-      payload[key] = ArrayPrototypeSlice(payload[key]);
+      payload[key] = ObjectFreeze(ArrayPrototypeSlice(payload[key]));
     }
   }
-  return payload;
+  return ObjectFreeze(payload);
 }
 
 /**
diff --git a/test/parallel/test-source-map-api.js b/test/parallel/test-source-map-api.js
index 8c965891536072..bc09d2ca2b8775 100644
--- a/test/parallel/test-source-map-api.js
+++ b/test/parallel/test-source-map-api.js
@@ -140,6 +140,14 @@ const { readFileSync } = require('fs');
   assert.notStrictEqual(payload, sourceMap.payload);
   assert.strictEqual(payload.sources[0], sourceMap.payload.sources[0]);
   assert.notStrictEqual(payload.sources, sourceMap.payload.sources);
+  // The payload and its arrays should be frozen to avoid unnecessary cloning:
+  assert(Object.isFrozen(sourceMap.payload));
+  assert(Object.isFrozen(sourceMap.payload.sources));
+  // The same frozen object is returned on each call:
+  assert.strictEqual(sourceMap.payload, sourceMap.payload);
+  // lineLengths should be frozen and return the same reference each call:
+  assert(Object.isFrozen(sourceMap.lineLengths));
+  assert.strictEqual(sourceMap.lineLengths, sourceMap.lineLengths);
 }
 
 // findEntry() and findOrigin() must return empty object instead of
@@ -178,6 +186,11 @@ const { readFileSync } = require('fs');
   assert.notStrictEqual(payload, sourceMap.payload);
   assert.strictEqual(payload.sources[0], sourceMap.payload.sources[0]);
   assert.notStrictEqual(payload.sources, sourceMap.payload.sources);
+  // The payload and its arrays should be frozen to avoid unnecessary cloning:
+  assert(Object.isFrozen(sourceMap.payload));
+  assert(Object.isFrozen(sourceMap.payload.sources));
+  // The same frozen object is returned on each call:
+  assert.strictEqual(sourceMap.payload, sourceMap.payload);
 }
 
 // Test various known decodings to ensure decodeVLQ works correctly.

From 0b5b1894267f154b4e6b4c75b0057a2331f1f0ef Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Tue, 19 May 2026 12:16:51 -0700
Subject: [PATCH 19/83] test: avoid repeated writes in watch helper

Use performFileOperation() for test runner watch updates so the
run() API path schedules a single delayed write instead of rewriting
the file until the second run completes.

Repeated writes can trigger another watch restart while the previous
rerun is still active. The runner then terminates the in-flight child
process with SIGTERM, which can make the captured output include both
a failed file-level subtest and the next successful run.

Also count only root summary duration lines when detecting completed
runs.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63386
Refs: https://github.com/nodejs/reliability/blob/main/reports/2026-05-17.md#jstest-failure
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
---
 test/common/watch.js | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/test/common/watch.js b/test/common/watch.js
index 81defc49835eb1..c3d22c30f78e0c 100644
--- a/test/common/watch.js
+++ b/test/common/watch.js
@@ -106,7 +106,7 @@ async function testRunnerWatch({
   child.stdout.on('data', (data) => {
     stdout += data.toString();
     currentRun += data.toString();
-    const testRuns = stdout.match(/duration_ms\s\d+/g);
+    const testRuns = stdout.match(/^\S+ duration_ms\s\d+/gm);
     if (testRuns?.length >= 1) ran1.resolve();
     if (testRuns?.length >= 2) ran2.resolve();
   });
@@ -118,18 +118,11 @@ async function testRunnerWatch({
     const content = fixtureContent[fileToUpdate];
     const path = fixturePaths[fileToUpdate];
 
-    if (useRunApi) {
-      const interval = setInterval(
-        () => writeFileSync(path, content),
-        common.platformTimeout(1000),
-      );
-      await ran2.promise;
-      clearInterval(interval);
-    } else {
-      writeFileSync(path, content);
-      await setTimeout(common.platformTimeout(1000));
-      await ran2.promise;
-    }
+    await performFileOperation(
+      () => writeFileSync(path, content),
+      useRunApi,
+    );
+    await ran2.promise;
 
     runs.push(currentRun);
     child.kill();

From 46e17c728e644ef0a8bc0703a3e0d60adbc2d057 Mon Sep 17 00:00:00 2001
From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
Date: Tue, 19 May 2026 22:00:55 +0200
Subject: [PATCH 20/83] build,win: add Rust toolchain automated configuration
 Windows

Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
PR-URL: https://github.com/nodejs/node/pull/63381
Refs: https://github.com/nodejs/node/issues/63225
Refs: https://github.com/nodejs/node/pull/63367
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Stefan Stojanovic <stefan.stojanovic@janeasystems.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
---
 .configurations/configuration.dsc.yaml                | 9 ++++++++-
 .configurations/configuration.vsBuildTools.dsc.yaml   | 9 ++++++++-
 .configurations/configuration.vsEnterprise.dsc.yaml   | 9 ++++++++-
 .configurations/configuration.vsProfessional.dsc.yaml | 9 ++++++++-
 BUILDING.md                                           | 1 +
 5 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/.configurations/configuration.dsc.yaml b/.configurations/configuration.dsc.yaml
index 9e38aaba78a412..8c637d7dae819a 100644
--- a/.configurations/configuration.dsc.yaml
+++ b/.configurations/configuration.dsc.yaml
@@ -35,6 +35,13 @@ properties:
           - Microsoft.VisualStudio.Workload.NativeDesktop
           - Microsoft.VisualStudio.Component.VC.Llvm.Clang
           - Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset
+    - resource: Microsoft.WinGet.DSC/WinGetPackage
+      id: rustPackage
+      directives:
+        description: Install Rust with MSVC toolchain
+      settings:
+        id: Rustlang.Rust.MSVC
+        source: winget
     - resource: Microsoft.WinGet.DSC/WinGetPackage
       id: gitPackage
       directives:
@@ -51,4 +58,4 @@ properties:
       settings:
         id: Nasm.Nasm
         source: winget
-  configurationVersion: 0.1.1
+  configurationVersion: 0.2.0
diff --git a/.configurations/configuration.vsBuildTools.dsc.yaml b/.configurations/configuration.vsBuildTools.dsc.yaml
index 5434b44b3e0459..3e3a51ca90260f 100644
--- a/.configurations/configuration.vsBuildTools.dsc.yaml
+++ b/.configurations/configuration.vsBuildTools.dsc.yaml
@@ -35,6 +35,13 @@ properties:
           - Microsoft.VisualStudio.Workload.VCTools
           - Microsoft.VisualStudio.Component.VC.Llvm.Clang
           - Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset
+    - resource: Microsoft.WinGet.DSC/WinGetPackage
+      id: rustPackage
+      directives:
+        description: Install Rust with MSVC toolchain
+      settings:
+        id: Rustlang.Rust.MSVC
+        source: winget
     - resource: Microsoft.WinGet.DSC/WinGetPackage
       id: gitPackage
       directives:
@@ -51,4 +58,4 @@ properties:
       settings:
         id: Nasm.Nasm
         source: winget
-  configurationVersion: 0.1.1
+  configurationVersion: 0.2.0
diff --git a/.configurations/configuration.vsEnterprise.dsc.yaml b/.configurations/configuration.vsEnterprise.dsc.yaml
index 4faf7d77d371d6..124a391b7843fa 100644
--- a/.configurations/configuration.vsEnterprise.dsc.yaml
+++ b/.configurations/configuration.vsEnterprise.dsc.yaml
@@ -35,6 +35,13 @@ properties:
           - Microsoft.VisualStudio.Workload.NativeDesktop
           - Microsoft.VisualStudio.Component.VC.Llvm.Clang
           - Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset
+    - resource: Microsoft.WinGet.DSC/WinGetPackage
+      id: rustPackage
+      directives:
+        description: Install Rust with MSVC toolchain
+      settings:
+        id: Rustlang.Rust.MSVC
+        source: winget
     - resource: Microsoft.WinGet.DSC/WinGetPackage
       id: gitPackage
       directives:
@@ -51,4 +58,4 @@ properties:
       settings:
         id: Nasm.Nasm
         source: winget
-  configurationVersion: 0.1.1
+  configurationVersion: 0.2.0
diff --git a/.configurations/configuration.vsProfessional.dsc.yaml b/.configurations/configuration.vsProfessional.dsc.yaml
index e094059e826c0e..7d2a8b36984ccf 100644
--- a/.configurations/configuration.vsProfessional.dsc.yaml
+++ b/.configurations/configuration.vsProfessional.dsc.yaml
@@ -35,6 +35,13 @@ properties:
           - Microsoft.VisualStudio.Workload.NativeDesktop
           - Microsoft.VisualStudio.Component.VC.Llvm.Clang
           - Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset
+    - resource: Microsoft.WinGet.DSC/WinGetPackage
+      id: rustPackage
+      directives:
+        description: Install Rust with MSVC toolchain
+      settings:
+        id: Rustlang.Rust.MSVC
+        source: winget
     - resource: Microsoft.WinGet.DSC/WinGetPackage
       id: gitPackage
       directives:
@@ -51,4 +58,4 @@ properties:
       settings:
         id: Nasm.Nasm
         source: winget
-  configurationVersion: 0.1.1
+  configurationVersion: 0.2.0
diff --git a/BUILDING.md b/BUILDING.md
index 5cf5e9f57d6753..d70f084783d527 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -796,6 +796,7 @@ easily. These files will install the following
 * `Python 3.14`
 * `Visual Studio 2022` (Build Tools, Community, Professional or Enterprise Edition) and
   "Desktop development with C++" workload, Clang and ClangToolset optional components
+* `Rust Toolchain MSVC`
 * `NetWide Assembler`
 
 The following Desired State Configuration (DSC) files are available:

From 5605f6bca4bec6146af5bf678e44403df41cae91 Mon Sep 17 00:00:00 2001
From: YuSheng Chen <samuel871211@gmail.com>
Date: Wed, 20 May 2026 06:57:05 +0800
Subject: [PATCH 21/83] doc: update http2's `push` and `trailers` events with
 `rawHeaders` param

Signed-off-by: Yu-Sheng Chen <samuel871211@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63259
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/http2.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/doc/api/http2.md b/doc/api/http2.md
index b179743d85a121..ff717b93fdecac 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -1341,10 +1341,11 @@ added: v8.4.0
 
 * `headers` {HTTP/2 Headers Object} An object describing the headers
 * `flags` {number} The associated numeric flags
+* `rawHeaders` {HTTP/2 Raw Headers}
 
 The `'trailers'` event is emitted when a block of headers associated with
-trailing header fields is received. The listener callback is passed the
-[HTTP/2 Headers Object][] and flags associated with the headers.
+trailing header fields is received. The listener callback is passed the [HTTP/2 Headers Object][], flags associated
+with the headers, and the headers in raw format (see [HTTP/2 Raw Headers][]).
 
 This event might not be emitted if `http2stream.end()` is called
 before trailers are received and the incoming data is not being read or
@@ -1704,10 +1705,11 @@ added: v8.4.0
 
 * `headers` {HTTP/2 Headers Object}
 * `flags` {number}
+* `rawHeaders` {HTTP/2 Raw Headers}
 
 The `'push'` event is emitted when response headers for a Server Push stream
-are received. The listener callback is passed the [HTTP/2 Headers Object][] and
-flags associated with the headers.
+are received. The listener callback is passed the [HTTP/2 Headers Object][], flags associated
+with the headers, and the headers in raw format (see [HTTP/2 Raw Headers][]).
 
 ```js
 stream.on('push', (headers, flags) => {

From 4f4077a299f1d2d42d35b89edd34216a4411819a Mon Sep 17 00:00:00 2001
From: Claudio Wunder <cwunder@gnome.org>
Date: Tue, 19 May 2026 20:02:54 -0300
Subject: [PATCH 22/83] doc: remove the bi-monthly contributor spotlight
 section
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/62734
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/contributing/recognizing-contributors.md | 26 --------------------
 1 file changed, 26 deletions(-)

diff --git a/doc/contributing/recognizing-contributors.md b/doc/contributing/recognizing-contributors.md
index c0bf37247e3121..f79bd8dd2c55ca 100644
--- a/doc/contributing/recognizing-contributors.md
+++ b/doc/contributing/recognizing-contributors.md
@@ -49,29 +49,3 @@ making a request in the #nodejs-social channel in the OpenJS Foundation slack.
 We trust that collaborators will only request amplification when they believe
 the event is relevant to the Node.js community and the content of the post is
 in line with the norms of the project.
-
-## Bi-monthly contributor spotlight
-
-The contributor spotlight program showcases individual(s) or teams who have
-made signification contributions to the project. Anybody who is not
-a member of the Technical Steering Committee (TSC) and has made a
-notable contribution to the project can be nominated. They DO NOT need
-to be a collaborator, team member etc.
-
-The work of the team or individual(s) will be showcased on the
-Node.js social channels and, if warranted, through a blog post created by the
-OpenJS marketing staff along with the team or individual(s) which will
-be published on [openjsf.org](https://openjsf.org/).
-
-Nominations can be made through this web form:
-[Contributor Spotlight nomination](https://forms.gle/dXBXZn8yu83HLJ57A)
-
-Nominations will be reviewed/approved by the Technical Steering Committee (TSC)
-on a regular basis as scheduled by the TSC chair. The TSC will also
-recommend the order in which approved nominations are processed
-by the OpenJS marketing staff.
-
-Before any work proceeds on an approved nomination the individual(s)
-or team will be contacted to confirm they want to participate. Social
-content and or spotlight blog post will only be published after the
-team or individual(s) have confirmed they are happy with the content.

From 0c7034f5aef0095254af484312322a6dc2cef02e Mon Sep 17 00:00:00 2001
From: joao-oliveira-softtor <joao.oliveira@softtor.com.br>
Date: Tue, 19 May 2026 20:19:36 -0300
Subject: [PATCH 23/83] doc: fix article usage before vowel-sound acronyms
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Several prose references to HTTP, HTTPS, SSL, HPE_HEADER_OVERFLOW
and ECMAScript used the article "a" where the acronym starts with
a vowel sound and should take "an". The rule is based on
pronunciation, not spelling: HTTP is read "aitch-tee-tee-pee",
SSL is read "ess-es-el", ECMAScript is read "ek-mah-script",
and HPE is read "aitch-pee-ee" — all starting with a vowel sound.

Affected files:

* doc/api/crypto.md — "disable a SSL 3.0/TLS 1.0 vulnerability"
* doc/api/http.md — five occurrences ("a HTTP '400 Bad Request'",
  "a HTTP '431 Request Header Fields Too Large'", "a HTTP/1.1 102
  Processing message", two copies of "use a HTTP parser") plus
  two references to "a HPE_HEADER_OVERFLOW"
* doc/api/http2.md — two code-sample comments reading
  "// Detects if it is a HTTPS request or HTTP/2"
* doc/api/module.md — "compiles a CommonJS, a ECMAScript Module,
  or a TypeScript module" (only the middle article changes; the
  adjacent "a CommonJS" and "a TypeScript" are both correct)
* doc/api/tls.md — two references to "part of a SSL/TLS handshake"
  in tlsSocket.getFinished() and tlsSocket.getPeerFinished()

No behavior changes, documentation only.

Signed-off-by: João Victor Oliveira <joao.oliveira@softtor.com.br>
PR-URL: https://github.com/nodejs/node/pull/62696
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Akhil Marsonya <akhil.marsonya27@gmail.com>
Reviewed-By: Jacob Smith <jacob@frende.me>
---
 doc/api/crypto.md |  2 +-
 doc/api/http.md   | 12 ++++++------
 doc/api/http2.md  |  4 ++--
 doc/api/module.md |  2 +-
 doc/api/tls.md    |  4 ++--
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index adaf8f64b56733..efb3fa4a6cf0ee 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -6657,7 +6657,7 @@ See the [list of SSL OP Flags][] for details.
   </tr>
   <tr>
     <td><code>SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS</code></td>
-    <td>Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability
+    <td>Instructs OpenSSL to disable an SSL 3.0/TLS 1.0 vulnerability
     workaround added in OpenSSL 0.9.6d.</td>
   </tr>
   <tr>
diff --git a/doc/api/http.md b/doc/api/http.md
index a916337287e109..3daf37737d0c2a 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1516,7 +1516,7 @@ changes:
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/25605
     description: The default behavior will return a 431 Request Header
-                 Fields Too Large if a HPE_HEADER_OVERFLOW error occurs.
+                 Fields Too Large if an HPE_HEADER_OVERFLOW error occurs.
   - version: v9.4.0
     pr-url: https://github.com/nodejs/node/pull/17672
     description: The `rawPacket` is the current buffer that just parsed. Adding
@@ -1542,8 +1542,8 @@ This event is guaranteed to be passed an instance of the {net.Socket} class,
 a subclass of {stream.Duplex}, unless the user specifies a socket
 type other than {net.Socket}.
 
-Default behavior is to try close the socket with a HTTP '400 Bad Request',
-or a HTTP '431 Request Header Fields Too Large' in the case of a
+Default behavior is to try close the socket with an HTTP '400 Bad Request',
+or an HTTP '431 Request Header Fields Too Large' in the case of an
 [`HPE_HEADER_OVERFLOW`][] error. If the socket is not writable or headers
 of the current attached [`http.ServerResponse`][] has been sent, it is
 immediately destroyed.
@@ -2735,7 +2735,7 @@ response.writeInformation(110, { 'X-Progress': '50%' });
 added: v10.0.0
 -->
 
-Sends a HTTP/1.1 102 Processing message to the client, indicating that
+Sends an HTTP/1.1 102 Processing message to the client, indicating that
 the request body should be sent.
 
 ## Class: `http.IncomingMessage`
@@ -3734,7 +3734,7 @@ changes:
     `readableHighWaterMark` and `writableHighWaterMark`. This affects
     `highWaterMark` property of both `IncomingMessage` and `ServerResponse`.
     **Default:** See [`stream.getDefaultHighWaterMark()`][].
-  * `insecureHTTPParser` {boolean} If set to `true`, it will use a HTTP parser
+  * `insecureHTTPParser` {boolean} If set to `true`, it will use an HTTP parser
     with leniency flags enabled. Using the insecure parser should be avoided.
     See [`--insecure-http-parser`][] for more information.
     **Default:** `false`.
@@ -4045,7 +4045,7 @@ changes:
     request to. **Default:** `'localhost'`.
   * `hostname` {string} Alias for `host`. To support [`url.parse()`][],
     `hostname` will be used if both `host` and `hostname` are specified.
-  * `insecureHTTPParser` {boolean} If set to `true`, it will use a HTTP parser
+  * `insecureHTTPParser` {boolean} If set to `true`, it will use an HTTP parser
     with leniency flags enabled. Using the insecure parser should be avoided.
     See [`--insecure-http-parser`][] for more information.
     **Default:** `false`
diff --git a/doc/api/http2.md b/doc/api/http2.md
index ff717b93fdecac..fff90abe41fde6 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -3976,7 +3976,7 @@ const server = createSecureServer(
 ).listen(8000);
 
 function onRequest(req, res) {
-  // Detects if it is a HTTPS request or HTTP/2
+  // Detects if it is an HTTPS request or HTTP/2
   const { socket: { alpnProtocol } } = req.httpVersion === '2.0' ?
     req.stream.session : req;
   res.writeHead(200, { 'content-type': 'application/json' });
@@ -4000,7 +4000,7 @@ const server = createSecureServer(
 ).listen(4443);
 
 function onRequest(req, res) {
-  // Detects if it is a HTTPS request or HTTP/2
+  // Detects if it is an HTTPS request or HTTP/2
   const { socket: { alpnProtocol } } = req.httpVersion === '2.0' ?
     req.stream.session : req;
   res.writeHead(200, { 'content-type': 'application/json' });
diff --git a/doc/api/module.md b/doc/api/module.md
index 451c8b3348a47a..62780536914f96 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -366,7 +366,7 @@ changes:
 
 The module compile cache can be enabled either using the [`module.enableCompileCache()`][]
 method or the [`NODE_COMPILE_CACHE=dir`][] environment variable. After it is enabled,
-whenever Node.js compiles a CommonJS, a ECMAScript Module, or a TypeScript module, it will
+whenever Node.js compiles a CommonJS, an ECMAScript Module, or a TypeScript module, it will
 use on-disk [V8 code cache][] persisted in the specified directory to speed up the compilation.
 This may slow down the first load of a module graph, but subsequent loads of the same module
 graph may get a significant speedup if the contents of the modules do not change.
diff --git a/doc/api/tls.md b/doc/api/tls.md
index dc4719d391d003..5d11e2c53eada0 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -1212,7 +1212,7 @@ added: v9.9.0
 -->
 
 * Returns: {Buffer|undefined} The latest `Finished` message that has been
-  sent to the socket as part of a SSL/TLS handshake, or `undefined` if
+  sent to the socket as part of an SSL/TLS handshake, or `undefined` if
   no `Finished` message has been sent yet.
 
 As the `Finished` messages are message digests of the complete handshake
@@ -1355,7 +1355,7 @@ added: v9.9.0
 -->
 
 * Returns: {Buffer|undefined} The latest `Finished` message that is expected
-  or has actually been received from the socket as part of a SSL/TLS handshake,
+  or has actually been received from the socket as part of an SSL/TLS handshake,
   or `undefined` if there is no `Finished` message so far.
 
 As the `Finished` messages are message digests of the complete handshake

From f8685431d34cc3495af5cc8682011b1313b812dc Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Tue, 19 May 2026 17:15:34 -0700
Subject: [PATCH 24/83] test: deflake connection refused proxy tests

Use 127.0.0.1:10, matching existing refused-connection tests, instead
of binding and releasing an ephemeral port that can be reused before
the child process connects.

Clear NO_PROXY and no_proxy so local proxy bypass settings do not skip
the proxy connection attempt.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63395
Refs: https://github.com/nodejs/reliability/blob/main/reports/2026-05-15.md#jstest-failure
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 ...-http-proxy-request-connection-refused.mjs | 37 +++++-----------
 ...https-proxy-request-connection-refused.mjs | 42 ++++++-------------
 2 files changed, 24 insertions(+), 55 deletions(-)

diff --git a/test/client-proxy/test-http-proxy-request-connection-refused.mjs b/test/client-proxy/test-http-proxy-request-connection-refused.mjs
index d07cf8ce530203..bf8fe9baff27f5 100644
--- a/test/client-proxy/test-http-proxy-request-connection-refused.mjs
+++ b/test/client-proxy/test-http-proxy-request-connection-refused.mjs
@@ -15,34 +15,19 @@ await once(server, 'listening');
 const serverHost = `localhost:${server.address().port}`;
 const requestUrl = `http://${serverHost}/test`;
 
-let maxRetries = 10;
 let foundRefused = false;
-while (maxRetries-- > 0) {
-  // Make it fail on connection refused by connecting to a port of a closed server.
-  // If it succeeds, get a different port and retry.
-  const proxy = http.createServer((req, res) => {
-    res.destroy();
-  });
-  proxy.listen(0);
-  await once(proxy, 'listening');
-  const port = proxy.address().port;
-  proxy.close();
-  await once(proxy, 'close');
+const port = 10;
+console.log(`Trying proxy at port ${port}`);
+const { stderr } = await runProxiedRequest({
+  NODE_USE_ENV_PROXY: 1,
+  REQUEST_URL: requestUrl,
+  HTTP_PROXY: `http://127.0.0.1:${port}`,
+  NO_PROXY: '',
+  no_proxy: '',
+  REQUEST_TIMEOUT: 5000,
+});
 
-  console.log(`Trying proxy at port ${port}`);
-  const { stderr } = await runProxiedRequest({
-    NODE_USE_ENV_PROXY: 1,
-    REQUEST_URL: requestUrl,
-    HTTP_PROXY: `http://localhost:${port}`,
-    REQUEST_TIMEOUT: 5000,
-  });
-
-  foundRefused = /Error.*connect ECONNREFUSED/.test(stderr);
-  if (foundRefused) {
-    // The proxy client should get a connection refused error.
-    break;
-  }
-}
+foundRefused = /Error.*connect ECONNREFUSED/.test(stderr);
 
 server.close();
 assert(foundRefused, 'Expected ECONNREFUSED error from proxy request');
diff --git a/test/client-proxy/test-https-proxy-request-connection-refused.mjs b/test/client-proxy/test-https-proxy-request-connection-refused.mjs
index f2a9875a4ef44a..f1c0de89ba957a 100644
--- a/test/client-proxy/test-https-proxy-request-connection-refused.mjs
+++ b/test/client-proxy/test-https-proxy-request-connection-refused.mjs
@@ -5,7 +5,6 @@ import fixtures from '../common/fixtures.js';
 import assert from 'node:assert';
 import { once } from 'events';
 import { runProxiedRequest } from '../common/proxy-server.js';
-import http from 'node:http';
 
 if (!common.hasCrypto)
   common.skip('missing crypto');
@@ -25,35 +24,20 @@ await once(server, 'listening');
 const serverHost = `localhost:${server.address().port}`;
 const requestUrl = `https://${serverHost}/test`;
 
-let maxRetries = 10;
 let foundRefused = false;
-while (maxRetries-- > 0) {
-  // Make it fail on connection refused by connecting to a port of a closed server.
-  // If it succeeds, get a different port and retry.
-  const proxy = http.createServer((req, res) => {
-    res.destroy();
-  });
-  proxy.listen(0);
-  await once(proxy, 'listening');
-  const port = proxy.address().port;
-  proxy.close();
-  await once(proxy, 'close');
-
-  console.log(`Trying proxy at port ${port}`);
-  const { stderr } = await runProxiedRequest({
-    NODE_USE_ENV_PROXY: 1,
-    REQUEST_URL: requestUrl,
-    HTTPS_PROXY: `http://localhost:${port}`,
-    NODE_EXTRA_CA_CERTS: fixtures.path('keys', 'fake-startcom-root-cert.pem'),
-    REQUEST_TIMEOUT: 5000,
-  });
-
-  foundRefused = /Error.*connect ECONNREFUSED/.test(stderr);
-  if (foundRefused) {
-    // The proxy client should get a connection refused error.
-    break;
-  }
-}
+const port = 10;
+console.log(`Trying proxy at port ${port}`);
+const { stderr } = await runProxiedRequest({
+  NODE_USE_ENV_PROXY: 1,
+  REQUEST_URL: requestUrl,
+  HTTPS_PROXY: `http://127.0.0.1:${port}`,
+  NO_PROXY: '',
+  no_proxy: '',
+  NODE_EXTRA_CA_CERTS: fixtures.path('keys', 'fake-startcom-root-cert.pem'),
+  REQUEST_TIMEOUT: 5000,
+});
+
+foundRefused = /Error.*connect ECONNREFUSED/.test(stderr);
 
 server.close();
 assert(foundRefused, 'Expected ECONNREFUSED error from proxy request');

From 0e8fb913d857b0d4123995e401293a0c9ee5efd8 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Tue, 19 May 2026 20:26:58 -0700
Subject: [PATCH 25/83] test: disable Maglev in near-heap-limit worker test

The test expects the worker to run out of memory during startup while
creating the message port. With Maglev enabled, the tiny worker heap
can be exhausted earlier while generating deoptimization data, which
changes the failure mode.

Disable Maglev so the induced OOM reaches the path covered by the test.

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63398
Refs: https://github.com/nodejs/reliability/blob/main/reports/2026-05-18.md#jstest-failure
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Richard Lau <richard.lau@ibm.com>
---
 test/parallel/test-worker-nearheaplimit-deadlock.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-worker-nearheaplimit-deadlock.js b/test/parallel/test-worker-nearheaplimit-deadlock.js
index b22c86b211611f..b7f19f6089e88c 100644
--- a/test/parallel/test-worker-nearheaplimit-deadlock.js
+++ b/test/parallel/test-worker-nearheaplimit-deadlock.js
@@ -1,7 +1,9 @@
-// Flags: --no-node-snapshot
+// Flags: --no-node-snapshot --no-maglev
 // With node snapshot the OOM can occur during the deserialization of the
 // context, so disable it since we want the OOM to occur during the creation of
 // the message port.
+// With Maglev, the OOM can occur during compilation instead, so disable it for
+// the same reason.
 'use strict';
 const common = require('../common');
 const assert = require('assert');

From 09b369fd46493e5af11ece5dfe26a065c4ddd917 Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Wed, 20 May 2026 03:40:57 -0400
Subject: [PATCH 26/83] meta: move one or more collaborators to emeritus

PR-URL: https://github.com/nodejs/node/pull/63402
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Debadree Chatterjee <debadree333@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 55f15c5a8045dc..c2012523eb199a 100644
--- a/README.md
+++ b/README.md
@@ -317,8 +317,6 @@ For information about the governance of the Node.js project, see
   **Daeyeon Jeong** <<daeyeon.dev@gmail.com>> (he/him)
 * [dario-piotrowicz](https://github.com/dario-piotrowicz) -
   **Dario Piotrowicz** <<dario.piotrowicz@gmail.com>> (he/him)
-* [debadree25](https://github.com/debadree25) -
-  **Debadree Chatterjee** <<debadree333@gmail.com>> (he/him)
 * [deokjinkim](https://github.com/deokjinkim) -
   **Deokjin Kim** <<deokjin81.kim@gmail.com>> (he/him)
 * [edsadr](https://github.com/edsadr) -
@@ -365,8 +363,6 @@ For information about the governance of the Node.js project, see
   **James M Snell** <<jasnell@gmail.com>> (he/him)
 * [jazelly](https://github.com/jazelly) -
   **Jason Zhang** <<xzha4350@gmail.com>> (he/him)
-* [JonasBa](https://github.com/JonasBa) -
-  **Jonas Badalic** <<jonas.badalic@gmail.com>> (he/him)
 * [joyeecheung](https://github.com/joyeecheung) -
   **Joyee Cheung** <<joyeec9h3@gmail.com>> (she/her)
 * [juanarbol](https://github.com/juanarbol) -
@@ -507,6 +503,8 @@ For information about the governance of the Node.js project, see
   **David Cai** <<davidcai1993@yahoo.com>> (he/him)
 * [davisjam](https://github.com/davisjam) -
   **Jamie Davis** <<davisjam@vt.edu>> (he/him)
+* [debadree25](https://github.com/debadree25) -
+  **Debadree Chatterjee** <<debadree333@gmail.com>> (he/him)
 * [devnexen](https://github.com/devnexen) -
   **David Carlier** <<devnexen@gmail.com>>
 * [devsnek](https://github.com/devsnek) -
@@ -571,6 +569,8 @@ For information about the governance of the Node.js project, see
   **João Reis** <<reis@janeasystems.com>>
 * [joesepi](https://github.com/joesepi) -
   **Joe Sepi** <<sepi@joesepi.com>> (he/him)
+* [JonasBa](https://github.com/JonasBa) -
+  **Jonas Badalic** <<jonas.badalic@gmail.com>> (he/him)
 * [joshgav](https://github.com/joshgav) -
   **Josh Gavant** <<josh.gavant@outlook.com>>
 * [julianduque](https://github.com/julianduque) -

From 701f73589b03d9101f14af63d4b0198691105526 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 20 May 2026 09:55:01 +0200
Subject: [PATCH 27/83] doc: fix promise nomenclature in `stream_iter.md`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63406
Reviewed-By: René <contact.9a5d6388@renegade334.me.uk>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/fs.md          | 16 ++++++++--------
 doc/api/stream_iter.md | 36 ++++++++++++++++++------------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 884e5935219b67..56291efa8a1971 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1034,16 +1034,16 @@ added:
     Set this to match the reader's `chunkSize` for optimal `pipeTo()`
     performance. **Default:** `131072` (128 KB).
 * Returns: {Object}
-  * `write(chunk[, options])` {Function} Returns {Promise\<void>}.
+  * `write(chunk[, options])` {Function} Returns {Promise}.
     Accepts `Uint8Array`, `Buffer`, or string (UTF-8 encoded).
     * `chunk` {Buffer|TypedArray|DataView|string}
     * `options` {Object}
       * `signal` {AbortSignal} If the signal is already aborted, the write
         rejects with `AbortError` without performing I/O.
-  * `writev(chunks[, options])` {Function} Returns {Promise\<void>}. Uses
+  * `writev(chunks[, options])` {Function} Returns {Promise}. Uses
     scatter/gather I/O via a single `writev()` syscall. Accepts mixed
     `Uint8Array`/string arrays.
-    * `chunks` {Array\<Buffer|TypedArray|DataView|string>}
+    * `chunks` {Buffer\[]|TypedArray\[]|DataView\[]|string\[]}
     * `options` {Object}
       * `signal` {AbortSignal} If the signal is already aborted, the write
         rejects with `AbortError` without performing I/O.
@@ -1055,10 +1055,10 @@ added:
     * `chunk` {Buffer|TypedArray|DataView|string}
   * `writevSync(chunks)` {Function} Returns {boolean}. Synchronous batch
     write. Same fallback semantics as `writeSync()`.
-    * `chunks` {Array\<Buffer|TypedArray|DataView|string>}
-  * `end([options])` {Function} Returns {Promise\<number>} total bytes
-    written. Idempotent: returns `totalBytesWritten` if already closed,
-    returns the pending promise if already closing. Rejects if the writer
+    * `chunks` {Buffer\[]|TypedArray\[]|DataView\[]|string\[]}
+  * `end([options])` {Function} Returns {Promise}, fulfills with the total
+    number of bytes written. Idempotent: returns `totalBytesWritten` if already
+    closed, returns the pending promise if already closing. Rejects if the writer
     is in an errored state.
     * `options` {Object}
       * `signal` {AbortSignal} If the signal is already aborted, `end()`
@@ -2815,7 +2815,7 @@ changes:
   * `filter` {Function} Function to filter copied files/directories. Return
     `true` to copy the item, `false` to ignore it. When ignoring a directory,
     all of its contents will be skipped as well. Can also return a `Promise`
-    that resolves to `true` or `false` **Default:** `undefined`.
+    that fulfills with `true` or `false`. **Default:** `undefined`.
     * `src` {string} source path to copy.
     * `dest` {string} destination path to copy to.
     * Returns: {boolean|Promise} A value that is coercible to `boolean` or
diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md
index 611f1bf88c7c02..ab4915cc76b247 100644
--- a/doc/api/stream_iter.md
+++ b/doc/api/stream_iter.md
@@ -220,7 +220,7 @@ that closes when the bucket is full:
 
 * **Pending writes (the hose)** -- writes waiting for slot space. After
   the consumer drains, pending writes are promoted into the now-empty
-  slots and their promises resolve.
+  slots and their promises settle.
 
 How each policy uses these buffers:
 
@@ -430,7 +430,7 @@ The value is always non-negative.
 * `options` {Object}
   * `signal` {AbortSignal} Cancel just this operation. The signal cancels only
     the pending `end()` call; it does not fail the writer itself.
-* Returns: {Promise\<number>} Total bytes written.
+* Returns: {Promise} Fulfills with the total number of bytes written.
 
 Signal that no more data will be written.
 
@@ -463,9 +463,9 @@ transition with no async work to perform.
 * `options` {Object}
   * `signal` {AbortSignal} Cancel just this write operation. The signal cancels
     only the pending `write()` call; it does not fail the writer itself.
-* Returns: {Promise\<void>}
+* Returns: {Promise} Fulfills with `undefined` when buffer space is available.
 
-Write a chunk. The promise resolves when buffer space is available.
+Write a chunk.
 
 #### `writer.writeSync(chunk)`
 
@@ -481,7 +481,7 @@ Synchronous write. Does not block; returns `false` if backpressure is active.
 * `options` {Object}
   * `signal` {AbortSignal} Cancel just this write operation. The signal cancels
     only the pending `writev()` call; it does not fail the writer itself.
-* Returns: {Promise\<void>}
+* Returns: {Promise}
 
 Write multiple chunks as a single batch.
 
@@ -606,7 +606,7 @@ added:
     the source ends. **Default:** `false`.
   * `preventFail` {boolean} If `true`, do not call `writer.fail()` on
     error. **Default:** `false`.
-* Returns: {Promise\<number>} Total bytes written.
+* Returns: {Promise} Fulfills with the total number of bytes written.
 
 Pipe a source through transforms into a writer. If the writer has a
 `writev(chunks)` method, entire batches are passed in a single call (enabling
@@ -912,7 +912,7 @@ added:
   * `signal` {AbortSignal}
   * `limit` {number} Maximum number of bytes to consume. If the total bytes
     collected exceeds limit, an `ERR_OUT_OF_RANGE` error is thrown
-* Returns: {Promise\<Uint8Array\[]>}
+* Returns: {Promise} Fulfills with an array of `Uint8Array` objects.
 
 Collect all chunks as an array of `Uint8Array` values (without concatenating).
 
@@ -928,7 +928,7 @@ added:
   * `signal` {AbortSignal}
   * `limit` {number} Maximum number of bytes to consume. If the total bytes
     collected exceeds limit, an `ERR_OUT_OF_RANGE` error is thrown
-* Returns: {Promise\<ArrayBuffer>}
+* Returns: {Promise} Fulfills with an `ArrayBuffer` object.
 
 Collect all bytes into an `ArrayBuffer`.
 
@@ -974,7 +974,7 @@ added:
   * `signal` {AbortSignal}
   * `limit` {number} Maximum number of bytes to consume. If the total bytes
     collected exceeds limit, an `ERR_OUT_OF_RANGE` error is thrown
-* Returns: {Promise\<Uint8Array>}
+* Returns: {Promise} Fulfills with an `Uint8Array` object.
 
 Collect all bytes from a stream into a single `Uint8Array`.
 
@@ -1024,7 +1024,7 @@ added:
   * `signal` {AbortSignal}
   * `limit` {number} Maximum number of bytes to consume. If the total bytes
     collected exceeds limit, an `ERR_OUT_OF_RANGE` error is thrown
-* Returns: {Promise\<string>}
+* Returns: {Promise} Fulfills with a `string`.
 
 Collect all bytes and decode as text.
 
@@ -1070,11 +1070,11 @@ added:
 -->
 
 * `drainable` {Object} An object implementing the drainable protocol.
-* Returns: {Promise\<boolean>|null}
+* Returns: {Promise|null}
 
-Wait for a drainable writer's backpressure to clear. Returns a promise that
-resolves to `true` when the writer can accept more data, or `null` if the
-object does not implement the drainable protocol.
+Wait for a drainable writer's backpressure to clear. Returns `null` if
+the object does not implement the drainable protocol, or a promise that
+fulfills with `true` when the writer can accept more data.
 
 ```mjs
 import { push, ondrain, text } from 'node:stream/iter';
@@ -1794,8 +1794,8 @@ text(consumer).then(console.log); // 'hello'
 * Value: `Symbol.for('Stream.drainableProtocol')`
 
 Implement to make a writer compatible with `ondrain()`. The method should
-return a promise that resolves when backpressure clears, or `null` if no
-backpressure.
+return `null` if no backpressure, or a promise that fulfills with a truthy value
+when backpressure clears.
 
 ```mjs
 import { ondrain } from 'node:stream/iter';
@@ -2001,8 +2001,8 @@ console.log(textSync(consumer)); // 'hello'
 The value must be a function that converts the object into a streamable value.
 When the object is encountered anywhere in the streaming pipeline (as a source
 passed to `from()`, or as a value returned from a transform), this method is
-called to produce the actual data. It may return (or resolve to) any streamable
-value: a string, `Uint8Array`, `AsyncIterable`, `Iterable`, or another streamable
+called to produce the actual data. It may return any value that resolves to:
+a string, `Uint8Array`, `AsyncIterable`, `Iterable`, or another streamable
 object.
 
 ```mjs

From 59e8484abd311a4cc97c779c04903c6573d12765 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9?= <contact.9a5d6388@renegade334.me.uk>
Date: Wed, 20 May 2026 08:56:21 +0100
Subject: [PATCH 28/83] doc: remove unsupported template type from v8.md

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>
PR-URL: https://github.com/nodejs/node/pull/63410
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/v8.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/v8.md b/doc/api/v8.md
index fee6b067596fde..cf8777db973425 100644
--- a/doc/api/v8.md
+++ b/doc/api/v8.md
@@ -389,7 +389,7 @@ changes:
   * `format` {string} If it's `'count'`, the count of matched objects
     is returned. If it's `'summary'`, an array with summary strings
     of the matched objects is returned.
-* Returns: {number|Array<string>}
+* Returns: {number|string\[]}
 
 This is similar to the [`queryObjects()` console API][] provided by the
 Chromium DevTools console. It can be used to search for objects that

From d9558968d9f4c442d83fa2848e0d9e06e4a37489 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 20 May 2026 10:00:45 +0200
Subject: [PATCH 29/83] 2026-05-20, Version 26.2.0 (Current)

Notable changes:

doc:
  * mark `stream.compose` stable (Matteo Collina) https://github.com/nodejs/node/pull/62562
fs:
  * (SEMVER-MINOR) add `Temporal.Instant` support to `Stats` and `BigIntStats` (Livia Medeiros) https://github.com/nodejs/node/pull/60789
http:
  * (SEMVER-MINOR) add `writeInformation` to send arbitrary 1xx status codes (Tim Perry) https://github.com/nodejs/node/pull/63155

PR-URL: https://github.com/nodejs/node/pull/63440
---
 CHANGELOG.md                    |   3 +-
 doc/api/cli.md                  |   2 +-
 doc/api/debugger.md             |   2 +-
 doc/api/deprecations.md         |   2 +-
 doc/api/errors.md               |   6 +-
 doc/api/fs.md                   |   2 +-
 doc/api/http.md                 |   2 +-
 doc/api/http2.md                |   2 +-
 doc/api/n-api.md                |   2 +-
 doc/api/quic.md                 | 142 ++++++++++++++++----------------
 doc/api/stream.md               |   2 +-
 doc/api/test.md                 |  10 +--
 doc/changelogs/CHANGELOG_V26.md | 128 ++++++++++++++++++++++++++++
 13 files changed, 217 insertions(+), 88 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 984419475dbd2e..c20d0ea446bf2d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -42,7 +42,8 @@ release.
 </tr>
 <tr>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V26.md#26.1.0">26.1.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V26.md#26.2.0">26.2.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V26.md#26.1.0">26.1.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V26.md#26.0.0">26.0.0</a><br/>
   </td>
   <td valign="top">
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 8f7d6185ac464c..f544e0a0d68881 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1416,7 +1416,7 @@ This feature requires `--allow-worker` if used with the [Permission Model][].
 ### `--experimental-test-tag-filter=<tag>`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1.0 - Early development
diff --git a/doc/api/debugger.md b/doc/api/debugger.md
index 0ac62b64dcc984..5eeffd43e57f5f 100644
--- a/doc/api/debugger.md
+++ b/doc/api/debugger.md
@@ -236,7 +236,7 @@ debug>
 added:
   - v26.1.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63286
     description: JSON report schema bumped to v2. Probe `target` is now
         `{ suffix, line, column? }` instead of an array. Each "hit" event carries a
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 68dd5a4a36561c..6e4f4de2f144a7 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -4562,7 +4562,7 @@ removed in a future version of Node.js.
 
 <!-- YAML
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63121
     description: Documentation-only deprecation.
 -->
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 8e0956c29f3843..e8c87ebb502fdc 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -2470,7 +2470,7 @@ compiled with ICU support.
 ### `ERR_NO_TEMPORAL`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 An attempt was made to use features that require [`Temporal`][], but Node.js was not
@@ -2668,7 +2668,7 @@ Opening a QUIC stream failed.
 ### `ERR_QUIC_STREAM_ABORTED`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1 - Experimental
@@ -2681,7 +2681,7 @@ or session with an explicit application or transport error code.
 ### `ERR_QUIC_STREAM_RESET`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1 - Experimental
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 56291efa8a1971..e1211e4cd25f3f 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -7533,7 +7533,7 @@ i.e. before the `'ready'` event is emitted.
 <!-- YAML
 added: v0.1.21
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/60789
     description: Added `Temporal.Instant` support.
   - version:
diff --git a/doc/api/http.md b/doc/api/http.md
index 3daf37737d0c2a..0775ad1a1a0dec 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -2703,7 +2703,7 @@ will result in a [`TypeError`][] being thrown.
 ### `response.writeInformation(statusCode[, headers][, callback])`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `statusCode` {number} An HTTP 1xx informational status code, between `100`
diff --git a/doc/api/http2.md b/doc/api/http2.md
index fff90abe41fde6..63a86ddc538887 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -4851,7 +4851,7 @@ response.writeEarlyHints({
 #### `response.writeInformation(statusCode[, headers])`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `statusCode` {number} An HTTP 1xx informational status code, between `100`
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index d7e1c202c0ea89..29c0bff1fab712 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2784,7 +2784,7 @@ Language Specification.
 added: v8.0.0
 napiVersion: 1
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/62710
     description: Added support for `SharedArrayBuffer`.
 -->
diff --git a/doc/api/quic.md b/doc/api/quic.md
index ecd0d73803888a..4ad25810ab4627 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -403,7 +403,7 @@ a server once.
 ## `quic.constants`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * {Object}
@@ -541,7 +541,7 @@ True if `endpoint.destroy()` has been called. Read only.
 ### `endpoint.listening`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean}
@@ -551,7 +551,7 @@ True if the endpoint is actively listening for incoming connections. Read only.
 ### `endpoint.maxConnectionsPerHost`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -564,7 +564,7 @@ The valid range is `0` to `65535`.
 ### `endpoint.maxConnectionsTotal`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -771,7 +771,7 @@ promise will reject with an `ERR_QUIC_TRANSPORT_ERROR` or
 ### `session.opened`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Promise} for an {Object}
@@ -811,7 +811,7 @@ A promise that is fulfilled once the session is destroyed.
 ### `session.closing`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean}
@@ -865,7 +865,7 @@ has been destroyed. Read only.
 ### `session.onerror`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function|undefined}
@@ -913,7 +913,7 @@ The callback to invoke when the status of a datagram is updated. Read/write.
 ### `session.onearlyrejected`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function|undefined}
@@ -970,7 +970,7 @@ The callback to invoke when the TLS handshake is completed. Read/write.
 ### `session.onnewtoken`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {quic.OnNewTokenCallback}
@@ -982,7 +982,7 @@ the same server to skip address validation. Read/write.
 ### `session.onorigin`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {quic.OnOriginCallback}
@@ -994,7 +994,7 @@ Read/write.
 ### `session.ongoaway`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function}
@@ -1019,7 +1019,7 @@ This callback is only relevant for HTTP/3 sessions. Read/write.
 ### `session.onkeylog`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {quic.OnKeylogCallback}
@@ -1035,7 +1035,7 @@ Can also be set via the `onkeylog` option in [`quic.connect()`][] or
 ### `session.onqlog`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {quic.OnQlogCallback}
@@ -1192,7 +1192,7 @@ what this endpoint advertises to the peer as its own maximum.
 ### `session.certificate`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|undefined}
@@ -1204,7 +1204,7 @@ if the session is destroyed or no certificate is available.
 ### `session.peerCertificate`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|undefined}
@@ -1216,7 +1216,7 @@ if the session is destroyed or the peer did not present a certificate.
 ### `session.ephemeralKeyInfo`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|undefined}
@@ -1228,7 +1228,7 @@ The ephemeral key information for the session, with properties such as
 ### `session.maxDatagramSize`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -1243,7 +1243,7 @@ will not be sent.
 ### `session.maxPendingDatagrams`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -1480,7 +1480,7 @@ added: v23.8.0
 ## Class: `QuicError`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1 - Experimental
@@ -1522,7 +1522,7 @@ the Node.js convention that `error.code` is a string.
 ### `new QuicError(message, options)`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `message` {string} A human-readable description of the error.
@@ -1556,7 +1556,7 @@ console.log(custom.code);    // 'ERR_MY_QUIC_FAILURE'
 ### `error.errorCode`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {bigint}
@@ -1566,7 +1566,7 @@ The numeric QUIC error code carried by this error.
 ### `error.type`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {string}
@@ -1599,7 +1599,7 @@ CONNECTION\_CLOSE with a non-zero error code).
 <!-- YAML
 added: v23.8.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/62876
     description: Added the `options` parameter accepting `code` and `reason`.
 -->
@@ -1678,7 +1678,7 @@ the implementation falls back to the negotiated application protocol's
 ### `stream.early`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean}
@@ -1705,7 +1705,7 @@ or is still pending. Read only.
 ### `stream.highWaterMark`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -1733,7 +1733,7 @@ pending. Read only.
 ### `stream.onerror`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function|undefined}
@@ -1780,7 +1780,7 @@ whole stream with [`stream.destroy()`][]. Read/write.
 ### `stream.headers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|undefined}
@@ -1797,7 +1797,7 @@ arrays. The object has `__proto__: null`.
 ### `stream.onheaders`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function}
@@ -1812,7 +1812,7 @@ Read/write.
 ### `stream.ontrailers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function}
@@ -1825,7 +1825,7 @@ session that does not support headers. Read/write.
 ### `stream.oninfo`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function}
@@ -1840,7 +1840,7 @@ Read/write.
 ### `stream.onwanttrailers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Function}
@@ -1854,7 +1854,7 @@ Read/write.
 ### `stream.pendingTrailers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|undefined}
@@ -1868,7 +1868,7 @@ Read/write.
 ### `stream.sendHeaders(headers[, options])`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `headers` {Object} Header object with string keys and string or
@@ -1886,7 +1886,7 @@ headers. Throws `ERR_INVALID_STATE` if the session does not support headers.
 ### `stream.sendInformationalHeaders(headers)`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `headers` {Object} Header object. Must include `:status` with a 1xx
@@ -1899,7 +1899,7 @@ Sends informational (1xx) response headers. Server only. Throws
 ### `stream.sendTrailers(headers)`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `headers` {Object} Trailing header object. Pseudo-headers must not be
@@ -1914,7 +1914,7 @@ does not support headers.
 ### `stream.priority`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object|null}
@@ -1933,7 +1933,7 @@ reflects the peer's requested priority (e.g., from `PRIORITY_UPDATE` frames).
 ### `stream.setPriority([options])`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `options` {Object}
@@ -1950,7 +1950,7 @@ has been destroyed.
 ### `stream[Symbol.asyncIterator]()`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Returns: {AsyncIterableIterator} yielding {Uint8Array\[]}
@@ -1983,7 +1983,7 @@ await Stream.pipeTo(stream, someWriter);
 ### `stream.writer`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object}
@@ -2026,7 +2026,7 @@ themselves before passing the buffer.
 ### `stream.setBody(body)`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `body` {string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView |
@@ -2220,7 +2220,7 @@ need to specify.
 #### `endpointOptions.disableStatelessReset`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean}
@@ -2234,7 +2234,7 @@ at a different layer.
 #### `endpointOptions.idleTimeout`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -2420,7 +2420,7 @@ Default: `'h3'`
 #### `sessionOptions.application`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {Object}
@@ -2520,7 +2520,7 @@ per-identity in the [`sessionOptions.sni`][] map.
 #### `sessionOptions.enableEarlyData`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean} **Default:** `true`
@@ -2646,7 +2646,7 @@ added: v23.8.0
 #### `sessionOptions.datagramDropPolicy`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {string}
@@ -2675,7 +2675,7 @@ reached, the datagram is dropped and reported as `'abandoned'` via the
 #### `sessionOptions.drainingPeriodMultiplier`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {number}
@@ -2701,7 +2701,7 @@ to complete before timing out.
 #### `sessionOptions.keepAlive`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {bigint|number}
@@ -2783,7 +2783,7 @@ True to enable TLS tracing output.
 #### `sessionOptions.token` (client only)
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {ArrayBufferView}
@@ -2816,7 +2816,7 @@ Specifies the maximum number of unacknowledged packets a session should allow.
 #### `sessionOptions.rejectUnauthorized`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean} **Default:** `true`
@@ -2830,7 +2830,7 @@ ignored.
 #### `sessionOptions.reuseEndpoint`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * Type: {boolean}
@@ -3137,7 +3137,7 @@ added: v23.8.0
 ### Callback: `OnNewTokenCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicSession}
@@ -3147,7 +3147,7 @@ added: REPLACEME
 ### Callback: `OnOriginCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicSession}
@@ -3156,7 +3156,7 @@ added: REPLACEME
 ### Callback: `OnKeylogCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicSession}
@@ -3171,7 +3171,7 @@ the secret value.
 ### Callback: `OnQlogCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicSession}
@@ -3204,7 +3204,7 @@ added: v23.8.0
 ### Callback: `OnHeadersCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicStream}
@@ -3218,7 +3218,7 @@ on the client.
 ### Callback: `OnTrailersCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicStream}
@@ -3229,7 +3229,7 @@ Called when trailing headers are received from the peer.
 ### Callback: `OnInfoCallback`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `this` {quic.QuicStream}
@@ -3241,7 +3241,7 @@ Called when informational (1xx) headers are received from the server
 ## HTTP/3 support
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 When the negotiated ALPN identifier is `'h3'` (or one of the `'h3-*'`
@@ -3396,7 +3396,7 @@ Server-side notes:
 ## Performance measurement
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 QUIC sessions, streams, and endpoints emit [`PerformanceEntry`][] objects
@@ -3486,7 +3486,7 @@ Published when an endpoint begins listening for incoming connections.
 ### Channel: `quic.endpoint.connect`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `endpoint` {quic.QuicEndpoint}
@@ -3639,7 +3639,7 @@ of the final statistics at the time of destruction.
 ### Channel: `quic.session.error`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `session` {quic.QuicSession}
@@ -3694,7 +3694,7 @@ Published when a path validation attempt completes.
 ### Channel: `quic.session.new.token`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `token` {Buffer} The NEW\_TOKEN token data.
@@ -3732,7 +3732,7 @@ server. The session is always destroyed immediately after.
 ### Channel: `quic.session.receive.origin`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `origins` {string\[]} The list of origins the server is authoritative for.
@@ -3762,7 +3762,7 @@ Published when the TLS handshake completes.
 ### Channel: `quic.session.goaway`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `session` {quic.QuicSession}
@@ -3776,7 +3776,7 @@ a stream boundary.
 ### Channel: `quic.session.early.rejected`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `session` {quic.QuicSession}
@@ -3788,7 +3788,7 @@ latency regressions when 0-RTT is expected to succeed.
 ### Channel: `quic.stream.closed`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
@@ -3802,7 +3802,7 @@ of the final statistics at the time of destruction.
 ### Channel: `quic.stream.headers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
@@ -3817,7 +3817,7 @@ server-side streams, this contains request pseudo-headers (`:method`,
 ### Channel: `quic.stream.trailers`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
@@ -3829,7 +3829,7 @@ Published when trailing headers are received on a stream.
 ### Channel: `quic.stream.info`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
@@ -3842,7 +3842,7 @@ Published when informational (1xx) headers are received on a stream
 ### Channel: `quic.stream.reset`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
@@ -3857,7 +3857,7 @@ requests.
 ### Channel: `quic.stream.blocked`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 * `stream` {quic.QuicStream}
diff --git a/doc/api/stream.md b/doc/api/stream.md
index 95c1ab1e2dc8f5..9e34d78937d88c 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -3013,7 +3013,7 @@ const server = http.createServer((req, res) => {
 <!-- YAML
 added: v16.9.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/62562
     description: Marking the API stable.
   - version:
diff --git a/doc/api/test.md b/doc/api/test.md
index b17c3fd4f6685b..830c5434a49544 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -482,7 +482,7 @@ tests must satisfy **both** requirements in order to be executed.
 ## Test tags
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1.0 - Early development
@@ -1646,7 +1646,7 @@ added:
   - v18.9.0
   - v16.19.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63221
     description: Added the `testTagFilters` option.
   - version:
@@ -1884,7 +1884,7 @@ added:
   - v18.0.0
   - v16.17.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63221
     description: Added the `tags` option.
   - version:
@@ -4234,7 +4234,7 @@ the second attempt is `1`, and so on. This property is useful in conjunction wit
 ### `context.tags`
 
 <!-- YAML
-added: REPLACEME
+added: v26.2.0
 -->
 
 > Stability: 1.0 - Early development
@@ -4462,7 +4462,7 @@ added:
   - v18.0.0
   - v16.17.0
 changes:
-  - version: REPLACEME
+  - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63221
     description: Added the `tags` option.
   - version:
diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md
index 0576adcb2a3966..56812f4d072e2d 100644
--- a/doc/changelogs/CHANGELOG_V26.md
+++ b/doc/changelogs/CHANGELOG_V26.md
@@ -8,6 +8,7 @@
 </tr>
 <tr>
 <td>
+<a href="#26.2.0">26.2.0</a><br/>
 <a href="#26.1.0">26.1.0</a><br/>
 <a href="#26.0.0">26.0.0</a><br/>
 </td>
@@ -42,6 +43,133 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="26.2.0"></a>
+
+## 2026-05-20, Version 26.2.0 (Current), @aduh95
+
+### Notable Changes
+
+* \[[`189d43a193`](https://github.com/nodejs/node/commit/189d43a193)] - **doc**: mark `stream.compose` stable (Matteo Collina) [#62562](https://github.com/nodejs/node/pull/62562)
+* \[[`f858c6140e`](https://github.com/nodejs/node/commit/f858c6140e)] - **(SEMVER-MINOR)** **fs**: add `Temporal.Instant` support to `Stats` and `BigIntStats` (Livia Medeiros) [#60789](https://github.com/nodejs/node/pull/60789)
+* \[[`0cbb3895df`](https://github.com/nodejs/node/commit/0cbb3895df)] - **(SEMVER-MINOR)** **http**: add `writeInformation` to send arbitrary 1xx status codes (Tim Perry) [#63155](https://github.com/nodejs/node/pull/63155)
+
+### Commits
+
+* \[[`9a394bab84`](https://github.com/nodejs/node/commit/9a394bab84)] - **benchmark**: respect stream/iter broadcast backpressure (Trivikram Kamat) [#63314](https://github.com/nodejs/node/pull/63314)
+* \[[`ad98b4620b`](https://github.com/nodejs/node/commit/ad98b4620b)] - **crypto**: align verifyOneShot accepted types (Anshika Jain) [#63280](https://github.com/nodejs/node/pull/63280)
+* \[[`ba0736a847`](https://github.com/nodejs/node/commit/ba0736a847)] - **crypto**: wire ML-DSA and ML-KEM for use when using BoringSSL (Filip Skokan) [#63255](https://github.com/nodejs/node/pull/63255)
+* \[[`5573a6a4a8`](https://github.com/nodejs/node/commit/5573a6a4a8)] - **crypto**: wire ChaCha20-Poly1305 in Web Cryptography when using BoringSSL (Filip Skokan) [#63255](https://github.com/nodejs/node/pull/63255)
+* \[[`7dc563b8d6`](https://github.com/nodejs/node/commit/7dc563b8d6)] - **crypto**: wire AES-KW in Web Cryptography when using BoringSSL (Filip Skokan) [#63255](https://github.com/nodejs/node/pull/63255)
+* \[[`b55e2b1f4d`](https://github.com/nodejs/node/commit/b55e2b1f4d)] - **crypto**: improve system certificate enumeration logic on macOS (Robo) [#62576](https://github.com/nodejs/node/pull/62576)
+* \[[`fd509a755a`](https://github.com/nodejs/node/commit/fd509a755a)] - **crypto**: harden CryptoKey algorithm slots (Filip Skokan) [#63111](https://github.com/nodejs/node/pull/63111)
+* \[[`8657df39e7`](https://github.com/nodejs/node/commit/8657df39e7)] - **crypto**: harden KeyObject internal slots (Filip Skokan) [#63111](https://github.com/nodejs/node/pull/63111)
+* \[[`729274e046`](https://github.com/nodejs/node/commit/729274e046)] - **crypto**: reject invalid raw key imports (Filip Skokan) [#63134](https://github.com/nodejs/node/pull/63134)
+* \[[`8fc9cb9c01`](https://github.com/nodejs/node/commit/8fc9cb9c01)] - **crypto**: improve accuracy of SubtleCrypto.supports (Filip Skokan) [#63104](https://github.com/nodejs/node/pull/63104)
+* \[[`288065cb3f`](https://github.com/nodejs/node/commit/288065cb3f)] - **crypto**: optimize normalizeAlgorithm dispatch hot path (Filip Skokan) [#62756](https://github.com/nodejs/node/pull/62756)
+* \[[`ecf3797d09`](https://github.com/nodejs/node/commit/ecf3797d09)] - **debugger**: disambiguate probe location binding (Joyee Cheung) [#63286](https://github.com/nodejs/node/pull/63286)
+* \[[`bdc57135fd`](https://github.com/nodejs/node/commit/bdc57135fd)] - **debugger**: add --help to `node inspect` and improve docs (Joyee Cheung) [#63201](https://github.com/nodejs/node/pull/63201)
+* \[[`2a6e6058e9`](https://github.com/nodejs/node/commit/2a6e6058e9)] - **deps**: update undici to 8.3.0 (Node.js GitHub Bot) [#63377](https://github.com/nodejs/node/pull/63377)
+* \[[`327b927271`](https://github.com/nodejs/node/commit/327b927271)] - **deps**: update corepack to 0.35.0 (Node.js GitHub Bot) [#63375](https://github.com/nodejs/node/pull/63375)
+* \[[`5828fadf52`](https://github.com/nodejs/node/commit/5828fadf52)] - **deps**: update sqlite to 3.53.1 (Node.js GitHub Bot) [#63217](https://github.com/nodejs/node/pull/63217)
+* \[[`fe127a999b`](https://github.com/nodejs/node/commit/fe127a999b)] - **deps**: update simdjson to 4.6.4 (Node.js GitHub Bot) [#62811](https://github.com/nodejs/node/pull/62811)
+* \[[`a34c4ea159`](https://github.com/nodejs/node/commit/a34c4ea159)] - **deps**: V8: cherry-pick 435a2cdf664c (Matthias Liedtke) [#63136](https://github.com/nodejs/node/pull/63136)
+* \[[`ad91efcc43`](https://github.com/nodejs/node/commit/ad91efcc43)] - **deps**: cherry-pick libuv/libuv\@a43e543 (Ali Hassan) [#63222](https://github.com/nodejs/node/pull/63222)
+* \[[`5ea6c3ee7e`](https://github.com/nodejs/node/commit/5ea6c3ee7e)] - **deps**: add missing static linking targets for libffi (Paolo Insogna) [#63168](https://github.com/nodejs/node/pull/63168)
+* \[[`c1f6ba22b4`](https://github.com/nodejs/node/commit/c1f6ba22b4)] - **deps**: update ngtcp2 to 1.22.1 (Node.js GitHub Bot) [#62812](https://github.com/nodejs/node/pull/62812)
+* \[[`7b8767ef76`](https://github.com/nodejs/node/commit/7b8767ef76)] - **doc**: remove unsupported template type from v8.md (René) [#63410](https://github.com/nodejs/node/pull/63410)
+* \[[`b2ec1880b1`](https://github.com/nodejs/node/commit/b2ec1880b1)] - **doc**: fix promise nomenclature in `stream_iter.md` (Antoine du Hamel) [#63406](https://github.com/nodejs/node/pull/63406)
+* \[[`cf6cbbd39d`](https://github.com/nodejs/node/commit/cf6cbbd39d)] - **doc**: fix article usage before vowel-sound acronyms (joao-oliveira-softtor) [#62696](https://github.com/nodejs/node/pull/62696)
+* \[[`da05065d98`](https://github.com/nodejs/node/commit/da05065d98)] - **doc**: remove the bi-monthly contributor spotlight section (Claudio Wunder) [#62734](https://github.com/nodejs/node/pull/62734)
+* \[[`c31f320fba`](https://github.com/nodejs/node/commit/c31f320fba)] - **doc**: update http2's `push` and `trailers` events with `rawHeaders` param (YuSheng Chen) [#63259](https://github.com/nodejs/node/pull/63259)
+* \[[`f0d008439b`](https://github.com/nodejs/node/commit/f0d008439b)] - **doc**: add Rust toolchain manual installation instructions Windows (Mike McCready) [#63367](https://github.com/nodejs/node/pull/63367)
+* \[[`68b1220fbd`](https://github.com/nodejs/node/commit/68b1220fbd)] - **doc**: remove inactive members from Triagers list (Antoine du Hamel) [#63329](https://github.com/nodejs/node/pull/63329)
+* \[[`189d43a193`](https://github.com/nodejs/node/commit/189d43a193)] - **doc**: mark stream.compose stable (Matteo Collina) [#62562](https://github.com/nodejs/node/pull/62562)
+* \[[`c4fb894039`](https://github.com/nodejs/node/commit/c4fb894039)] - **doc**: fix CHANGELOG (Richard Lau) [#63292](https://github.com/nodejs/node/pull/63292)
+* \[[`9f319a77e4`](https://github.com/nodejs/node/commit/9f319a77e4)] - **doc**: reference correct function in Module docs (Robin Malfait) [#63247](https://github.com/nodejs/node/pull/63247)
+* \[[`2c13acc88e`](https://github.com/nodejs/node/commit/2c13acc88e)] - **doc**: replace Visual Studio 2022 Evergreen version reference with 17.14 (Mike McCready) [#63211](https://github.com/nodejs/node/pull/63211)
+* \[[`7e42c336c9`](https://github.com/nodejs/node/commit/7e42c336c9)] - **doc**: recommend explicitly Tier 1 or 2 for production applications (Mike McCready) [#63187](https://github.com/nodejs/node/pull/63187)
+* \[[`d99e0bb6d5`](https://github.com/nodejs/node/commit/d99e0bb6d5)] - **doc**: document Temporal configure flags in BUILDING.md (ChrisJr404) [#63248](https://github.com/nodejs/node/pull/63248)
+* \[[`c0ea77b305`](https://github.com/nodejs/node/commit/c0ea77b305)] - **doc**: run license-builder (github-actions\[bot]) [#63232](https://github.com/nodejs/node/pull/63232)
+* \[[`8265aba0f4`](https://github.com/nodejs/node/commit/8265aba0f4)] - **doc**: add large pull requests contributing guide (Matteo Collina) [#62829](https://github.com/nodejs/node/pull/62829)
+* \[[`be241bacc8`](https://github.com/nodejs/node/commit/be241bacc8)] - **doc**: remove unnecessary `<!-- eslint-` magic comments (Antoine du Hamel) [#63200](https://github.com/nodejs/node/pull/63200)
+* \[[`e0b1f092c3`](https://github.com/nodejs/node/commit/e0b1f092c3)] - **doc**: fix inconsistencies in CJS code snippets (Antoine du Hamel) [#63199](https://github.com/nodejs/node/pull/63199)
+* \[[`a3feb15871`](https://github.com/nodejs/node/commit/a3feb15871)] - **doc**: clarify SEA platform support excludes darwin-x64 (MJSHANG) [#63181](https://github.com/nodejs/node/pull/63181)
+* \[[`cafd7667fc`](https://github.com/nodejs/node/commit/cafd7667fc)] - **doc**: improve quic documentation (James M Snell) [#63157](https://github.com/nodejs/node/pull/63157)
+* \[[`3c784edb6f`](https://github.com/nodejs/node/commit/3c784edb6f)] - **doc**: update release steps when post-release fails (Rafael Gonzaga) [#63131](https://github.com/nodejs/node/pull/63131)
+* \[[`9de954e9be`](https://github.com/nodejs/node/commit/9de954e9be)] - **doc**: fix deprecation list in 26.0.0 changelog (Antoine du Hamel) [#63147](https://github.com/nodejs/node/pull/63147)
+* \[[`20c553e456`](https://github.com/nodejs/node/commit/20c553e456)] - **doc**: add Hmac.digest() documentation-only deprecation (DEP0206) (Anshika Jain) [#63121](https://github.com/nodejs/node/pull/63121)
+* \[[`3494eae2c8`](https://github.com/nodejs/node/commit/3494eae2c8)] - **doc**: document the latest-vX.x schema (Marco Ippolito) [#63033](https://github.com/nodejs/node/pull/63033)
+* \[[`c02413d29d`](https://github.com/nodejs/node/commit/c02413d29d)] - **doc**: remove list of versions in `BUILDING.md` (Antoine du Hamel) [#63113](https://github.com/nodejs/node/pull/63113)
+* \[[`53f9a902a1`](https://github.com/nodejs/node/commit/53f9a902a1)] - **doc,sqlite**: document entryPoint argument for loadExtension (Edy Silva) [#63152](https://github.com/nodejs/node/pull/63152)
+* \[[`f858c6140e`](https://github.com/nodejs/node/commit/f858c6140e)] - **(SEMVER-MINOR)** **fs**: add `Temporal.Instant` support to `Stats` and `BigIntStats` (Livia Medeiros) [#60789](https://github.com/nodejs/node/pull/60789)
+* \[[`b2ba62ca0e`](https://github.com/nodejs/node/commit/b2ba62ca0e)] - **fs**: make `Date` properties on `Stats` enumerable (LiviaMedeiros) [#63328](https://github.com/nodejs/node/pull/63328)
+* \[[`0cbb3895df`](https://github.com/nodejs/node/commit/0cbb3895df)] - **(SEMVER-MINOR)** **http**: add writeInformation to send arbitrary 1xx status codes (Tim Perry) [#63155](https://github.com/nodejs/node/pull/63155)
+* \[[`f712e6856e`](https://github.com/nodejs/node/commit/f712e6856e)] - **http2**: validate non-link headers in writeEarlyHints (Matteo Collina) [#62017](https://github.com/nodejs/node/pull/62017)
+* \[[`3acadae676`](https://github.com/nodejs/node/commit/3acadae676)] - **lib**: fix typo idenity => identity (Daijiro Wachi) [#63112](https://github.com/nodejs/node/pull/63112)
+* \[[`460329e886`](https://github.com/nodejs/node/commit/460329e886)] - **lib**: fixes validator message (Daijiro Wachi) [#62823](https://github.com/nodejs/node/pull/62823)
+* \[[`9438c832b2`](https://github.com/nodejs/node/commit/9438c832b2)] - **lib**: narrow ReadableStreamBYOBRequest.view return type to Uint8Array (RoomWithOutRoof) [#63017](https://github.com/nodejs/node/pull/63017)
+* \[[`c7d27c82c4`](https://github.com/nodejs/node/commit/c7d27c82c4)] - **lib**: handle --permission-audit when propagating flags (Rafael Gonzaga) [#63047](https://github.com/nodejs/node/pull/63047)
+* \[[`9f19915276`](https://github.com/nodejs/node/commit/9f19915276)] - **lib**: optimize webidl conversion options (Filip Skokan) [#62756](https://github.com/nodejs/node/pull/62756)
+* \[[`771afd626a`](https://github.com/nodejs/node/commit/771afd626a)] - **meta**: move one or more collaborators to emeritus (Node.js GitHub Bot) [#63402](https://github.com/nodejs/node/pull/63402)
+* \[[`67d094a554`](https://github.com/nodejs/node/commit/67d094a554)] - **meta**: move one or more collaborators to emeritus (Node.js GitHub Bot) [#63235](https://github.com/nodejs/node/pull/63235)
+* \[[`9091398f3d`](https://github.com/nodejs/node/commit/9091398f3d)] - **meta**: ignore AI assistants files (Matteo Collina) [#62612](https://github.com/nodejs/node/pull/62612)
+* \[[`96f19a16d0`](https://github.com/nodejs/node/commit/96f19a16d0)] - **module**: fix sync hook short-circuit in require() in imported CJS (Joyee Cheung) [#62920](https://github.com/nodejs/node/pull/62920)
+* \[[`45f3e3ef11`](https://github.com/nodejs/node/commit/45f3e3ef11)] - **node-api**: support SharedArrayBuffer in napi\_create\_typedarray (Yilong Li) [#62710](https://github.com/nodejs/node/pull/62710)
+* \[[`d7afa617bb`](https://github.com/nodejs/node/commit/d7afa617bb)] - **quic**: send correct OpenSSL alert for ALPN mismatches (Tim Perry) [#63193](https://github.com/nodejs/node/pull/63193)
+* \[[`526313beb8`](https://github.com/nodejs/node/commit/526313beb8)] - **quic**: fixup quic stream variable chunk len (James M Snell) [#63230](https://github.com/nodejs/node/pull/63230)
+* \[[`1613c7fe70`](https://github.com/nodejs/node/commit/1613c7fe70)] - **quic**: support --allow-net permissions (James M Snell) [#63184](https://github.com/nodejs/node/pull/63184)
+* \[[`72ab7444a8`](https://github.com/nodejs/node/commit/72ab7444a8)] - **quic**: remove unused env\_ variable in session\_manager.h/cc (James M Snell) [#63177](https://github.com/nodejs/node/pull/63177)
+* \[[`2b55656778`](https://github.com/nodejs/node/commit/2b55656778)] - **quic**: remove unused binding variable in session.cc (James M Snell) [#63177](https://github.com/nodejs/node/pull/63177)
+* \[[`83f0d37400`](https://github.com/nodejs/node/commit/83f0d37400)] - **quic**: ignore coverage for quic files (James M Snell) [#63149](https://github.com/nodejs/node/pull/63149)
+* \[[`7e6b77b14d`](https://github.com/nodejs/node/commit/7e6b77b14d)] - **quic**: complete the internal implementation of QUIC (James M Snell) [#62876](https://github.com/nodejs/node/pull/62876)
+* \[[`71372418f1`](https://github.com/nodejs/node/commit/71372418f1)] - **repl**: fix dedup comparing normalized line against raw history (Daijiro Wachi) [#62886](https://github.com/nodejs/node/pull/62886)
+* \[[`20f40c2c25`](https://github.com/nodejs/node/commit/20f40c2c25)] - **sqlite**: keep source database alive during backup (Matteo Collina) [#62673](https://github.com/nodejs/node/pull/62673)
+* \[[`592f741bd0`](https://github.com/nodejs/node/commit/592f741bd0)] - **src**: simplify OpenSSL feature gates (Filip Skokan) [#63255](https://github.com/nodejs/node/pull/63255)
+* \[[`520ab7ad40`](https://github.com/nodejs/node/commit/520ab7ad40)] - **src**: add BoringSSL EVP enumeration fallback (Filip Skokan) [#63206](https://github.com/nodejs/node/pull/63206)
+* \[[`12be49acbc`](https://github.com/nodejs/node/commit/12be49acbc)] - **src**: support multiple versions in node.config.json (Marco Ippolito) [#63033](https://github.com/nodejs/node/pull/63033)
+* \[[`296f907585`](https://github.com/nodejs/node/commit/296f907585)] - **src**: remove unused using declarations in node\_task\_queue (Mert Can Altin) [#63144](https://github.com/nodejs/node/pull/63144)
+* \[[`7703f11b3c`](https://github.com/nodejs/node/commit/7703f11b3c)] - **src**: skip JS callback for settled Promise.race losers (Felipe Coelho) [#62336](https://github.com/nodejs/node/pull/62336)
+* \[[`74ab710c3a`](https://github.com/nodejs/node/commit/74ab710c3a)] - **src,sqlite**: remove dead code (Edy Silva) [#63204](https://github.com/nodejs/node/pull/63204)
+* \[[`e49154f4c8`](https://github.com/nodejs/node/commit/e49154f4c8)] - **stream**: add sync iterable fast path to pipeTo (Trivikram Kamat) [#63318](https://github.com/nodejs/node/pull/63318)
+* \[[`537455e98d`](https://github.com/nodejs/node/commit/537455e98d)] - **stream**: fix merge handling for object-like sources (Trivikram Kamat) [#63356](https://github.com/nodejs/node/pull/63356)
+* \[[`e21b8a47f0`](https://github.com/nodejs/node/commit/e21b8a47f0)] - **stream**: limit iter from sync iterable batches (Trivikram Kamat) [#63324](https://github.com/nodejs/node/pull/63324)
+* \[[`3bdb64dc67`](https://github.com/nodejs/node/commit/3bdb64dc67)] - **stream**: cache minimum cursor count in broadcast (Trivikram Kamat) [#63322](https://github.com/nodejs/node/pull/63322)
+* \[[`81819add6b`](https://github.com/nodejs/node/commit/81819add6b)] - **stream**: remove unnecessary check (Antoine du Hamel) [#63030](https://github.com/nodejs/node/pull/63030)
+* \[[`22e3579d74`](https://github.com/nodejs/node/commit/22e3579d74)] - **stream**: avoid retrying accepted pipeTo writes (Trivikram Kamat) [#63297](https://github.com/nodejs/node/pull/63297)
+* \[[`691915ea94`](https://github.com/nodejs/node/commit/691915ea94)] - **stream**: validate broadcast writer writev chunks (Trivikram Kamat) [#63300](https://github.com/nodejs/node/pull/63300)
+* \[[`253f5f4ca2`](https://github.com/nodejs/node/commit/253f5f4ca2)] - **stream**: uncork fromWritable writev on chunk error (Trivikram Kamat) [#63295](https://github.com/nodejs/node/pull/63295)
+* \[[`aa6913cc4a`](https://github.com/nodejs/node/commit/aa6913cc4a)] - **stream**: validate fromWritable() options before cache (Trivikram Kamat) [#63278](https://github.com/nodejs/node/pull/63278)
+* \[[`6c53ddb988`](https://github.com/nodejs/node/commit/6c53ddb988)] - **stream**: optimize single-slot push queue drain (Trivikram Kamat) [#63274](https://github.com/nodejs/node/pull/63274)
+* \[[`b568649f6f`](https://github.com/nodejs/node/commit/b568649f6f)] - **stream**: preserve toReadableSync batch after backpressure (Trivikram Kamat) [#63276](https://github.com/nodejs/node/pull/63276)
+* \[[`cdcefd7e2f`](https://github.com/nodejs/node/commit/cdcefd7e2f)] - **stream**: cache minimum cursor count in share (Trivikram Kamat) [#63262](https://github.com/nodejs/node/pull/63262)
+* \[[`ba7000e4f7`](https://github.com/nodejs/node/commit/ba7000e4f7)] - **stream**: minor stream/iter implementation edits (René) [#63132](https://github.com/nodejs/node/pull/63132)
+* \[[`c694999ab8`](https://github.com/nodejs/node/commit/c694999ab8)] - **test**: disable Maglev in near-heap-limit worker test (Trivikram Kamat) [#63398](https://github.com/nodejs/node/pull/63398)
+* \[[`a6d6d51c1b`](https://github.com/nodejs/node/commit/a6d6d51c1b)] - **test**: deflake connection refused proxy tests (Trivikram Kamat) [#63395](https://github.com/nodejs/node/pull/63395)
+* \[[`31d89c4f59`](https://github.com/nodejs/node/commit/31d89c4f59)] - **test**: avoid repeated writes in watch helper (Trivikram Kamat) [#63386](https://github.com/nodejs/node/pull/63386)
+* \[[`6f3587c773`](https://github.com/nodejs/node/commit/6f3587c773)] - **test**: deflake watch mode worker test (Trivikram Kamat) [#63384](https://github.com/nodejs/node/pull/63384)
+* \[[`a57aebaa73`](https://github.com/nodejs/node/commit/a57aebaa73)] - **test**: update tls/crypto behaviour expectations when using BoringSSL (Filip Skokan) [#63161](https://github.com/nodejs/node/pull/63161)
+* \[[`b871cff2db`](https://github.com/nodejs/node/commit/b871cff2db)] - **test**: relax test-memory-usage arrayBuffers check (inoway46) [#63244](https://github.com/nodejs/node/pull/63244)
+* \[[`25189bcb95`](https://github.com/nodejs/node/commit/25189bcb95)] - **test**: reduce flakiness of `different-registry-per-thread` (Antoine du Hamel) [#63244](https://github.com/nodejs/node/pull/63244)
+* \[[`5bdb1f8426`](https://github.com/nodejs/node/commit/5bdb1f8426)] - **test**: fix flaky test-watch-mode-inspect timeout (Matteo Collina) [#63361](https://github.com/nodejs/node/pull/63361)
+* \[[`d57bd2bf59`](https://github.com/nodejs/node/commit/d57bd2bf59)] - **test**: relax min assertion in test-performance-eventloopdelay (Marco) [#63100](https://github.com/nodejs/node/pull/63100)
+* \[[`014e1f00c1`](https://github.com/nodejs/node/commit/014e1f00c1)] - **test**: avoid flaky restart sync in debugger exceptions test (Yuya Inoue) [#62055](https://github.com/nodejs/node/pull/62055)
+* \[[`dd28ff8a80`](https://github.com/nodejs/node/commit/dd28ff8a80)] - **test**: avoid initial-break wait in restart-message (inoway46) [#62060](https://github.com/nodejs/node/pull/62060)
+* \[[`e89a49a13a`](https://github.com/nodejs/node/commit/e89a49a13a)] - **test**: move FFI tests to `NATIVE_SUITES` (Antoine du Hamel) [#63165](https://github.com/nodejs/node/pull/63165)
+* \[[`51ef0258ba`](https://github.com/nodejs/node/commit/51ef0258ba)] - **test**: update WPT for wasm/jsapi to 288c467d35 (Node.js GitHub Bot) [#63136](https://github.com/nodejs/node/pull/63136)
+* \[[`c0175a9ba1`](https://github.com/nodejs/node/commit/c0175a9ba1)] - **test**: use ERM to destroy sqlite database handles after tests (René) [#63076](https://github.com/nodejs/node/pull/63076)
+* \[[`83054e8aba`](https://github.com/nodejs/node/commit/83054e8aba)] - **test\_runner**: avoid hanging on incomplete v8 frames (Ali Hassan) [#62704](https://github.com/nodejs/node/pull/62704)
+* \[[`4f1426d361`](https://github.com/nodejs/node/commit/4f1426d361)] - **test\_runner**: fix hooks test context (Moshe Atlow) [#63285](https://github.com/nodejs/node/pull/63285)
+* \[[`6a4c4b7193`](https://github.com/nodejs/node/commit/6a4c4b7193)] - **test\_runner**: fix diagnostics channel context tracking (Moshe Atlow) [#63283](https://github.com/nodejs/node/pull/63283)
+* \[[`eba9c3481b`](https://github.com/nodejs/node/commit/eba9c3481b)] - **test\_runner**: add tags option and tag-name filter (Chemi Atlow) [#63221](https://github.com/nodejs/node/pull/63221)
+* \[[`2ba124f23b`](https://github.com/nodejs/node/commit/2ba124f23b)] - **tls**: add unsupported renegotiation error (Filip Skokan) [#63161](https://github.com/nodejs/node/pull/63161)
+* \[[`7c5048495a`](https://github.com/nodejs/node/commit/7c5048495a)] - **tools**: bump the eslint group in /tools/eslint with 4 updates (dependabot\[bot]) [#63075](https://github.com/nodejs/node/pull/63075)
+* \[[`6c574110a7`](https://github.com/nodejs/node/commit/6c574110a7)] - **tools**: update gyp-next to 0.22.2 (Node.js GitHub Bot) [#63374](https://github.com/nodejs/node/pull/63374)
+* \[[`f14ed762b3`](https://github.com/nodejs/node/commit/f14ed762b3)] - **tools**: add boringssl to tools/nix/openssl-matrix.nix (Filip Skokan) [#63206](https://github.com/nodejs/node/pull/63206)
+* \[[`14d3924c48`](https://github.com/nodejs/node/commit/14d3924c48)] - **tools**: fix test426 updater (Antoine du Hamel) [#63271](https://github.com/nodejs/node/pull/63271)
+* \[[`0d017ece8d`](https://github.com/nodejs/node/commit/0d017ece8d)] - **tools**: filter V8 scripts for build toolchain (Richard Lau) [#63069](https://github.com/nodejs/node/pull/63069)
+* \[[`3859a8700e`](https://github.com/nodejs/node/commit/3859a8700e)] - **tools**: use different branch for tool updates on staging branches (Antoine du Hamel) [#63110](https://github.com/nodejs/node/pull/63110)
+* \[[`4a32ed82bd`](https://github.com/nodejs/node/commit/4a32ed82bd)] - **tools**: prevent lib code from reading KeyObject and CryptoKey accessors (Filip Skokan) [#63111](https://github.com/nodejs/node/pull/63111)
+
 <a id="26.1.0"></a>
 
 ## 2026-05-07, Version 26.1.0 (Current), @aduh95

From b5659d14abdf78e8766de617477e2b027c0aa93f Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Wed, 20 May 2026 16:21:23 -0400
Subject: [PATCH 30/83] test: update WPT for WebCryptoAPI to 97bbc7247a

PR-URL: https://github.com/nodejs/node/pull/63417
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/fixtures/wpt/README.md                   |  2 +-
 .../import_export/ML-KEM_importKey.js         | 10 ++--
 .../ML-KEM_importKey_fixtures.js              | 18 ++++++
 .../serialization/aes-cbc.https.any.js        | 11 ++++
 .../serialization/aes-ctr.https.any.js        | 11 ++++
 .../serialization/aes-gcm.https.any.js        | 11 ++++
 .../serialization/aes-kw.https.any.js         | 11 ++++
 .../aes-ocb.tentative.https.any.js            | 11 ++++
 .../chacha20-poly1305.tentative.https.any.js  | 11 ++++
 .../serialization/ecdh.https.any.js           | 12 ++++
 .../serialization/ecdsa.https.any.js          | 12 ++++
 .../serialization/ed25519.https.any.js        | 12 ++++
 .../ed448.tentative.https.any.js              | 12 ++++
 .../serialization/hmac.https.any.js           | 11 ++++
 .../serialization/kmac.tentative.https.any.js | 17 ++++++
 .../mldsa.tentative.https.any.js              | 27 +++++++++
 .../mlkem.tentative.https.any.js              | 32 +++++++++++
 .../serialization/rsa-oaep.https.any.js       | 12 ++++
 .../serialization/rsa-pss.https.any.js        | 12 ++++
 .../rsassa-pkcs1-v1_5.https.any.js            | 12 ++++
 .../serialization/serialization.js            | 55 +++++++++++++++++++
 .../serialization/x25519.https.any.js         | 12 ++++
 .../serialization/x448.tentative.https.any.js | 12 ++++
 test/fixtures/wpt/versions.json               |  2 +-
 test/wpt/status/WebCryptoAPI.cjs              |  7 +++
 25 files changed, 348 insertions(+), 7 deletions(-)
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/aes-cbc.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/aes-ctr.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/aes-gcm.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/aes-kw.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/ecdh.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/ecdsa.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/ed25519.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/hmac.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/rsa-oaep.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/rsa-pss.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/rsassa-pkcs1-v1_5.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/serialization.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/x25519.https.any.js
 create mode 100644 test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js

diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index c98284f664a0af..10cedb4149edde 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -34,7 +34,7 @@ Last update:
 - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/288c467d35/wasm/jsapi
 - wasm/webapi: https://github.com/web-platform-tests/wpt/tree/fd1b23eeaa/wasm/webapi
 - web-locks: https://github.com/web-platform-tests/wpt/tree/10a122a6bc/web-locks
-- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/8b5cd267b4/WebCryptoAPI
+- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/97bbc7247a/WebCryptoAPI
 - webidl: https://github.com/web-platform-tests/wpt/tree/63ca529a02/webidl
 - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/2f96fa1996/webidl/ecmascript-binding/es-exceptions
 - webmessaging/broadcastchannel: https://github.com/web-platform-tests/wpt/tree/6495c91853/webmessaging/broadcastchannel
diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.js b/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.js
index ad2f75048556e4..d9257ac6982505 100644
--- a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.js
+++ b/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey.js
@@ -3,14 +3,14 @@ var subtle = crypto.subtle;
 function runTests(algorithmName) {
   var algorithm = { name: algorithmName };
   var data = keyData[algorithmName];
-  // var jwkData = {jwk: {kty: data.jwk.kty, alg: data.jwk.alg, pub: data.jwk.pub}};
-
-  // TODO: add JWK when its definition is done in IETF JOSE WG
+  var jwkData = {
+    jwk: { kty: data.jwk.kty, alg: data.jwk.alg, pub: data.jwk.pub },
+  };
 
   [true, false].forEach(function (extractable) {
     // Test public keys first
     allValidUsages(data.publicUsages, true).forEach(function (usages) {
-      ['spki', /*'jwk',*/ 'raw-public'].forEach(function (format) {
+      ['spki', 'jwk', 'raw-public'].forEach(function (format) {
         if (format === 'jwk') {
           // Not all fields used for public keys
           testFormat(
@@ -36,7 +36,7 @@ function runTests(algorithmName) {
 
     // Next, test private keys
     allValidUsages(data.privateUsages).forEach(function (usages) {
-      ['pkcs8', /*'jwk',*/ 'raw-seed'].forEach(function (format) {
+      ['pkcs8', 'jwk', 'raw-seed'].forEach(function (format) {
         testFormat(format, algorithm, data, algorithmName, usages, extractable);
       });
     });
diff --git a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js b/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js
index 1c25d37614e92e..f3a5f6687dc5e1 100644
--- a/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js
+++ b/test/fixtures/wpt/WebCryptoAPI/import_export/ML-KEM_importKey_fixtures.js
@@ -23,6 +23,12 @@ var keyData = {
       80, 130, 235, 161, 49, 141, 160, 11, 40, 152, 18, 142, 30, 56, 252, 129,
       211,
     ]),
+    jwk: {
+      priv: 'pSbBpIR6aK1T1uMf57eY5GCMQRdTgwjN9cB64vRehm12PK3LGUu9kBYlozVOlblQguuhMY2gCyiYEo4eOPyB0w',
+      kty: 'AKP',
+      alg: 'ML-KEM-512',
+      pub: 'NmgRwWK5Bbwb-FQJRnK_kDCVThmIH7wdYMRUaaUaIFQoZJQK5bJh0zEtyFpBboqtcZLG7tibd5wJQpNDnnkvmHZjC3QZl2iOLolHnjQPe7FuOPGP_EqSF0kziAZ7cHQ2UPgJVcVhQWYsqhdjAkEsTqyrUvOlclGMjxSOdNF0e9qVxWZRjvFzTudlmfKGdPsO9gmnKRYsHqbDm4mdVJOlRhpeZIUUwPRF3KrIUBul5CpUPVuUdPrM1Ola15ISYJU_mDI0ECKpElWtiAmRcOWxoiGd3tGWwPyorGqmJCabuEI7ZaqjIQoygXlWanvIxEVI75d2aroa4ZM1dgMJAiWM_Pcet7EEieafA7pdP1EQ6utJs9oYDXsngBZaOXiqc_hnm3KzKQUZIkiPA9BQgxN53RMG51ZC2HVHwoC7iaVQsDi4u9iFRZCplXWPZXQMcSpH_sBy4cEVDgW-AZweDpIW9rICT9xOHwwwmvWtNMmXmDZ0-vNN14kHGdBOP4N0-YIj1nwdkwIHskKfAnlDVcrA0Rx-EFixxcQiXDq-xeBc-gY6UdR6LDQeifp7BRwqTicqBYOCdYHJpIN2pweK70puM3Iy_kHIPhIazCBnJvOKl3YlYRsPR8BU12W3LJS4kOUfvXiNqIKrqXxFv7BxURULIfvN7myEBrc9OpivU_IfiOOy-5jA8RRxLGsWnppqQdINFuqvYtEn31obk2CVnESA7hnOERuM7EOdU-M8MsN0QSlmZJxAN3VavFBl6uOq8FJJvfydUvEWc3vPrnB2g_KmXuwtprObdlO9_1JWp2UnenFpOClD7QnMKtaiBmWOGZZV6dmIWrtY9_RZ01Gn_LORv8JoWQhAb2tMrRVtF9M1Jjx0jIO5jlSx9MgVzYte18YCMTCPY-J5Zuo3Q6o-LdLInnUq6cVugdQMjhJ_8SuXmsBYIHXN9FMKttWI6YKcLVYjHstsXiEP0kOx4fd4kZaKH-S3vCIl9CA5BiUXjxK108ooEpY9lTxH_yGCQRnEkve0HwWwHfvagpKsDDWzRIh4xAHRsY9_xcPO-JlXbUZ6_HA',
+    },
   },
   'ML-KEM-768': {
     privateUsages: ['decapsulateBits', 'decapsulateKey'],
@@ -47,6 +53,12 @@ var keyData = {
       201, 9, 240, 170, 192, 86, 52, 228, 122, 16, 73, 139, 30, 11, 224, 117,
       143, 2, 124, 21, 63, 91, 210, 94, 160, 123, 99, 189, 172, 61, 235, 191,
     ]),
+    jwk: {
+      priv: 'psgdZMYwUKSP1wJsaqLna2-PAg63_ZwRW9VLyHBZ8zfJCfCqwFY05HoQSYseC-B1jwJ8FT9b0l6ge2O9rD3rvw',
+      kty: 'AKP',
+      alg: 'ML-KEM-768',
+      pub: '7lhoaxGSnpU0O6dvndAgrKiCDLwlHeMBR4ZatDw5lYwtPCIEI9CbmfqjX7kTAcoJsEKh-oityrERRVegtAmShCZFdzGGVjRh3Yh594KhKZfGPYyUnTq8eBETGfl0Gldu8BBimWuzEGhghoOHYPa0ygEfUQZhU8qZ8nA6TbiuNSdPJ8xdfxtgiEiCe3Z9SqhF3aerJoyuc2uAKbGPafrCd7rDsitzFPI1TVYaKWC1OblyKVu8PhWtEdx8VYRftaUJBwfKEnQSNvWLZTVEbTqgJQNwHLmQyMSktnjNKDmrF2C-TkKFOrenC4QAEGQvcrAuidpcuPNl8FVMDKUsIRY5aiQvEsdRxJcWZGJ6hUVzzseVrgBM0NFrIDkpe5Wga-hSZggbACIvWzISJgNkznp7oJM36FxeVbkHDXTNaLQ-PHR7pTwrpzUCmiecewGZ5ZIE6ooPaMC84vdxlqB-WKQV2gs_t1mO20NnZcCyqPkGNNtueOkGZlJORvhYBbqEhdKdtLF4b-oo-CBrHgAKRGVaAGoFEleSCJFusCsX_ajBKQkvNSdJXDJC82QGXbnKL1sK9QLOzTYV_xgZWMW3tRFYMMWSz5w000irtFDNcmJcUbkn0BGg-vdzceY46eOeg3JE2rh-9fVLzhZMq6UG8YyhBZMonEx-JalyninCurYWk1aEVic0n7cQ1MMPvnJyKolXubWNKFGiB7K1H2mG5TafRrJvCQlXfSoncaLHr9SGr2UQvyvGNMTGYcFIxnCp3lyU42a157x3OwINDcA39OLD0hJ7JhdeVGkeIQp9VRt1vaOUEEPFVXuXIPtBqMu-9gOfL3hNh2aixMCP6VS6gypYfYNNCTZ9O7pJ81sFfEJv4-yR5zBZ0IYi4saeeoUJQgmohBcm9IaUDoWAlVhbxKoV1SQ22juWvXas5flgyzVh-GV7bpVoH-SawqlAEnxE-vWWVXLMRXYuh_CByxYvFPVCYeS4GuKF9kpT7rWQ6gM-T-gV5zS62EQ7qrxZL7DOjkqXnqeaD7pMxWRKt4QFdYupnNgfI1wt8Mxjn_CzKOOBHZIdKooppSI2BOpmvyu1zcDJX1snbBNcLVtMdbBYJXOf1RXIEXWCAOKf1jNGLRyOazhlbOpmtBxRsqO5-Lq9odptmUO3FtQ23VqQ0nhFHeFO8yMpOAp2H3widhpFQbKbYKKrtfjGL_kXwxqlh4k1nAmCXzvKe7wzlyow1NgEx_e6MRkc_PIsekgytkAhsPSYc0t_AuEy5xyqN_m_JMbLJCwaFVtoPVoKPNRzFtM1YrNSrtAOg0MLMna5eJN9CotPh0MywwxzKfyvFnEr-FKMr9UgOExqrZWY1gFeDot5S9rJhErLrZWAI8cn2tUuOGMg1LozqOxJIOyHsAERJ4W7jJQ5dWosbzdsiSeXAauX4fB_VWbAxmxNhreT1mJAF5Owx1OLJGYTFsmKqSI4HsGvlVpwQcClh8ZIBmWiLwUstOO401BGBsh2lbyWUmRGQCgSymgMP6IuQ7hAnWAp7CyO92VWNfXMV3ynevpq4a8MzDsgXnFisMWx_7w1vsdnSvNfo8E',
+    },
   },
   'ML-KEM-1024': {
     privateUsages: ['decapsulateBits', 'decapsulateKey'],
@@ -72,5 +84,11 @@ var keyData = {
       251, 65, 39, 3, 101, 145, 174, 21, 195, 144, 234, 14, 158, 32, 49, 57,
       142, 113,
     ]),
+    jwk: {
+      priv: 'mHWy5rWG9IGnfaYItV_O0ohw230GdnpTJvQ5zTJiOy7oQhGRzPyiuXR08hyEwftBJwNlka4Vw5DqDp4gMTmOcQ',
+      kty: 'AKP',
+      alg: 'ML-KEM-1024',
+      pub: 'IUe4I2Yu3_Ix1zZYFhRrTaBXm9KI8sZbdfbBXtsk8yV5ZBa0HYip0qHDrSEniEVDDngDv9Nhibg-OKdEgFy2NEaVa4WbHQxsVrUO11sV5LZ3H4Ww7CNG_3Ye-4h-vRw0B8eYJSLFGouhMRs8Q4q0ZhVp1wI8fIOoM-cXxypf6Kw_hLZD2TCkA3dN8hxk_tC5o5aZ8bFw7UyFJhgjmcEvzaYV6VqzokdodPty1jWOmguRXmydfvE1RjUHodUFOIhSzwuH3BgYlVk2Xcp3IPyyjnSNLBwLKEg4LlANCUvENPY6EJNgp-toE9wqk9ao_0t5HPpaqDAU0frBe9MhAHuvH3DHWlukxSRy7rmqC2tra9XCbTxp9_QRrCEs8Aa956fFmjN_z_EAGEdS7QqIxfi414ECFAWcTpGmC4y-VHSUC3UUGjJW1eNHzLOrk6g0dgqNFwF2h9h56NKddiQ3S2JUSTmAaiQj5FKmswNW61Ie24Yo4qcQOGKg9ioKGPmPyZDJ5Xwgchh6vsqu7-cOWZiRd8xAjvCrf6oiDXEjs7i8faEZqJAkVmqbfqyy4CW5astIffZYnBxsckuqHylk6VyrE8GalasJ65aY2ft0femcNJh5xSTBsmTHJtyj2hU1FcyNndgrLbdpcQobXdmyX0i3nsN6HXwKv_iAV6B6jCaTJVgLINwr0PW9XHaKLXKSw9QgmGc47qzCjiiEBZVrzxKz0ohDzlcGCvRapgDGakg1nBW54eRbuJi7kRynkSAaK2FKkuJ60Exw5PgGpBRRrFGI_KVbKMw7GkvOP6c3F0obH0iuk1TOsim92KJIixrOK2KECCrMODGAtDOVlxQxhDG57UGAp2KeGIwzhknHMCO081UV4Iy9dPctfVs6DlUwjHiMb9c5deJX7vwSVHxXqSUL52N-QNpBMXEX3TlsHafGewhSQhk3SfRNVxLAqqpWxyRxAKMKKsBEFDi1LsQGlQdF_RwjtNHMBOwJEeSy3lSAiLmInLVQ9-xUYXWZJmyY8jCwU4OUrSg3v0ge0cAtglA3UwAX5DU4i2AOT8YPkuR3DseMsirFEEOc2pI7tCpy4YxdRyqY9XWRNYTCI2UAtAdIKaaslRMEhnZpI8VYBqUehNCvkPIY8GxuA_o3XlopD8g8gBlqqqqxqYNdrQVLiWjCZyajXOBwL8uWiMOSQWcmHztxlRJ3TjqDZSYlZ2RZzBWGy7O1bXsSPAcu64EyWPFYgWEHAwGUAOodl5F95acdk0C1ogE3aBSz-SGqWddCZUUE1YlZ8etr-Dt8_9y4IUaixqxDZcZcU0ZiaDBNiKQWkIl3yIvKF3YwUdgXeyBg3jkUDDyTE2vLFYtzH-Vl6aOBNJTHaKESEUFyo4FW6qkwU5bNuXJed6ygiLZES6MKXGkHZzxt0xN_-1GWMcwa5Rxfq7V6KSh64sWSmEyXtXBnhesfUuMXfMFXFNzCanuIhIdabku6uPutNSOuRgW-5aajfVV_Bbtgx9eibpZHfYw42eqcJUdtsZEYgRUkzVgYxtFn6WyhQqhDeXGry4lUJrMGUWmmr5yGvbW8u1GFS7LITjODYvms1kKtRpEdNCIJICwlyQwhn_eVsYc-OWMG71iNeqELTgRj1olWgJpXenFMe0K8ctyMnSNY6LQOd-tTtUx8cQnKmxA5ThtrhYtS8JS0iDmUUcikf8aJxxZs7hh9HQp9jttI4PsBo8dKdMRHJQLEW1cY8nGG21C1nRzKKeet8hNA2va3T-xznbdzkEJ1FNae1fMWhZUO1pRAGUfB_ARPnAeNRRFn-XmLCwtKtRy_GrpHsmhlVZdvioJVZGoB9JusQamo7PhciUmTbpx69rc55nF7EKjOyHFaH3O5GCmulSLJK0fKpTG2d0KWlKDK13IK4PMvVpd0kegv-VSyF3as7QwEuVQrdJJOHZi5MZMsF4vISwgGdcN5JBdFdCXAvgmOqlpR0Li6HCUoD0GXs7KPZwCADLk1lynACrq_HodeXadFvpORW0ok07UF58Swb-SbdatO2dQjfwWB0dC2a9JINjSS6WGfrIKrOriqP-5wjVKdo5w1493fQtp3aXqOEio',
+    },
   },
 };
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-cbc.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-cbc.https.any.js
new file mode 100644
index 00000000000000..840566639cd799
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-cbc.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'AES-CBC',
+    resultType: 'CryptoKey',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    exportFormat: 'raw'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ctr.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ctr.https.any.js
new file mode 100644
index 00000000000000..3b3fb6822043f3
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ctr.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'AES-CTR',
+    resultType: 'CryptoKey',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    exportFormat: 'raw'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-gcm.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-gcm.https.any.js
new file mode 100644
index 00000000000000..b54eba677b965b
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-gcm.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'AES-GCM',
+    resultType: 'CryptoKey',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    exportFormat: 'raw'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-kw.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-kw.https.any.js
new file mode 100644
index 00000000000000..9948dce9b395e7
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-kw.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'AES-KW',
+    resultType: 'CryptoKey',
+    usages: ['wrapKey', 'unwrapKey'],
+    exportFormat: 'raw'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js
new file mode 100644
index 00000000000000..33b814410c3ff4
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/aes-ocb.tentative.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'AES-OCB',
+    resultType: 'CryptoKey',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    exportFormat: 'raw-secret'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js
new file mode 100644
index 00000000000000..aaaa24a0b662bc
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/chacha20-poly1305.tentative.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'ChaCha20-Poly1305',
+    resultType: 'CryptoKey',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    exportFormat: 'raw-secret'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/ecdh.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/ecdh.https.any.js
new file mode 100644
index 00000000000000..17df8a87ba6ffb
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/ecdh.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'ECDH',
+    resultType: 'CryptoKeyPair',
+    usages: ['deriveKey', 'deriveBits'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/ecdsa.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/ecdsa.https.any.js
new file mode 100644
index 00000000000000..679dc066f53193
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/ecdsa.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'ECDSA',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/ed25519.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/ed25519.https.any.js
new file mode 100644
index 00000000000000..831e91725b6bae
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/ed25519.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'Ed25519',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js
new file mode 100644
index 00000000000000..4abe56285689b8
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/ed448.tentative.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'Ed448',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/hmac.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/hmac.https.any.js
new file mode 100644
index 00000000000000..99efea6bcaa996
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/hmac.https.any.js
@@ -0,0 +1,11 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'HMAC',
+    resultType: 'CryptoKey',
+    usages: ['sign', 'verify'],
+    exportFormat: 'raw'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js
new file mode 100644
index 00000000000000..645d16bec776fb
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/kmac.tentative.https.any.js
@@ -0,0 +1,17 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'KMAC128',
+    resultType: 'CryptoKey',
+    usages: ['sign', 'verify'],
+    exportFormat: 'raw-secret'
+  },
+  {
+    name: 'KMAC256',
+    resultType: 'CryptoKey',
+    usages: ['sign', 'verify'],
+    exportFormat: 'raw-secret'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js
new file mode 100644
index 00000000000000..3f61248b3d9e49
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/mldsa.tentative.https.any.js
@@ -0,0 +1,27 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+
+run_test([
+  {
+    name: 'ML-DSA-44',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+  {
+    name: 'ML-DSA-65',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+  {
+    name: 'ML-DSA-87',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js
new file mode 100644
index 00000000000000..62a210f0cda218
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/mlkem.tentative.https.any.js
@@ -0,0 +1,32 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'ML-KEM-512',
+    resultType: 'CryptoKeyPair',
+    usages: [
+      'decapsulateBits', 'decapsulateKey', 'encapsulateBits', 'encapsulateKey'
+    ],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+  {
+    name: 'ML-KEM-768',
+    resultType: 'CryptoKeyPair',
+    usages: [
+      'decapsulateBits', 'decapsulateKey', 'encapsulateBits', 'encapsulateKey'
+    ],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+  {
+    name: 'ML-KEM-1024',
+    resultType: 'CryptoKeyPair',
+    usages: [
+      'decapsulateBits', 'decapsulateKey', 'encapsulateBits', 'encapsulateKey'
+    ],
+    publicFormat: 'raw-public',
+    privateFormat: 'raw-seed'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-oaep.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-oaep.https.any.js
new file mode 100644
index 00000000000000..42469307155d50
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-oaep.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'RSA-OAEP',
+    resultType: 'CryptoKeyPair',
+    usages: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'],
+    publicFormat: 'spki',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-pss.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-pss.https.any.js
new file mode 100644
index 00000000000000..a1255b7638bc37
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/rsa-pss.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'RSA-PSS',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'spki',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/rsassa-pkcs1-v1_5.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/rsassa-pkcs1-v1_5.https.any.js
new file mode 100644
index 00000000000000..051eb87e07856e
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/rsassa-pkcs1-v1_5.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'RSASSA-PKCS1-v1_5',
+    resultType: 'CryptoKeyPair',
+    usages: ['sign', 'verify'],
+    publicFormat: 'spki',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/serialization.js b/test/fixtures/wpt/WebCryptoAPI/serialization/serialization.js
new file mode 100644
index 00000000000000..a9444032503268
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/serialization.js
@@ -0,0 +1,55 @@
+function run_test(vectors) {
+  function testCryptoKeySerialization(
+      generateKeyAlgorithm, generateKeyUsages, exportFormat) {
+    promise_test(async t => {
+      var cryptoKey = await crypto.subtle.generateKey(
+          generateKeyAlgorithm, true, generateKeyUsages);
+      const keyExported =
+          await crypto.subtle.exportKey(exportFormat, cryptoKey);
+
+      const {key} = structuredClone({key: cryptoKey});
+      const newKeyExported =
+          await crypto.subtle.exportKey(exportFormat, key);
+      assert_true(equalBuffers(keyExported, newKeyExported));
+    }, 'serialization test ' + objectToString(generateKeyAlgorithm));
+  };
+
+  function testCryptoKeyPairSerialization(
+      generateKeyAlgorithm, generateKeyUsages, publicExportFormat,
+      privateExportFormat) {
+    promise_test(async t => {
+      var keyPair = await crypto.subtle.generateKey(
+          generateKeyAlgorithm, true, generateKeyUsages);
+      const publicKeyExported =
+          await crypto.subtle.exportKey(publicExportFormat, keyPair.publicKey);
+      const privateKeyExported = await crypto.subtle.exportKey(
+          privateExportFormat, keyPair.privateKey);
+
+      const {publicKey, privateKey} = structuredClone(
+          {publicKey: keyPair.publicKey, privateKey: keyPair.privateKey});
+      const newPublicKeyExported =
+          await crypto.subtle.exportKey(publicExportFormat, publicKey);
+      assert_true(equalBuffers(publicKeyExported, newPublicKeyExported));
+      const newPrivateKeyExported = await crypto.subtle.exportKey(
+          privateExportFormat, privateKey);
+      assert_true(equalBuffers(privateKeyExported, newPrivateKeyExported));
+    }, 'serialization test ' + objectToString(generateKeyAlgorithm));
+  };
+
+  vectors.forEach(function(vector) {
+    if (vector.resultType === 'CryptoKey') {
+      allAlgorithmSpecifiersFor(vector.name)
+          .forEach(function(generateKeyAlgorithm) {
+            testCryptoKeySerialization(
+                generateKeyAlgorithm, vector.usages, vector.exportFormat);
+          });
+    } else {
+      allAlgorithmSpecifiersFor(vector.name)
+          .forEach(function(generateKeyAlgorithm) {
+            testCryptoKeyPairSerialization(
+                generateKeyAlgorithm, vector.usages, vector.publicFormat,
+                vector.privateFormat);
+          });
+    }
+  });
+}
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/x25519.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/x25519.https.any.js
new file mode 100644
index 00000000000000..618bf29ebfe206
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/x25519.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'X25519',
+    resultType: 'CryptoKeyPair',
+    usages: ['deriveKey', 'deriveBits'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js
new file mode 100644
index 00000000000000..cafc00144a3ce7
--- /dev/null
+++ b/test/fixtures/wpt/WebCryptoAPI/serialization/x448.tentative.https.any.js
@@ -0,0 +1,12 @@
+// META: title=WebCryptoAPI: CryptoKey serialization
+// META: script=../util/helpers.js
+// META: script=serialization.js
+run_test([
+  {
+    name: 'X448',
+    resultType: 'CryptoKeyPair',
+    usages: ['deriveKey', 'deriveBits'],
+    publicFormat: 'raw',
+    privateFormat: 'pkcs8'
+  },
+]);
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index 5a461bda392613..470592c842b925 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -96,7 +96,7 @@
     "path": "web-locks"
   },
   "WebCryptoAPI": {
-    "commit": "8b5cd267b480d75bce41aa306bebbd07ce414fa5",
+    "commit": "97bbc7247a16231f4744a47a1d9b3d29633d5292",
     "path": "WebCryptoAPI"
   },
   "webidl": {
diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs
index 4b01978511548f..c31831a6ea6a12 100644
--- a/test/wpt/status/WebCryptoAPI.cjs
+++ b/test/wpt/status/WebCryptoAPI.cjs
@@ -36,6 +36,8 @@ if (!hasOpenSSL(3, 0)) {
     'generateKey/successes_kmac.tentative.https.any.js',
     'import_export/AES-OCB_importKey.tentative.https.any.js',
     'import_export/KMAC_importKey.tentative.https.any.js',
+    'serialization/aes-ocb.tentative.https.any.js',
+    'serialization/kmac.tentative.https.any.js',
     'sign_verify/kmac.tentative.https.any.js');
 }
 
@@ -55,6 +57,8 @@ if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) {
     'generateKey/successes_ML-KEM.tentative.https.any.js',
     'import_export/ML-DSA_importKey.tentative.https.any.js',
     'import_export/ML-KEM_importKey.tentative.https.any.js',
+    'serialization/mldsa.tentative.https.any.js',
+    'serialization/mlkem.tentative.https.any.js',
     'sign_verify/mldsa.tentative.https.any.js');
 
   skipSubtests(
@@ -75,6 +79,8 @@ if (process.features.openssl_is_boringssl) {
     'import_export/okp_importKey_failures_Ed448.tentative.https.any.js',
     'import_export/okp_importKey_failures_X448.tentative.https.any.js',
     'import_export/okp_importKey_X448.tentative.https.any.js',
+    'serialization/ed448.tentative.https.any.js',
+    'serialization/x448.tentative.https.any.js',
     'sign_verify/eddsa_curve448.tentative.https.any.js');
 
   skipSubtests(
@@ -83,6 +89,7 @@ if (process.features.openssl_is_boringssl) {
     ['generateKey/failures_ML-KEM.tentative.https.any.js', /ml-kem-512/i],
     ['generateKey/successes_ML-KEM.tentative.https.any.js', /ml-kem-512/i],
     ['import_export/ML-KEM_importKey.tentative.https.any.js', /ml-kem-512/i],
+    ['serialization/mlkem.tentative.https.any.js', /ml-kem-512/i],
     ['supports-modern.tentative.https.any.js', /ml-kem-512/i]);
 }
 

From 614050b657e9757c1097aa85f92f2cb51149dc0d Mon Sep 17 00:00:00 2001
From: Stefan Stojanovic <StefanStojanovic@users.noreply.github.com>
Date: Thu, 21 May 2026 01:25:49 +0200
Subject: [PATCH 31/83] build,win: replace LTCG with Thin LTO for releases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: StefanStojanovic <stefan.stojanovic@janeasystems.com>
PR-URL: https://github.com/nodejs/node/pull/63114
Refs: https://github.com/nodejs/node/issues/61964
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 common.gypi  |  7 +++++++
 configure.py |  9 +++++++++
 vcbuild.bat  | 32 +++++++++++++++++++-------------
 3 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/common.gypi b/common.gypi
index c0a3d785a3dab3..26c2ef3675fd0e 100644
--- a/common.gypi
+++ b/common.gypi
@@ -272,6 +272,13 @@
                   },
                 },
               },],
+              ['(enable_thin_lto=="true" or enable_lto=="true") and lto_jobs!=""', {
+                'msvs_settings': {
+                  'VCLinkerTool': {
+                    'AdditionalOptions': ['/opt:lldltojobs=<(lto_jobs)'],
+                  },
+                },
+              },],
             ],
             'target_conditions': [
               ['_toolset=="target"', {
diff --git a/configure.py b/configure.py
index eea76312119385..ae5f9e70a69a35 100755
--- a/configure.py
+++ b/configure.py
@@ -225,6 +225,14 @@
     help="Enable compiling with thin lto of a binary. This feature is only available "
          "on windows.")
 
+parser.add_argument("--lto-jobs",
+    action="store",
+    dest="lto_jobs",
+    default=None,
+    help="Set the number of parallel LTO code generation jobs during linking. "
+         "Defaults to the number of CPU cores. Lower values reduce peak memory "
+         "usage at the cost of longer link times. Only effective with LTO enabled.")
+
 parser.add_argument("--link-module",
     action="append",
     dest="linked_module",
@@ -1995,6 +2003,7 @@ def configure_node(o):
 
   o['variables']['enable_lto'] = b(options.enable_lto)
   o['variables']['enable_thin_lto'] = b(options.enable_thin_lto)
+  o['variables']['lto_jobs'] = options.lto_jobs or ''
 
   if options.node_use_large_pages or options.node_use_large_pages_script_lld:
     warn('''The `--use-largepages` and `--use-largepages-script-lld` options
diff --git a/vcbuild.bat b/vcbuild.bat
index 0d3ce0fd021fb6..28494815df1d64 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -26,6 +26,7 @@ set target_arch=x64
 set ltcg=
 set thin_lto=
 set lto=
+set lto_jobs=
 set pgo_generate=
 set pgo_use=
 set target_env=
@@ -110,6 +111,7 @@ if /i "%1"=="nonpm"         set nonpm=1&goto arg-ok
 if /i "%1"=="ltcg"          set ltcg=1&goto arg-ok
 if /i "%1"=="thin-lto"      set thin_lto=1&goto arg-ok
 if /i "%1"=="lto"           set lto=1&goto arg-ok
+if /i "%1"=="lto-jobs"      set "lto_jobs=%2"&goto arg-ok-2
 if /i "%1"=="pgo-generate"  set pgo_generate=1&goto arg-ok
 if /i "%1"=="pgo-use"       set pgo_use=1&goto arg-ok
 if /i "%1"=="v8temporal"    set v8temporal=1&goto arg-ok
@@ -187,6 +189,20 @@ goto next-arg
 
 :args-done
 
+if defined build_release (
+  set config=Release
+  set package=1
+  set msi=1
+  set licensertf=1
+  set download_arg="--download=all"
+  set i18n_arg=full-icu
+  set projgen=1
+  set cctest=1
+  set thin_lto=1
+  @REM Parallel LTO link jobs can cause OOM issues, so we limit it to 2 by default for release builds in the release CI.
+  set lto_jobs=2
+)
+
 :: LTO mutual exclusion
 set lto_count=0
 if defined ltcg       set /a lto_count+=1
@@ -208,18 +224,6 @@ if defined pgo_generate if defined pgo_use (
   exit /b 1
 )
 
-if defined build_release (
-  set config=Release
-  set package=1
-  set msi=1
-  set licensertf=1
-  set download_arg="--download=all"
-  set i18n_arg=full-icu
-  set projgen=1
-  set cctest=1
-  set ltcg=1
-)
-
 if defined msi     set stage_package=1
 if defined package set stage_package=1
 
@@ -243,6 +247,7 @@ if defined nonpm            set configure_flags=%configure_flags% --without-npm
 if defined ltcg             set configure_flags=%configure_flags% --with-ltcg
 if defined thin_lto         set configure_flags=%configure_flags% --enable-thin-lto
 if defined lto              set configure_flags=%configure_flags% --enable-lto
+if defined lto_jobs         set configure_flags=%configure_flags% --lto-jobs=%lto_jobs%
 if defined pgo_generate     set configure_flags=%configure_flags% --enable-pgo-generate
 if defined pgo_use          set configure_flags=%configure_flags% --enable-pgo-use
 if defined release_urlbase  set configure_flags=%configure_flags% --release-urlbase=%release_urlbase%
@@ -908,7 +913,7 @@ set exit_code=1
 goto exit
 
 :help
-echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-doc/test-js-native-api/test-node-api/test-internet/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [build-addons/build-js-native-api-tests/build-node-api-tests/build-ffi-tests] [ignore-flaky] [static/dll] [noprojgen] [projgen] [clang-cl] [ccache path-to-ccache] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [nonpm] [ltcg] [thin-lto] [lto] [pgo-generate] [pgo-use] [licensetf] [sign] [x64/arm64] [vs2022/vs2026] [download-all] [enable-vtune] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [format-md] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
+echo vcbuild.bat [debug/release] [msi] [doc] [test/test-all/test-addons/test-doc/test-js-native-api/test-node-api/test-internet/test-tick-processor/test-known-issues/test-node-inspect/test-check-deopts/test-npm/test-v8/test-v8-intl/test-v8-benchmarks/test-v8-all] [build-addons/build-js-native-api-tests/build-node-api-tests/build-ffi-tests] [ignore-flaky] [static/dll] [noprojgen] [projgen] [clang-cl] [ccache path-to-ccache] [small-icu/full-icu/without-intl] [nobuild] [nosnapshot] [nonpm] [ltcg] [thin-lto] [lto] [lto-jobs number-of-jobs] [pgo-generate] [pgo-use] [licensetf] [sign] [x64/arm64] [vs2022/vs2026] [download-all] [enable-vtune] [lint/lint-ci/lint-js/lint-md] [lint-md-build] [format-md] [package] [build-release] [upload] [no-NODE-OPTIONS] [link-module path-to-module] [debug-http2] [debug-nghttp2] [clean] [cctest] [no-cctest] [openssl-no-asm]
 echo Examples:
 echo   vcbuild.bat                          : builds release build
 echo   vcbuild.bat debug                    : builds debug build
@@ -922,6 +927,7 @@ echo   vcbuild.bat no-cctest                : skip building cctest.exe
 echo   vcbuild.bat ccache c:\ccache\        : use ccache to speed build
 echo   vcbuild.bat thin-lto                 : builds with Thin LTO applied globally to all targets
 echo   vcbuild.bat lto                      : builds with Full LTO applied globally to all targets
+echo   vcbuild.bat thin-lto lto-jobs 2      : builds with Thin LTO applied globally to all targets and limits parallel LTO link jobs (reduces peak memory usage)
 echo   vcbuild.bat pgo-generate             : builds instrumented binary for PGO (profile first, then rebuild with pgo-use)
 echo   vcbuild.bat pgo-use                  : builds optimized binary using PGO profile data
 goto exit

From 61d66c32dd95a4b3ece77dfde60f6358d20da6f1 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Thu, 21 May 2026 11:06:29 +0200
Subject: [PATCH 32/83] test: unskip snapshot reproducibility test

Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63307
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Stewart X Addison <sxa@redhat.com>
Reviewed-By: Richard Lau <richard.lau@ibm.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/parallel/parallel.status | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status
index 5c7fe47927611f..73a866bbef8b75 100644
--- a/test/parallel/parallel.status
+++ b/test/parallel/parallel.status
@@ -19,9 +19,6 @@ test-fs-read-stream-concurrent-reads: PASS, FLAKY
 # https://github.com/nodejs/build/issues/3043
 test-snapshot-incompatible: SKIP
 
-# https://github.com/nodejs/node/issues/53579
-test-snapshot-reproducible: SKIP
-
 [$system==win32]
 # https://github.com/nodejs/node/issues/59090
 test-inspector-network-fetch: PASS, FLAKY

From a29a11864b73fe55e96dd6969602ca1990611d4f Mon Sep 17 00:00:00 2001
From: Nad Alaba <37968805+nadalaba@users.noreply.github.com>
Date: Thu, 21 May 2026 13:25:21 +0300
Subject: [PATCH 33/83] gyp: update deps gypfiles

Signed-off-by: Nad Alaba <37968805+nadalaba@users.noreply.github.com>
PR-URL: https://github.com/nodejs/node/pull/63117
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 deps/inspector_protocol/inspector_protocol.gyp | 1 -
 deps/uv/uv.gyp                                 | 1 -
 tools/v8_gypfiles/abseil.gyp                   | 4 +---
 3 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/deps/inspector_protocol/inspector_protocol.gyp b/deps/inspector_protocol/inspector_protocol.gyp
index 0eb551c769f55d..bd03b7ded1220f 100644
--- a/deps/inspector_protocol/inspector_protocol.gyp
+++ b/deps/inspector_protocol/inspector_protocol.gyp
@@ -14,7 +14,6 @@
       'crdtp/json.h',
       'crdtp/json_platform.cc',
       'crdtp/json_platform.h',
-      'crdtp/maybe.h',
       'crdtp/parser_handler.h',
       'crdtp/protocol_core.cc',
       'crdtp/protocol_core.h',
diff --git a/deps/uv/uv.gyp b/deps/uv/uv.gyp
index 540445f1f3249b..760a3cdb0019d1 100644
--- a/deps/uv/uv.gyp
+++ b/deps/uv/uv.gyp
@@ -62,7 +62,6 @@
     'uv_sources_win': [
       'include/uv/win.h',
       'src/win/async.c',
-      'src/win/atomicops-inl.h',
       'src/win/core.c',
       'src/win/detect-wakeup.c',
       'src/win/dl.c',
diff --git a/tools/v8_gypfiles/abseil.gyp b/tools/v8_gypfiles/abseil.gyp
index fdc2fae1ab4d75..1a1de3378605b0 100644
--- a/tools/v8_gypfiles/abseil.gyp
+++ b/tools/v8_gypfiles/abseil.gyp
@@ -35,14 +35,11 @@
         '<(ABSEIL_ROOT)/absl/base/internal/direct_mmap.h',
         '<(ABSEIL_ROOT)/absl/base/internal/endian.h',
         '<(ABSEIL_ROOT)/absl/base/internal/errno_saver.h',
-        '<(ABSEIL_ROOT)/absl/base/internal/fast_type_id.h',
         '<(ABSEIL_ROOT)/absl/base/internal/hide_ptr.h',
-        '<(ABSEIL_ROOT)/absl/base/internal/identity.h',
         '<(ABSEIL_ROOT)/absl/base/internal/iterator_traits.h',
         '<(ABSEIL_ROOT)/absl/base/internal/low_level_alloc.h',
         '<(ABSEIL_ROOT)/absl/base/internal/low_level_alloc.cc',
         '<(ABSEIL_ROOT)/absl/base/internal/low_level_scheduling.h',
-        '<(ABSEIL_ROOT)/absl/base/internal/nullability_impl.h',
         '<(ABSEIL_ROOT)/absl/base/internal/per_thread_tls.h',
         '<(ABSEIL_ROOT)/absl/base/internal/poison.h',
         '<(ABSEIL_ROOT)/absl/base/internal/poison.cc',
@@ -75,6 +72,7 @@
         '<(ABSEIL_ROOT)/absl/base/internal/unscaledcycleclock.h',
         '<(ABSEIL_ROOT)/absl/base/internal/unscaledcycleclock.cc',
         '<(ABSEIL_ROOT)/absl/base/internal/unscaledcycleclock_config.h',
+        '<(ABSEIL_ROOT)/absl/base/fast_type_id.h',
         '<(ABSEIL_ROOT)/absl/base/log_severity.h',
         '<(ABSEIL_ROOT)/absl/base/log_severity.cc',
         '<(ABSEIL_ROOT)/absl/base/macros.h',

From 145527738b317b9bb664a28d750ae65747d65912 Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Tue, 19 May 2026 14:07:05 +0300
Subject: [PATCH 34/83] test_runner: preserve run duration when using
 test-rerun

Signed-off-by: Moshe Atlow <moshe@atlow.co.il>
PR-URL: https://github.com/nodejs/node/pull/63429
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Aviv Keller <me@aviv.sh>
---
 lib/internal/test_runner/reporter/rerun.js       |  1 +
 lib/internal/test_runner/test.js                 | 15 ++++++++++++++-
 test/fixtures/test-runner/rerun-duration.js      | 13 +++++++++++++
 test/parallel/test-runner-test-rerun-failures.js | 15 +++++++++++++++
 4 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/test-runner/rerun-duration.js

diff --git a/lib/internal/test_runner/reporter/rerun.js b/lib/internal/test_runner/reporter/rerun.js
index 9658a7fb70ff0b..ecdd53243e887a 100644
--- a/lib/internal/test_runner/reporter/rerun.js
+++ b/lib/internal/test_runner/reporter/rerun.js
@@ -62,6 +62,7 @@ function reportReruns(previousRuns, globalOptions) {
           name: data.name,
           children,
           passed_on_attempt: data.details.passed_on_attempt ?? data.details.attempt,
+          duration_ms: data.details.duration_ms,
         };
       }
     }
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index eb888905798bcd..cae309ffc23938 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -10,10 +10,12 @@ const {
   ArrayPrototypeSplice,
   ArrayPrototypeUnshift,
   ArrayPrototypeUnshiftApply,
+  BigInt,
   Error,
   FunctionPrototype,
   MathFloor,
   MathMax,
+  MathRound,
   Number,
   NumberPrototypeToFixed,
   ObjectFreeze,
@@ -803,14 +805,25 @@ class Test extends AsyncResource {
       const previousAttempt = this.root.harness.previousRuns[this.attempt - 1]?.[testIdentifier];
       if (previousAttempt != null) {
         this.passedAttempt = previousAttempt.passed_on_attempt;
+        if (previousAttempt.duration_ms !== undefined) {
+          this.replayedDurationNs = BigInt(MathRound(previousAttempt.duration_ms * 1_000_000));
+        }
         this.fn = () => {
+          // Restore the original duration on the synthetic replay. Suites are
+          // skipped here because Suite.run() unconditionally reassigns
+          // startTime later; only non-suite tests benefit from setting it.
+          if (this.reportedType !== 'suite') {
+            this.startTime = hrtime();
+            this.endTime = this.startTime + (this.replayedDurationNs ?? 0n);
+          }
           for (let i = 0; i < (previousAttempt.children?.length ?? 0); i++) {
             const child = previousAttempt.children[i];
             const t = this.createSubtest(Test, child.name, { __proto__: null }, noop, {
               __proto__: null,
               loc: [child.line, child.column, child.file],
             }, noop);
-            t.endTime = t.startTime = hrtime();
+            t.startTime = hrtime();
+            t.endTime = t.startTime + (t.replayedDurationNs ?? 0n);
             // For suites, Suite.run() starts the subtests via SafePromiseAll.
             // Starting them here as well would run them twice, re-invoking the
             // synthetic children-creator against a now-incremented disambiguator
diff --git a/test/fixtures/test-runner/rerun-duration.js b/test/fixtures/test-runner/rerun-duration.js
new file mode 100644
index 00000000000000..522ca187c52de4
--- /dev/null
+++ b/test/fixtures/test-runner/rerun-duration.js
@@ -0,0 +1,13 @@
+'use strict';
+// A passing test with a measurable duration alongside a failing test. The
+// failing test forces the rerun feature to retry on a second invocation,
+// causing the passing test to be replayed via the synthetic noop stub.
+const { test } = require('node:test');
+
+test('passing slow test', async () => {
+  await new Promise((resolve) => setTimeout(resolve, 25));
+});
+
+test('always failing', () => {
+  throw new Error('boom');
+});
diff --git a/test/parallel/test-runner-test-rerun-failures.js b/test/parallel/test-runner-test-rerun-failures.js
index 585d5f25f04a59..f6ae8735e9b77a 100644
--- a/test/parallel/test-runner-test-rerun-failures.js
+++ b/test/parallel/test-runner-test-rerun-failures.js
@@ -89,6 +89,7 @@ const getStateFile = async () => {
   res.forEach((entry) => {
     for (const item in entry) {
       delete entry[item].children;
+      delete entry[item].duration_ms;
     }
   });
   return res;
@@ -152,6 +153,20 @@ test('test should pass on third rerun with `--test`', async () => {
   assert.deepStrictEqual(await getStateFile(), expectedStateFile);
 });
 
+test('rerun preserves the original duration on the replayed pass', async () => {
+  const durationFixture = fixtures.path('test-runner', 'rerun-duration.js');
+  const args = ['--test-rerun-failures', stateFile, durationFixture];
+
+  await common.spawnPromisified(process.execPath, args);
+  await common.spawnPromisified(process.execPath, args);
+
+  const raw = JSON.parse(await readFile(stateFile, 'utf8'));
+  const passKey = Object.keys(raw[0]).find((k) => raw[0][k].name === 'passing slow test');
+  assert.ok(passKey, 'expected the passing test to be recorded on attempt 0');
+  assert.ok(raw[0][passKey].duration_ms > 0, 'expected a measurable duration on attempt 0');
+  assert.strictEqual(raw[1][passKey].duration_ms, raw[0][passKey].duration_ms);
+});
+
 test('using `run` api', async () => {
   let stream = run({ files: [fixture], rerunFailuresFilePath: stateFile });
   stream.on('test:pass', common.mustCall(19));

From 5c870129cc06d6c668ad67c722042de1248433d5 Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Tue, 19 May 2026 14:10:41 +0300
Subject: [PATCH 35/83] test_runner: show replayed-from-attempt hint in spec
 reporter

Signed-off-by: Moshe Atlow <moshe@atlow.co.il>
PR-URL: https://github.com/nodejs/node/pull/63429
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Aviv Keller <me@aviv.sh>
---
 lib/internal/test_runner/reporter/utils.js       |  5 ++++-
 test/parallel/test-runner-test-rerun-failures.js | 11 +++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
index d90040b9727aa2..67030680019838 100644
--- a/lib/internal/test_runner/reporter/utils.js
+++ b/lib/internal/test_runner/reporter/utils.js
@@ -73,7 +73,10 @@ function formatTestReport(type, data, showErrorDetails = true, prefix = '', inde
   let symbol = reporterUnicodeSymbolMap[type] ?? ' ';
   const { skip, todo, expectFailure } = data;
   const duration_ms = data.details?.duration_ms ? ` ${colors.gray}(${data.details.duration_ms}ms)${colors.white}` : '';
-  let title = `${data.name}${duration_ms}`;
+  const replayed = data.details?.passed_on_attempt !== undefined ?
+    ` ${colors.gray}(passed on attempt ${data.details.passed_on_attempt})${colors.white}` :
+    '';
+  let title = `${data.name}${duration_ms}${replayed}`;
 
   if (skip !== undefined) {
     title += ` # ${typeof skip === 'string' && skip.length ? skip : 'SKIP'}`;
diff --git a/test/parallel/test-runner-test-rerun-failures.js b/test/parallel/test-runner-test-rerun-failures.js
index f6ae8735e9b77a..3a9249cc52277b 100644
--- a/test/parallel/test-runner-test-rerun-failures.js
+++ b/test/parallel/test-runner-test-rerun-failures.js
@@ -157,8 +157,15 @@ test('rerun preserves the original duration on the replayed pass', async () => {
   const durationFixture = fixtures.path('test-runner', 'rerun-duration.js');
   const args = ['--test-rerun-failures', stateFile, durationFixture];
 
-  await common.spawnPromisified(process.execPath, args);
-  await common.spawnPromisified(process.execPath, args);
+  const first = await common.spawnPromisified(process.execPath, args);
+  assert.doesNotMatch(first.stdout, /passed on attempt/,
+                      'no replay marker should appear on the initial run');
+
+  const second = await common.spawnPromisified(process.execPath, args);
+  assert.match(second.stdout, /passing slow test[^\n]*\(passed on attempt 0\)/,
+               'spec reporter should mark the replayed test on the retry');
+  assert.doesNotMatch(second.stdout, /always failing[^\n]*\(passed on attempt/,
+                      'the failing test must not show the replay marker');
 
   const raw = JSON.parse(await readFile(stateFile, 'utf8'));
   const passKey = Object.keys(raw[0]).find((k) => raw[0][k].name === 'passing slow test');

From 0d6541aca0818cdd4f35d49387899cf2cee24c2a Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Tue, 12 May 2026 05:17:56 -0400
Subject: [PATCH 36/83] 2026-05-21, Version 24.16.0 'Krypton' (LTS)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Notable changes:

crypto:
  * (SEMVER-MINOR) implement `randomUUIDv7()` (nabeel378) https://github.com/nodejs/node/pull/62553
debugger:
  * (SEMVER-MINOR) add edit-free runtime expression probes to `node inspect` (Joyee Cheung) https://github.com/nodejs/node/pull/62713
fs:
  * (SEMVER-MINOR) add `signal` option to `fs.stat()` (Mert Can Altin) https://github.com/nodejs/node/pull/57775
  * (SEMVER-MINOR) expose `frsize` field in `statfs` (Jinho Jang) https://github.com/nodejs/node/pull/62277
http:
  * (SEMVER-MINOR) harden `ClientRequest` options merge (Matteo Collina) https://github.com/nodejs/node/pull/63082
  * (SEMVER-MINOR) add `req.signal` to `IncomingMessage` (Akshat) https://github.com/nodejs/node/pull/62541
stream:
  * (SEMVER-MINOR) propagate destruction in `duplexPair` (Ahmed Elhor) https://github.com/nodejs/node/pull/61098
test_runner:
  * (SEMVER-MINOR) support test order randomization (Pietro Marchini) https://github.com/nodejs/node/pull/61747
  * (SEMVER-MINOR) align mock timeout api (sangwook) https://github.com/nodejs/node/pull/62820
  * (SEMVER-MINOR) add mock-timers support for `AbortSignal.timeout` (DeveloperViraj) https://github.com/nodejs/node/pull/60751
util:
  * (SEMVER-MINOR) colorize text with hex colors (Guilherme Araújo) https://github.com/nodejs/node/pull/61556

PR-URL: https://github.com/nodejs/node/pull/63263
---
 CHANGELOG.md                    |   3 +-
 doc/api/cli.md                  |  13 +-
 doc/api/crypto.md               |  12 +-
 doc/api/debugger.md             |   1 +
 doc/api/errors.md               |   4 +-
 doc/api/fs.md                   |  24 ++-
 doc/api/http.md                 |   4 +-
 doc/api/inspector.md            |   5 +
 doc/api/n-api.md                |   4 +-
 doc/api/quic.md                 |  12 +-
 doc/api/sqlite.md               |   8 +-
 doc/api/test.md                 |  20 ++-
 doc/api/util.md                 |   4 +-
 doc/changelogs/CHANGELOG_V24.md | 251 ++++++++++++++++++++++++++++++++
 14 files changed, 338 insertions(+), 27 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c20d0ea446bf2d..36ee35300f6bce 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -63,7 +63,8 @@ release.
 <a href="doc/changelogs/CHANGELOG_V25.md#25.0.0">25.0.0</a><br/>
   </td>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V24.md#24.15.0">24.15.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V24.md#24.16.0">24.16.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V24.md#24.15.0">24.15.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.14.1">24.14.1</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.14.0">24.14.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.13.1">24.13.1</a><br/>
diff --git a/doc/api/cli.md b/doc/api/cli.md
index f544e0a0d68881..28d85a74c8707c 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1321,7 +1321,9 @@ top-level awaits, and print their location to help users find them.
 ### `--experimental-quic`
 
 <!-- YAML
-added: v25.0.0
+added:
+ - v25.0.0
+ - v24.16.0
 -->
 
 > Stability: 1.1 - Active development
@@ -1355,6 +1357,7 @@ Use this flag to enable [ShadowRealm][] support.
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 > Stability: 1.1 - Active Development
@@ -2893,7 +2896,9 @@ option set. This flag is not necessary when test isolation is disabled.
 ### `--test-random-seed`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 Set the seed used to randomize test execution order. This applies to both test
@@ -2907,7 +2912,9 @@ This flag cannot be used with `--watch` or `--test-rerun-failures`.
 ### `--test-randomize`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 Randomize test execution order. This applies to both test file execution order
diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index efb3fa4a6cf0ee..00a77f38a6d3b3 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -5850,7 +5850,9 @@ cryptographic pseudorandom number generator.
 ### `crypto.randomUUIDv7([options])`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * `options` {Object}
@@ -6102,7 +6104,9 @@ Throws an error if FIPS mode is not available.
 <!-- YAML
 added: v12.0.0
 changes:
-  - version: v26.0.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/62474
     description: Add support for Ed25519 context parameter.
   - version: v24.8.0
@@ -6231,7 +6235,9 @@ not introduce timing vulnerabilities.
 <!-- YAML
 added: v12.0.0
 changes:
-  - version: v26.0.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/62474
     description: Add support for Ed25519 context parameter.
   - version: v24.8.0
diff --git a/doc/api/debugger.md b/doc/api/debugger.md
index 5eeffd43e57f5f..478a4534ad4ca9 100644
--- a/doc/api/debugger.md
+++ b/doc/api/debugger.md
@@ -235,6 +235,7 @@ debug>
 <!-- YAML
 added:
   - v26.1.0
+  - v24.16.0
 changes:
   - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63286
diff --git a/doc/api/errors.md b/doc/api/errors.md
index e8c87ebb502fdc..5dbb2106163810 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -2768,7 +2768,9 @@ ES modules. When `require()` encounters an ES module that contains top-level
 ### `ERR_REQUIRE_ESM_RACE_CONDITION`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 > Stability: 1 - Experimental.
diff --git a/doc/api/fs.md b/doc/api/fs.md
index e1211e4cd25f3f..8c20afd92182de 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -780,7 +780,9 @@ Read from a file and write to an array of {ArrayBufferView}s
 <!-- YAML
 added: v10.0.0
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/57775
     description: Now accepts an additional `signal` property to allow aborting the operation.
   - version: v10.5.0
@@ -1354,7 +1356,9 @@ behavior is similar to `cp dir1/ dir2/`.
 <!-- YAML
 added: v22.0.0
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/62695
     description: Add support for the `followSymlinks` option.
   - version:
@@ -3475,7 +3479,9 @@ descriptor. See [`fs.utimes()`][].
 <!-- YAML
 added: v22.0.0
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/62695
     description: Add support for the `followSymlinks` option.
   - version:
@@ -5086,7 +5092,9 @@ The `atime` and `mtime` arguments follow these rules:
 <!-- YAML
 added: v0.5.10
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/61870
     description: Added `throwIfNoEntry` option.
   - version: v19.1.0
@@ -6065,7 +6073,9 @@ Synchronous version of [`fs.futimes()`][]. Returns `undefined`.
 <!-- YAML
 added: v22.0.0
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/62695
     description: Add support for the `followSymlinks` option.
   - version:
@@ -8033,7 +8043,9 @@ Optimal transfer block size.
 #### `statfs.frsize`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {number|bigint}
diff --git a/doc/api/http.md b/doc/api/http.md
index 0775ad1a1a0dec..41ecdf6d00b3be 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -3030,7 +3030,9 @@ Calls `message.socket.setTimeout(msecs, callback)`.
 ### `message.signal`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {AbortSignal}
diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 4cdbeb62d0e71a..8c6f45e3d15a88 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -687,6 +687,7 @@ For more details, see the official CDP documentation: [Network.loadNetworkResour
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 * `params` {Object}
@@ -708,6 +709,7 @@ This event indicates that a new item has been added to the storage.
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 * `params` {Object}
@@ -728,6 +730,7 @@ This event indicates that an item has been removed from the storage.
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 * `params` {Object}
@@ -750,6 +753,7 @@ This event indicates that a storage item has been updated.
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 * `params` {Object}
@@ -770,6 +774,7 @@ storage.
 <!-- YAML
 added:
   - v25.5.0
+  - v24.16.0
 -->
 
 * `params` {Object}
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 29c0bff1fab712..1679710cfa1b30 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2578,7 +2578,9 @@ JavaScript `ArrayBuffer`s are described in
 #### `node_api_create_external_sharedarraybuffer`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 ```c
diff --git a/doc/api/quic.md b/doc/api/quic.md
index 4ad25810ab4627..7e765f21083bea 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -577,7 +577,9 @@ The valid range is `0` to `65535`.
 ### `endpoint.setSNIContexts(entries[, options])`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * `entries` {object} An object mapping host names to TLS identity options.
@@ -2396,7 +2398,9 @@ added: v23.8.0
 #### `sessionOptions.alpn`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {string} (client) | {string\[]} (server)
@@ -2725,7 +2729,9 @@ The peer server name to target (SNI). Defaults to `'localhost'`.
 #### `sessionOptions.sni` (server only)
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {Object}
diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index f4eb4e9c862961..e277457c00dea7 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -562,7 +562,9 @@ the constructor. An exception is thrown if the database is already open.
 ### `database.serialize([dbName])`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * `dbName` {string} Name of the database to serialize. This can be `'main'`
@@ -597,7 +599,9 @@ console.log(buffer.length); // Prints the byte length of the database
 ### `database.deserialize(buffer[, options])`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * `buffer` {Uint8Array} A binary representation of a database, such as the
diff --git a/doc/api/test.md b/doc/api/test.md
index 830c5434a49544..19b7e87e099221 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -706,7 +706,9 @@ node --test "**/*.test.js" "**/*.spec.js"
 ### Randomizing tests execution order
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 > Stability: 1.0 - Early development
@@ -3833,7 +3835,9 @@ with.
 ## Test instrumentation and OpenTelemetry
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 The test runner publishes test execution events through the Node.js
@@ -4610,7 +4614,9 @@ Can be used to abort test subtasks when the test has been aborted.
 ### `context.passed`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {boolean}
@@ -4620,7 +4626,9 @@ Indicates whether the suite and all of its subtests have passed.
 ### `context.attempt`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * Type: {number}
@@ -4632,7 +4640,9 @@ the second attempt is `1`, and so on. This property is useful in conjunction wit
 ### `context.diagnostic(message)`
 
 <!-- YAML
-added: v26.1.0
+added:
+ - v26.1.0
+ - v24.16.0
 -->
 
 * `message` {string} A diagnostic message to output.
diff --git a/doc/api/util.md b/doc/api/util.md
index 770322b29d5e07..568d575c3d8735 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -2548,7 +2548,9 @@ added:
   - v21.7.0
   - v20.12.0
 changes:
-  - version: v26.1.0
+  - version:
+     - v26.1.0
+     - v24.16.0
     pr-url: https://github.com/nodejs/node/pull/61556
     description: Add support for hexadecimal colors.
   - version:
diff --git a/doc/changelogs/CHANGELOG_V24.md b/doc/changelogs/CHANGELOG_V24.md
index f0e903b3349c0a..6ba0beb61bcdcc 100644
--- a/doc/changelogs/CHANGELOG_V24.md
+++ b/doc/changelogs/CHANGELOG_V24.md
@@ -9,6 +9,7 @@
 </tr>
 <tr>
 <td>
+<a href="#24.16.0">24.16.0</a><br/>
 <a href="#24.15.0">24.15.0</a><br/>
 <a href="#24.14.1">24.14.1</a><br/>
 <a href="#24.14.0">24.14.0</a><br/>
@@ -65,6 +66,256 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="24.16.0"></a>
+
+## 2026-05-21, Version 24.16.0 'Krypton' (LTS), @aduh95
+
+### Notable Changes
+
+* \[[`b267f6bca3`](https://github.com/nodejs/node/commit/b267f6bca3)] - **(SEMVER-MINOR)** **crypto**: implement `randomUUIDv7()` (nabeel378) [#62553](https://github.com/nodejs/node/pull/62553)
+* \[[`ec2451b9cd`](https://github.com/nodejs/node/commit/ec2451b9cd)] - **(SEMVER-MINOR)** **debugger**: add edit-free runtime expression probes to `node inspect` (Joyee Cheung) [#62713](https://github.com/nodejs/node/pull/62713)
+* \[[`9705f628d9`](https://github.com/nodejs/node/commit/9705f628d9)] - **(SEMVER-MINOR)** **fs**: add signal option to `fs.stat()` (Mert Can Altin) [#57775](https://github.com/nodejs/node/pull/57775)
+* \[[`40ccfdecf9`](https://github.com/nodejs/node/commit/40ccfdecf9)] - **(SEMVER-MINOR)** **fs**: expose `frsize` field in `statfs` (Jinho Jang) [#62277](https://github.com/nodejs/node/pull/62277)
+* \[[`d7188af5c9`](https://github.com/nodejs/node/commit/d7188af5c9)] - **(SEMVER-MINOR)** **http**: harden `ClientRequest` options merge (Matteo Collina) [#63082](https://github.com/nodejs/node/pull/63082)
+* \[[`aa1d8a9afc`](https://github.com/nodejs/node/commit/aa1d8a9afc)] - **(SEMVER-MINOR)** **http**: add `req.signal` to `IncomingMessage` (Akshat) [#62541](https://github.com/nodejs/node/pull/62541)
+* \[[`6f37f7e240`](https://github.com/nodejs/node/commit/6f37f7e240)] - **(SEMVER-MINOR)** **stream**: propagate destruction in `duplexPair` (Ahmed Elhor) [#61098](https://github.com/nodejs/node/pull/61098)
+* \[[`d14029be7f`](https://github.com/nodejs/node/commit/d14029be7f)] - **(SEMVER-MINOR)** **test\_runner**: support test order randomization (Pietro Marchini) [#61747](https://github.com/nodejs/node/pull/61747)
+* \[[`d142c584cd`](https://github.com/nodejs/node/commit/d142c584cd)] - **(SEMVER-MINOR)** **test\_runner**: align mock timeout api (sangwook) [#62820](https://github.com/nodejs/node/pull/62820)
+* \[[`01a9552585`](https://github.com/nodejs/node/commit/01a9552585)] - **(SEMVER-MINOR)** **test\_runner**: add mock-timers support for `AbortSignal.timeout` (DeveloperViraj) [#60751](https://github.com/nodejs/node/pull/60751)
+* \[[`00705a459a`](https://github.com/nodejs/node/commit/00705a459a)] - **(SEMVER-MINOR)** **util**: colorize text with hex colors (Guilherme Araújo) [#61556](https://github.com/nodejs/node/pull/61556)
+
+### Commits
+
+* \[[`dd72df060d`](https://github.com/nodejs/node/commit/dd72df060d)] - **assert,util**: fix stale nested cycle memo entries (Ruben Bridgewater) [#62509](https://github.com/nodejs/node/pull/62509)
+* \[[`add94f4bc3`](https://github.com/nodejs/node/commit/add94f4bc3)] - **build**: track PDL files as inputs in inspector GN build (Robo) [#62888](https://github.com/nodejs/node/pull/62888)
+* \[[`1b1eb9e334`](https://github.com/nodejs/node/commit/1b1eb9e334)] - **build**: remove redundant -fuse-linker-plugin from GCC LTO flags (Daniel Lando) [#62667](https://github.com/nodejs/node/pull/62667)
+* \[[`8752b604ec`](https://github.com/nodejs/node/commit/8752b604ec)] - **crypto**: deduplicate and canonicalize CryptoKey usages (Filip Skokan) [#62902](https://github.com/nodejs/node/pull/62902)
+* \[[`341947e7fd`](https://github.com/nodejs/node/commit/341947e7fd)] - **crypto**: reject unintended raw key format string input (Filip Skokan) [#62974](https://github.com/nodejs/node/pull/62974)
+* \[[`28a78747fc`](https://github.com/nodejs/node/commit/28a78747fc)] - **crypto**: remove Argon2 KDF derivation from its job setup (Filip Skokan) [#62863](https://github.com/nodejs/node/pull/62863)
+* \[[`16e8c2b54d`](https://github.com/nodejs/node/commit/16e8c2b54d)] - **crypto**: fix unsigned conversion of 4-byte RSA publicExponent (DeepView Autofix) [#62839](https://github.com/nodejs/node/pull/62839)
+* \[[`eeae754a87`](https://github.com/nodejs/node/commit/eeae754a87)] - **crypto**: reject inherited key type names (Jonathan Lopes) [#62875](https://github.com/nodejs/node/pull/62875)
+* \[[`9dd5540325`](https://github.com/nodejs/node/commit/9dd5540325)] - **crypto**: add memory tracking for secureContext openssl objects (Mert Can Altin) [#59051](https://github.com/nodejs/node/pull/59051)
+* \[[`b267f6bca3`](https://github.com/nodejs/node/commit/b267f6bca3)] - **(SEMVER-MINOR)** **crypto**: implement randomUUIDv7() (nabeel378) [#62553](https://github.com/nodejs/node/pull/62553)
+* \[[`7597d204c1`](https://github.com/nodejs/node/commit/7597d204c1)] - **crypto**: add support for Ed25519 context parameter (Filip Skokan) [#62474](https://github.com/nodejs/node/pull/62474)
+* \[[`4bf85845da`](https://github.com/nodejs/node/commit/4bf85845da)] - **debugger**: move ProbeInspectorSession and helpers to separate files (Joyee Cheung) [#63013](https://github.com/nodejs/node/pull/63013)
+* \[[`ec2451b9cd`](https://github.com/nodejs/node/commit/ec2451b9cd)] - **(SEMVER-MINOR)** **debugger**: add edit-free runtime expression probes to `node inspect` (Joyee Cheung) [#62713](https://github.com/nodejs/node/pull/62713)
+* \[[`83e98f77b7`](https://github.com/nodejs/node/commit/83e98f77b7)] - **deps**: update corepack to 0.35.0 (Node.js GitHub Bot) [#63375](https://github.com/nodejs/node/pull/63375)
+* \[[`ec8c6b939a`](https://github.com/nodejs/node/commit/ec8c6b939a)] - **deps**: V8: cherry-pick 657d8de27427 (Guy Bedford) [#62784](https://github.com/nodejs/node/pull/62784)
+* \[[`722c0c3274`](https://github.com/nodejs/node/commit/722c0c3274)] - **deps**: update nghttp3 to 1.14.0 (Node.js GitHub Bot) [#61187](https://github.com/nodejs/node/pull/61187)
+* \[[`5304db93d3`](https://github.com/nodejs/node/commit/5304db93d3)] - **deps**: update nghttp3 to 1.13.1 (Node.js GitHub Bot) [#60046](https://github.com/nodejs/node/pull/60046)
+* \[[`e073b3811d`](https://github.com/nodejs/node/commit/e073b3811d)] - **deps**: update nghttp3 to 1.11.0 (James M Snell) [#59249](https://github.com/nodejs/node/pull/59249)
+* \[[`1d00313fb2`](https://github.com/nodejs/node/commit/1d00313fb2)] - **deps**: update ngtcp2 to 1.14.0 (James M Snell) [#59249](https://github.com/nodejs/node/pull/59249)
+* \[[`8b3a4fc18f`](https://github.com/nodejs/node/commit/8b3a4fc18f)] - **deps**: update amaro to 1.1.9 (Node.js GitHub Bot) [#63090](https://github.com/nodejs/node/pull/63090)
+* \[[`62fe0cfcd1`](https://github.com/nodejs/node/commit/62fe0cfcd1)] - **deps**: update llhttp to 9.4.1 (Node.js GitHub Bot) [#63045](https://github.com/nodejs/node/pull/63045)
+* \[[`137e09c8e9`](https://github.com/nodejs/node/commit/137e09c8e9)] - **deps**: update corepack to 0.34.7 (Node.js GitHub Bot) [#62810](https://github.com/nodejs/node/pull/62810)
+* \[[`14a4cb8fbc`](https://github.com/nodejs/node/commit/14a4cb8fbc)] - **deps**: update timezone to 2026b (Node.js GitHub Bot) [#62962](https://github.com/nodejs/node/pull/62962)
+* \[[`3e1036583a`](https://github.com/nodejs/node/commit/3e1036583a)] - **deps**: upgrade npm to 11.13.0 (npm team) [#62898](https://github.com/nodejs/node/pull/62898)
+* \[[`01dfe5961c`](https://github.com/nodejs/node/commit/01dfe5961c)] - **deps**: cherry-pick libuv/libuv\@439a54b (skooch) [#62881](https://github.com/nodejs/node/pull/62881)
+* \[[`6cd368b10c`](https://github.com/nodejs/node/commit/6cd368b10c)] - **deps**: update sqlite to 3.53.0 (Node.js GitHub Bot) [#62699](https://github.com/nodejs/node/pull/62699)
+* \[[`f218a4f553`](https://github.com/nodejs/node/commit/f218a4f553)] - **deps**: update nbytes to 0.1.4 (Node.js GitHub Bot) [#62698](https://github.com/nodejs/node/pull/62698)
+* \[[`b47688524a`](https://github.com/nodejs/node/commit/b47688524a)] - **deps**: update archs files for openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629)
+* \[[`d202e2d343`](https://github.com/nodejs/node/commit/d202e2d343)] - **deps**: upgrade openssl sources to openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629)
+* \[[`2faba66341`](https://github.com/nodejs/node/commit/2faba66341)] - **deps**: update minimatch to 10.2.5 (Node.js GitHub Bot) [#62594](https://github.com/nodejs/node/pull/62594)
+* \[[`fa46c90c5d`](https://github.com/nodejs/node/commit/fa46c90c5d)] - **deps**: update googletest to d72f9c8aea6817cdf1ca0ac10887f328de7f3da2 (Node.js GitHub Bot) [#62593](https://github.com/nodejs/node/pull/62593)
+* \[[`099ded5713`](https://github.com/nodejs/node/commit/099ded5713)] - **deps**: update simdjson to 4.6.1 (Node.js GitHub Bot) [#62592](https://github.com/nodejs/node/pull/62592)
+* \[[`7ce95afe96`](https://github.com/nodejs/node/commit/7ce95afe96)] - **deps**: libuv: cherry-pick aabb7651de (Santiago Gimeno) [#62561](https://github.com/nodejs/node/pull/62561)
+* \[[`57ef845623`](https://github.com/nodejs/node/commit/57ef845623)] - **deps**: update icu to 78.3 (Node.js GitHub Bot) [#62324](https://github.com/nodejs/node/pull/62324)
+* \[[`493ac40e12`](https://github.com/nodejs/node/commit/493ac40e12)] - **deps**: update libuv to 1.52.1 (Node.js GitHub Bot) [#61829](https://github.com/nodejs/node/pull/61829)
+* \[[`b39508b368`](https://github.com/nodejs/node/commit/b39508b368)] - **deps**: update undici to 7.25.0 (Node.js GitHub Bot) [#63011](https://github.com/nodejs/node/pull/63011)
+* \[[`cb67a925e9`](https://github.com/nodejs/node/commit/cb67a925e9)] - **deps**: use npm undici\@seven tag in `update-undici.sh` (Matteo Collina) [#62739](https://github.com/nodejs/node/pull/62739)
+* \[[`aa1e0bc28b`](https://github.com/nodejs/node/commit/aa1e0bc28b)] - **doc**: fix typos and inconsistencies in crypto.md and webcrypto.md (Filip Skokan) [#62828](https://github.com/nodejs/node/pull/62828)
+* \[[`f2a1735ed9`](https://github.com/nodejs/node/commit/f2a1735ed9)] - **doc**: fix duplicate word "to to" in util.styleText (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917)
+* \[[`b6378e215c`](https://github.com/nodejs/node/commit/b6378e215c)] - **doc**: fix node-config-schema (Сковорода Никита Андреевич) [#61596](https://github.com/nodejs/node/pull/61596)
+* \[[`233894a9ce`](https://github.com/nodejs/node/commit/233894a9ce)] - **doc**: fix the TypeScript Execute (tsx) project link (David Thornton) [#63093](https://github.com/nodejs/node/pull/63093)
+* \[[`5d97919f8f`](https://github.com/nodejs/node/commit/5d97919f8f)] - **doc**: correct diagnostics\_channel built-in channel names (Bryan English) [#62995](https://github.com/nodejs/node/pull/62995)
+* \[[`2a9ccc927e`](https://github.com/nodejs/node/commit/2a9ccc927e)] - **doc**: use mjs/cjs blocks for callbackify null reason example (Daijiro Wachi) [#62884](https://github.com/nodejs/node/pull/62884)
+* \[[`ef413b5358`](https://github.com/nodejs/node/commit/ef413b5358)] - **doc**: fix typo in test.md (Rich Trott) [#62960](https://github.com/nodejs/node/pull/62960)
+* \[[`76f21c5070`](https://github.com/nodejs/node/commit/76f21c5070)] - **doc**: correct typo in PR contribution instructions (Mike McCready) [#62738](https://github.com/nodejs/node/pull/62738)
+* \[[`ca02af1f7d`](https://github.com/nodejs/node/commit/ca02af1f7d)] - **doc**: fix duplicate word "of of" in postMessageToThread (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917)
+* \[[`46c99ed526`](https://github.com/nodejs/node/commit/46c99ed526)] - **doc**: fix duplicate word "for for" in compile cache (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917)
+* \[[`1a60851734`](https://github.com/nodejs/node/commit/1a60851734)] - **doc**: fix typo in dns.lookup options description (Daijiro Wachi) [#62882](https://github.com/nodejs/node/pull/62882)
+* \[[`169b5ea2ed`](https://github.com/nodejs/node/commit/169b5ea2ed)] - **doc**: fix Argon2 parameter bounds (Tobias Nießen) [#62868](https://github.com/nodejs/node/pull/62868)
+* \[[`9a3a190f4e`](https://github.com/nodejs/node/commit/9a3a190f4e)] - **doc**: clarify diffieHellman.generateKeys recomputes same key (Kit Dallege) [#62205](https://github.com/nodejs/node/pull/62205)
+* \[[`0fba9e87d6`](https://github.com/nodejs/node/commit/0fba9e87d6)] - **doc**: remove Ayase-252 and meixg from triagger team (Antoine du Hamel) [#62841](https://github.com/nodejs/node/pull/62841)
+* \[[`9c700f3446`](https://github.com/nodejs/node/commit/9c700f3446)] - **doc**: clarify dns.lookup() callback signature when all is true (eungi) [#62800](https://github.com/nodejs/node/pull/62800)
+* \[[`6b7280bc17`](https://github.com/nodejs/node/commit/6b7280bc17)] - **doc**: add experimental modules lifetime policy (Paolo Insogna) [#62753](https://github.com/nodejs/node/pull/62753)
+* \[[`ce47ea31c9`](https://github.com/nodejs/node/commit/ce47ea31c9)] - **doc**: clarify process.\_debugProcess() in Permission Model (Fahad Khan) [#62537](https://github.com/nodejs/node/pull/62537)
+* \[[`ba01633757`](https://github.com/nodejs/node/commit/ba01633757)] - **doc**: fix typo in devcontainer guide (Rohan Santhosh Kumar) [#62687](https://github.com/nodejs/node/pull/62687)
+* \[[`70b4d5839b`](https://github.com/nodejs/node/commit/70b4d5839b)] - **doc**: clarify Backport-PR-URL metadata added automatically (Mike McCready) [#62668](https://github.com/nodejs/node/pull/62668)
+* \[[`8126d1c3eb`](https://github.com/nodejs/node/commit/8126d1c3eb)] - **doc**: update WPT test runner README.md (Filip Skokan) [#62680](https://github.com/nodejs/node/pull/62680)
+* \[[`978afea4b5`](https://github.com/nodejs/node/commit/978afea4b5)] - **doc**: fix spelling in release announcement guidance (Rohan Santhosh Kumar) [#62663](https://github.com/nodejs/node/pull/62663)
+* \[[`1684ab8ff8`](https://github.com/nodejs/node/commit/1684ab8ff8)] - **doc**: note non-monotonic clock in crypto.randomUUIDv7 (nabeel378) [#62600](https://github.com/nodejs/node/pull/62600)
+* \[[`86d4f07930`](https://github.com/nodejs/node/commit/86d4f07930)] - **doc**: update bug bounty program (Rafael Gonzaga) [#62590](https://github.com/nodejs/node/pull/62590)
+* \[[`736ed8a08f`](https://github.com/nodejs/node/commit/736ed8a08f)] - **doc**: document TransformStream transformer.cancel option (Tom Pereira) [#62566](https://github.com/nodejs/node/pull/62566)
+* \[[`938af9be01`](https://github.com/nodejs/node/commit/938af9be01)] - **doc**: mention test runner retry attemp is zero based (Moshe Atlow) [#62504](https://github.com/nodejs/node/pull/62504)
+* \[[`94433e450f`](https://github.com/nodejs/node/commit/94433e450f)] - **doc,src,test**: fix dead inspector help URL (semimikoh) [#62745](https://github.com/nodejs/node/pull/62745)
+* \[[`ddf1f01659`](https://github.com/nodejs/node/commit/ddf1f01659)] - **esm**: add `ERR_REQUIRE_ESM_RACE_CONDITION` (Antoine du Hamel) [#62462](https://github.com/nodejs/node/pull/62462)
+* \[[`4a506acd16`](https://github.com/nodejs/node/commit/4a506acd16)] - **fs**: add followSymlinks option to glob (Matteo Collina) [#62695](https://github.com/nodejs/node/pull/62695)
+* \[[`f4ea495f9b`](https://github.com/nodejs/node/commit/f4ea495f9b)] - **fs**: restore fs patchability in ESM loader (Joyee Cheung) [#62835](https://github.com/nodejs/node/pull/62835)
+* \[[`63c111cd60`](https://github.com/nodejs/node/commit/63c111cd60)] - **fs**: validate position argument before length === 0 early return (Edy Silva) [#62674](https://github.com/nodejs/node/pull/62674)
+* \[[`9705f628d9`](https://github.com/nodejs/node/commit/9705f628d9)] - **(SEMVER-MINOR)** **fs**: add signal option to fs.stat() (Mert Can Altin) [#57775](https://github.com/nodejs/node/pull/57775)
+* \[[`40ccfdecf9`](https://github.com/nodejs/node/commit/40ccfdecf9)] - **(SEMVER-MINOR)** **fs**: expose frsize field in statfs (Jinho Jang) [#62277](https://github.com/nodejs/node/pull/62277)
+* \[[`717476a24e`](https://github.com/nodejs/node/commit/717476a24e)] - **http**: emit 'drain' on OutgoingMessage only after buffers drain (Robert Nagy) [#62936](https://github.com/nodejs/node/pull/62936)
+* \[[`d7188af5c9`](https://github.com/nodejs/node/commit/d7188af5c9)] - **(SEMVER-MINOR)** **http**: harden ClientRequest options merge (Matteo Collina) [#63082](https://github.com/nodejs/node/pull/63082)
+* \[[`64f15c274a`](https://github.com/nodejs/node/commit/64f15c274a)] - **http**: fix leaked error listener on sync HTTP req create + destroy (Tim Perry) [#62872](https://github.com/nodejs/node/pull/62872)
+* \[[`5c4798d799`](https://github.com/nodejs/node/commit/5c4798d799)] - **http**: fix no\_proxy leading-dot suffix matching (Daijiro Wachi) [#62333](https://github.com/nodejs/node/pull/62333)
+* \[[`9f3bc70ae5`](https://github.com/nodejs/node/commit/9f3bc70ae5)] - **http**: cleanup pipeline queue (Robert Nagy) [#62534](https://github.com/nodejs/node/pull/62534)
+* \[[`aa1d8a9afc`](https://github.com/nodejs/node/commit/aa1d8a9afc)] - **(SEMVER-MINOR)** **http**: add req.signal to IncomingMessage (Akshat) [#62541](https://github.com/nodejs/node/pull/62541)
+* \[[`900dc758ff`](https://github.com/nodejs/node/commit/900dc758ff)] - **http2**: expose writable stream state on compat response (T) [#63003](https://github.com/nodejs/node/pull/63003)
+* \[[`b3bfe35912`](https://github.com/nodejs/node/commit/b3bfe35912)] - **inspector**: coerce key and value to string in webstorage events (Ali Hassan) [#62616](https://github.com/nodejs/node/pull/62616)
+* \[[`3dc3fb6ad8`](https://github.com/nodejs/node/commit/3dc3fb6ad8)] - **inspector**: return errors when CDP protocol event emission fails (Ryuhei Shima) [#62162](https://github.com/nodejs/node/pull/62162)
+* \[[`4f3f21bd7c`](https://github.com/nodejs/node/commit/4f3f21bd7c)] - **inspector**: auto collect webstorage data (Ryuhei Shima) [#62145](https://github.com/nodejs/node/pull/62145)
+* \[[`36cc04189d`](https://github.com/nodejs/node/commit/36cc04189d)] - **inspector**: initial support storage inspection (Ryuhei Shima) [#61139](https://github.com/nodejs/node/pull/61139)
+* \[[`1718bc3b9b`](https://github.com/nodejs/node/commit/1718bc3b9b)] - **inspector**: fix absolute URLs in network http (bugyaluwang) [#62955](https://github.com/nodejs/node/pull/62955)
+* \[[`97e32c7a74`](https://github.com/nodejs/node/commit/97e32c7a74)] - **lib**: avoid quadratic shift() in startup snapshot callback (Daijiro Wachi) [#62914](https://github.com/nodejs/node/pull/62914)
+* \[[`25d2e999de`](https://github.com/nodejs/node/commit/25d2e999de)] - **lib**: harden kKeyOps lookup with null prototype (Filip Skokan) [#62877](https://github.com/nodejs/node/pull/62877)
+* \[[`37d3913c8f`](https://github.com/nodejs/node/commit/37d3913c8f)] - **lib**: short-circuit WebIDL BufferSource SAB check (Filip Skokan) [#62833](https://github.com/nodejs/node/pull/62833)
+* \[[`430c69d25f`](https://github.com/nodejs/node/commit/430c69d25f)] - **lib**: use js-only implementation of `isDataView()` (René) [#62780](https://github.com/nodejs/node/pull/62780)
+* \[[`3ba0add6a0`](https://github.com/nodejs/node/commit/3ba0add6a0)] - **lib**: fix lint in internal/webstreams/util.js (Filip Skokan) [#62806](https://github.com/nodejs/node/pull/62806)
+* \[[`9b95c41398`](https://github.com/nodejs/node/commit/9b95c41398)] - **lib**: fix sequence argument handling in Blob constructor (Ms2ger) [#62179](https://github.com/nodejs/node/pull/62179)
+* \[[`314dacdbee`](https://github.com/nodejs/node/commit/314dacdbee)] - **lib**: improve Web Cryptography key validation ordering (Filip Skokan) [#62749](https://github.com/nodejs/node/pull/62749)
+* \[[`3d18162430`](https://github.com/nodejs/node/commit/3d18162430)] - **lib**: reject SharedArrayBuffer in web APIs per spec (Ali Hassan) [#62632](https://github.com/nodejs/node/pull/62632)
+* \[[`ada3ce879d`](https://github.com/nodejs/node/commit/ada3ce879d)] - **lib**: defer AbortSignal.any() following (sangwook) [#62367](https://github.com/nodejs/node/pull/62367)
+* \[[`b2981ec7eb`](https://github.com/nodejs/node/commit/b2981ec7eb)] - **meta**: bump actions/download-artifact from 8.0.0 to 8.0.1 (dependabot\[bot]) [#62549](https://github.com/nodejs/node/pull/62549)
+* \[[`7cd20667b5`](https://github.com/nodejs/node/commit/7cd20667b5)] - **meta**: bump github/codeql-action from 4.35.1 to 4.35.3 (dependabot\[bot]) [#63074](https://github.com/nodejs/node/pull/63074)
+* \[[`91a07cfe9f`](https://github.com/nodejs/node/commit/91a07cfe9f)] - **meta**: bump Mozilla-Actions/sccache-action from 0.0.9 to 0.0.10 (dependabot\[bot]) [#63073](https://github.com/nodejs/node/pull/63073)
+* \[[`09e17fe47c`](https://github.com/nodejs/node/commit/09e17fe47c)] - **meta**: add automation policy (Chengzhong Wu) [#62871](https://github.com/nodejs/node/pull/62871)
+* \[[`59e7fb7986`](https://github.com/nodejs/node/commit/59e7fb7986)] - **meta**: move VoltrexKeyva to emeritus (Matteo Collina) [#62895](https://github.com/nodejs/node/pull/62895)
+* \[[`1e2915cfa6`](https://github.com/nodejs/node/commit/1e2915cfa6)] - **meta**: bump peter-evans/create-pull-request from 8.1.0 to 8.1.1 (dependabot\[bot]) [#62845](https://github.com/nodejs/node/pull/62845)
+* \[[`0253c6e2be`](https://github.com/nodejs/node/commit/0253c6e2be)] - **meta**: bump step-security/harden-runner from 2.16.1 to 2.19.0 (dependabot\[bot]) [#62844](https://github.com/nodejs/node/pull/62844)
+* \[[`f503675b86`](https://github.com/nodejs/node/commit/f503675b86)] - **meta**: bump actions/setup-node from 6.3.0 to 6.4.0 (dependabot\[bot]) [#62842](https://github.com/nodejs/node/pull/62842)
+* \[[`5e14e4d26e`](https://github.com/nodejs/node/commit/5e14e4d26e)] - **meta**: broaden stale bot (Aviv Keller) [#62658](https://github.com/nodejs/node/pull/62658)
+* \[[`795db76f87`](https://github.com/nodejs/node/commit/795db76f87)] - **meta**: pass release version to release worker (flakey5) [#62777](https://github.com/nodejs/node/pull/62777)
+* \[[`ef384fe39f`](https://github.com/nodejs/node/commit/ef384fe39f)] - **meta**: add QUIC to CODEOWNERS (Tim Perry) [#62652](https://github.com/nodejs/node/pull/62652)
+* \[[`67e0ac568d`](https://github.com/nodejs/node/commit/67e0ac568d)] - **meta**: move Michael to emeritus (Michael Dawson) [#62536](https://github.com/nodejs/node/pull/62536)
+* \[[`5dad616393`](https://github.com/nodejs/node/commit/5dad616393)] - **meta**: populate apt list for slim runner in update-openssl workflow (René) [#62628](https://github.com/nodejs/node/pull/62628)
+* \[[`a869d25d8a`](https://github.com/nodejs/node/commit/a869d25d8a)] - **meta**: bump step-security/harden-runner from 2.15.0 to 2.16.1 (dependabot\[bot]) [#62550](https://github.com/nodejs/node/pull/62550)
+* \[[`769efc0403`](https://github.com/nodejs/node/commit/769efc0403)] - **meta**: bump actions/setup-node from 6.2.0 to 6.3.0 (dependabot\[bot]) [#62548](https://github.com/nodejs/node/pull/62548)
+* \[[`73fcc2b055`](https://github.com/nodejs/node/commit/73fcc2b055)] - **meta**: bump github/codeql-action from 4.32.4 to 4.35.1 (dependabot\[bot]) [#62547](https://github.com/nodejs/node/pull/62547)
+* \[[`6c001246fe`](https://github.com/nodejs/node/commit/6c001246fe)] - **meta**: bump codecov/codecov-action from 5.5.2 to 6.0.0 (dependabot\[bot]) [#62545](https://github.com/nodejs/node/pull/62545)
+* \[[`5ee40d6a03`](https://github.com/nodejs/node/commit/5ee40d6a03)] - **meta**: bump actions/cache from 5.0.3 to 5.0.4 (dependabot\[bot]) [#62543](https://github.com/nodejs/node/pull/62543)
+* \[[`ca16ad8a05`](https://github.com/nodejs/node/commit/ca16ad8a05)] - **meta**: require DCO signoff in commit message guidelines (James M Snell) [#62510](https://github.com/nodejs/node/pull/62510)
+* \[[`db9497fc41`](https://github.com/nodejs/node/commit/db9497fc41)] - **meta**: expand memory leak DoS criteria to all DoS (Joyee Cheung) [#62505](https://github.com/nodejs/node/pull/62505)
+* \[[`13b7d08b8d`](https://github.com/nodejs/node/commit/13b7d08b8d)] - **module**: remove duplicated checks from `_resolveFilename` (Antoine du Hamel) [#62729](https://github.com/nodejs/node/pull/62729)
+* \[[`6b53efb53a`](https://github.com/nodejs/node/commit/6b53efb53a)] - **module,win**: fix long subpath import (Stefan Stojanovic) [#62101](https://github.com/nodejs/node/pull/62101)
+* \[[`841dfbf6fc`](https://github.com/nodejs/node/commit/841dfbf6fc)] - **node-api**: update libuv ABI stability note (Chengzhong Wu) [#62789](https://github.com/nodejs/node/pull/62789)
+* \[[`01090f2aa1`](https://github.com/nodejs/node/commit/01090f2aa1)] - **node-api**: add napi\_create\_external\_sharedarraybuffer (Ben Noordhuis) [#62623](https://github.com/nodejs/node/pull/62623)
+* \[[`87443b4355`](https://github.com/nodejs/node/commit/87443b4355)] - **node-api**: execute tsfn finalizer after queue drains when aborted (Kevin Eady) [#61956](https://github.com/nodejs/node/pull/61956)
+* \[[`e95570c054`](https://github.com/nodejs/node/commit/e95570c054)] - **process**: handle rejections only when needed (Gürgün Dayıoğlu) [#62919](https://github.com/nodejs/node/pull/62919)
+* \[[`37d49f3219`](https://github.com/nodejs/node/commit/37d49f3219)] - **process**: optimize asyncHandledRejections by using FixedQueue (Gürgün Dayıoğlu) [#60854](https://github.com/nodejs/node/pull/60854)
+* \[[`f697c55e38`](https://github.com/nodejs/node/commit/f697c55e38)] - **quic**: add QuicEndpoint.listening & QuicStream.destroy() and tests (Tim Perry) [#62648](https://github.com/nodejs/node/pull/62648)
+* \[[`c128942b69`](https://github.com/nodejs/node/commit/c128942b69)] - **quic**: fixup token verification to handle zero expiration (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620)
+* \[[`abb881ec92`](https://github.com/nodejs/node/commit/abb881ec92)] - **quic**: support multiple ALPN negotiation (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620)
+* \[[`476926c2ad`](https://github.com/nodejs/node/commit/476926c2ad)] - **quic**: apply multiple TLS context improvements and SNI support (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620)
+* \[[`76d9c24b95`](https://github.com/nodejs/node/commit/76d9c24b95)] - **quic**: implement rapidhash for hashing improvements (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620)
+* \[[`08726cd43d`](https://github.com/nodejs/node/commit/08726cd43d)] - **quic**: move quic behind compile time flag (Matteo Collina) [#61444](https://github.com/nodejs/node/pull/61444)
+* \[[`ea4f19aaa7`](https://github.com/nodejs/node/commit/ea4f19aaa7)] - **quic**: use arena allocation for packets (James M Snell) [#62589](https://github.com/nodejs/node/pull/62589)
+* \[[`21e9239e2a`](https://github.com/nodejs/node/commit/21e9239e2a)] - **quic**: fixup linting/formatting issues (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387)
+* \[[`edeed4303b`](https://github.com/nodejs/node/commit/edeed4303b)] - **quic**: update http3 impl details (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387)
+* \[[`7f3a85e6aa`](https://github.com/nodejs/node/commit/7f3a85e6aa)] - **quic**: fix a handful of bugs and missing functionality (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387)
+* \[[`45c1ebddf8`](https://github.com/nodejs/node/commit/45c1ebddf8)] - **quic**: copy options.certs buffer instead of detaching (Chengzhong Wu) [#61403](https://github.com/nodejs/node/pull/61403)
+* \[[`a31a8ee680`](https://github.com/nodejs/node/commit/a31a8ee680)] - **quic**: reduce boilerplate and other minor cleanups (James M Snell) [#59342](https://github.com/nodejs/node/pull/59342)
+* \[[`3be70ff43a`](https://github.com/nodejs/node/commit/3be70ff43a)] - **quic**: multiple fixups and updates (James M Snell) [#59342](https://github.com/nodejs/node/pull/59342)
+* \[[`b91a93444c`](https://github.com/nodejs/node/commit/b91a93444c)] - **quic**: update more of the quic to the new compile guard (James M Snell) [#59342](https://github.com/nodejs/node/pull/59342)
+* \[[`ca0080c164`](https://github.com/nodejs/node/commit/ca0080c164)] - **quic**: few additional small comment edits in cid.h (James M Snell) [#59342](https://github.com/nodejs/node/pull/59342)
+* \[[`6553202d83`](https://github.com/nodejs/node/commit/6553202d83)] - **quic**: fixup NO\_ERROR macro conflict on windows (James M Snell) [#59381](https://github.com/nodejs/node/pull/59381)
+* \[[`6df1508ac2`](https://github.com/nodejs/node/commit/6df1508ac2)] - **quic**: fixup windows coverage compile error (James M Snell) [#59381](https://github.com/nodejs/node/pull/59381)
+* \[[`b2b0bf8b04`](https://github.com/nodejs/node/commit/b2b0bf8b04)] - **quic**: update the guard to check openssl version (James M Snell) [#59249](https://github.com/nodejs/node/pull/59249)
+* \[[`5556b154bd`](https://github.com/nodejs/node/commit/5556b154bd)] - **quic**: start re-enabling quic with openssl 3.5 (James M Snell) [#59249](https://github.com/nodejs/node/pull/59249)
+* \[[`2ca42c8263`](https://github.com/nodejs/node/commit/2ca42c8263)] - **repl**: keep reference count for `process.on('newListener')` (Anna Henningsen) [#61895](https://github.com/nodejs/node/pull/61895)
+* \[[`2f37f9177f`](https://github.com/nodejs/node/commit/2f37f9177f)] - **sqlite**: use OneByte for ASCII text and internalize col names (Ali Hassan) [#61954](https://github.com/nodejs/node/pull/61954)
+* \[[`3c96ae1b2f`](https://github.com/nodejs/node/commit/3c96ae1b2f)] - **sqlite**: add serialize() and deserialize() (Ali Hassan) [#62579](https://github.com/nodejs/node/pull/62579)
+* \[[`be4d2f3a4c`](https://github.com/nodejs/node/commit/be4d2f3a4c)] - **sqlite**: enable Percentile extension (Jurj Andrei George) [#61295](https://github.com/nodejs/node/pull/61295)
+* \[[`dafed453b2`](https://github.com/nodejs/node/commit/dafed453b2)] - **src**: clean up experimental flag variables (Antoine du Hamel) [#62759](https://github.com/nodejs/node/pull/62759)
+* \[[`dca1e6aeea`](https://github.com/nodejs/node/commit/dca1e6aeea)] - **src**: expose help texts into node-config-schema.json (Pietro Marchini) [#58680](https://github.com/nodejs/node/pull/58680)
+* \[[`28c4f44eb1`](https://github.com/nodejs/node/commit/28c4f44eb1)] - **src**: add permission support to config file (Marco Ippolito) [#60746](https://github.com/nodejs/node/pull/60746)
+* \[[`f49175b220`](https://github.com/nodejs/node/commit/f49175b220)] - **src**: fix small compile warning in quic/streams.cc (James M Snell) [#60118](https://github.com/nodejs/node/pull/60118)
+* \[[`c9d4a446d8`](https://github.com/nodejs/node/commit/c9d4a446d8)] - **src**: cleanup quic TransportParams class (James M Snell) [#59884](https://github.com/nodejs/node/pull/59884)
+* \[[`99bb02fd9e`](https://github.com/nodejs/node/commit/99bb02fd9e)] - **src**: swap dotenv and config file parsing order (Marco Ippolito) [#63035](https://github.com/nodejs/node/pull/63035)
+* \[[`ecb4d49b7b`](https://github.com/nodejs/node/commit/ecb4d49b7b)] - **src**: add missing \<cstdlib> for abort() declaration (Charles Kerr) [#63001](https://github.com/nodejs/node/pull/63001)
+* \[[`b6219b6362`](https://github.com/nodejs/node/commit/b6219b6362)] - **src**: fix crash in GetErrorSource() for invalid using syntax (semimikoh) [#62770](https://github.com/nodejs/node/pull/62770)
+* \[[`b5ca5ad4c5`](https://github.com/nodejs/node/commit/b5ca5ad4c5)] - **src**: simplify `TCPWrap::Connect` signature (Anna Henningsen) [#62929](https://github.com/nodejs/node/pull/62929)
+* \[[`ef7ffce7cf`](https://github.com/nodejs/node/commit/ef7ffce7cf)] - **src**: use DCHECK in AsyncWrap::MakeCallback instead emiting a warning (Gerhard Stöbich) [#62795](https://github.com/nodejs/node/pull/62795)
+* \[[`cd9890a5ab`](https://github.com/nodejs/node/commit/cd9890a5ab)] - **src**: fix MaybeStackBuffer char\_traits deprecation warning (om-ghante) [#62507](https://github.com/nodejs/node/pull/62507)
+* \[[`c70ff44aee`](https://github.com/nodejs/node/commit/c70ff44aee)] - **src**: use context-free V8 message column getters (René) [#62778](https://github.com/nodejs/node/pull/62778)
+* \[[`06c405f1d7`](https://github.com/nodejs/node/commit/06c405f1d7)] - **src**: coerce `spawnSync` args to string once (Antoine du Hamel) [#62633](https://github.com/nodejs/node/pull/62633)
+* \[[`6151999ad6`](https://github.com/nodejs/node/commit/6151999ad6)] - **src**: use stack allocation for small string encoding (Ali Hassan) [#62431](https://github.com/nodejs/node/pull/62431)
+* \[[`a71a4ac7a3`](https://github.com/nodejs/node/commit/a71a4ac7a3)] - **src**: add contextify interceptor debug logs (Chengzhong Wu) [#62460](https://github.com/nodejs/node/pull/62460)
+* \[[`ad9a2909c2`](https://github.com/nodejs/node/commit/ad9a2909c2)] - **src**: workaround AIX libc++ std::filesystem bug (Richard Lau) [#62788](https://github.com/nodejs/node/pull/62788)
+* \[[`7792f1ae47`](https://github.com/nodejs/node/commit/7792f1ae47)] - **stream**: copyedit `webstreams/adapter.js` (Antoine du Hamel) [#63034](https://github.com/nodejs/node/pull/63034)
+* \[[`1397d8ce5c`](https://github.com/nodejs/node/commit/1397d8ce5c)] - **stream**: remove duplicated utility (Antoine du Hamel) [#63031](https://github.com/nodejs/node/pull/63031)
+* \[[`ff86b1d64f`](https://github.com/nodejs/node/commit/ff86b1d64f)] - **stream**: simplify `setPromiseHandled` utility (Antoine du Hamel) [#63032](https://github.com/nodejs/node/pull/63032)
+* \[[`24a078149a`](https://github.com/nodejs/node/commit/24a078149a)] - **stream**: validate ReadableStream.from iterator objects (Daeyeon Jeong) [#62911](https://github.com/nodejs/node/pull/62911)
+* \[[`cfb1fa9680`](https://github.com/nodejs/node/commit/cfb1fa9680)] - **stream**: reject duplicate nested transferables (Daeyeon Jeong) [#62831](https://github.com/nodejs/node/pull/62831)
+* \[[`d0c913758a`](https://github.com/nodejs/node/commit/d0c913758a)] - **stream**: ensuring cross-destruction in \_duplexify to prevent leaks (Daijiro Wachi) [#62824](https://github.com/nodejs/node/pull/62824)
+* \[[`978f5c15d7`](https://github.com/nodejs/node/commit/978f5c15d7)] - **stream**: simplify `readableStreamFromIterable` (Antoine du Hamel) [#62651](https://github.com/nodejs/node/pull/62651)
+* \[[`3527646ba5`](https://github.com/nodejs/node/commit/3527646ba5)] - **stream**: fix nested compose error propagation (Matteo Collina) [#62556](https://github.com/nodejs/node/pull/62556)
+* \[[`dfb9edef4f`](https://github.com/nodejs/node/commit/dfb9edef4f)] - **stream**: allow shared array buffer sources in writable webstream adapter (René) [#62163](https://github.com/nodejs/node/pull/62163)
+* \[[`f00cdab627`](https://github.com/nodejs/node/commit/f00cdab627)] - **stream**: simplify `createPromiseCallback` (Antoine du Hamel) [#62650](https://github.com/nodejs/node/pull/62650)
+* \[[`3ed783535f`](https://github.com/nodejs/node/commit/3ed783535f)] - **stream**: fix writev unhandled rejection in fromWeb (sangwook) [#62297](https://github.com/nodejs/node/pull/62297)
+* \[[`29b196694c`](https://github.com/nodejs/node/commit/29b196694c)] - **stream**: noop pause/resume on destroyed streams (Robert Nagy) [#62557](https://github.com/nodejs/node/pull/62557)
+* \[[`d73dbb9fc8`](https://github.com/nodejs/node/commit/d73dbb9fc8)] - **stream**: refactor duplexify to be less suceptible to prototype pollution (Antoine du Hamel) [#62559](https://github.com/nodejs/node/pull/62559)
+* \[[`6f37f7e240`](https://github.com/nodejs/node/commit/6f37f7e240)] - **(SEMVER-MINOR)** **stream**: propagate destruction in duplexPair (Ahmed Elhor) [#61098](https://github.com/nodejs/node/pull/61098)
+* \[[`b8816580e9`](https://github.com/nodejs/node/commit/b8816580e9)] - **test**: generate `localstorage.db` in a temp dir (Chengzhong Wu) [#62660](https://github.com/nodejs/node/pull/62660)
+* \[[`31a863fd29`](https://github.com/nodejs/node/commit/31a863fd29)] - **test**: update WPT for url to 258f285de0 (Node.js GitHub Bot) [#63087](https://github.com/nodejs/node/pull/63087)
+* \[[`d0d19bd8e3`](https://github.com/nodejs/node/commit/d0d19bd8e3)] - **test**: update WPT for streams to f8f26a372f (Node.js GitHub Bot) [#62864](https://github.com/nodejs/node/pull/62864)
+* \[[`f50ac5bc78`](https://github.com/nodejs/node/commit/f50ac5bc78)] - **test**: improve config-file permission test coverage (Rafael Gonzaga) [#60929](https://github.com/nodejs/node/pull/60929)
+* \[[`a0f90000f4`](https://github.com/nodejs/node/commit/a0f90000f4)] - **test**: export isRiscv64 from common module (Jamie Magee) [#62609](https://github.com/nodejs/node/pull/62609)
+* \[[`da4dd8646f`](https://github.com/nodejs/node/commit/da4dd8646f)] - **test**: normalize known inspector crash as completion (Joyee Cheung) [#62851](https://github.com/nodejs/node/pull/62851)
+* \[[`b7fdd94a4c`](https://github.com/nodejs/node/commit/b7fdd94a4c)] - **test**: account for RFC 7919 FFDHE negotiation in OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`375a993aaf`](https://github.com/nodejs/node/commit/375a993aaf)] - **test**: skip tls-deprecated secp256k1 on OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`698d8287d1`](https://github.com/nodejs/node/commit/698d8287d1)] - **test**: use an always invalid cipher and cover OpenSSL 4.0 behaviours (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`036bc6f300`](https://github.com/nodejs/node/commit/036bc6f300)] - **test**: use valid DER OCSP responses (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`3aa9938da8`](https://github.com/nodejs/node/commit/3aa9938da8)] - **test**: skip test-tls-error-stack when engines are unsupported (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`947f1ae246`](https://github.com/nodejs/node/commit/947f1ae246)] - **test**: accept renamed OpenSSL 4.0 error code and reason (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`afdd355622`](https://github.com/nodejs/node/commit/afdd355622)] - **test**: update test/addons/openssl-binding for OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805)
+* \[[`8637524a99`](https://github.com/nodejs/node/commit/8637524a99)] - **test**: mark test-snapshot-reproducible flaky (Filip Skokan) [#62808](https://github.com/nodejs/node/pull/62808)
+* \[[`c22d34134b`](https://github.com/nodejs/node/commit/c22d34134b)] - **test**: check contextify contextual store behavior in strict mode (René) [#62571](https://github.com/nodejs/node/pull/62571)
+* \[[`0b4e0d3c94`](https://github.com/nodejs/node/commit/0b4e0d3c94)] - **test**: update tls junk data error expectations (Filip Skokan) [#62629](https://github.com/nodejs/node/pull/62629)
+* \[[`85d83c2cdb`](https://github.com/nodejs/node/commit/85d83c2cdb)] - **test**: ensure WPT report is in out/wpt (Filip Skokan) [#62637](https://github.com/nodejs/node/pull/62637)
+* \[[`9e21711c60`](https://github.com/nodejs/node/commit/9e21711c60)] - **test**: improve WPT runner summary (Filip Skokan) [#62636](https://github.com/nodejs/node/pull/62636)
+* \[[`e04e2c9ac1`](https://github.com/nodejs/node/commit/e04e2c9ac1)] - **test**: skip url WPT subtests instead of modifying test script (Filip Skokan) [#62635](https://github.com/nodejs/node/pull/62635)
+* \[[`7b1211f88c`](https://github.com/nodejs/node/commit/7b1211f88c)] - **test**: capture negative utimes mtime at call time (Yuya Inoue) [#62490](https://github.com/nodejs/node/pull/62490)
+* \[[`f1a6e9fcc7`](https://github.com/nodejs/node/commit/f1a6e9fcc7)] - **test**: allow skipping individual WPT subtests (Filip Skokan) [#62517](https://github.com/nodejs/node/pull/62517)
+* \[[`23f927542e`](https://github.com/nodejs/node/commit/23f927542e)] - **test**: use on-disk fixture for test-npm-install (Joyee Cheung) [#62584](https://github.com/nodejs/node/pull/62584)
+* \[[`4739c45879`](https://github.com/nodejs/node/commit/4739c45879)] - **test**: update WPT for url to 7a3645b79a (Node.js GitHub Bot) [#62591](https://github.com/nodejs/node/pull/62591)
+* \[[`f68189b839`](https://github.com/nodejs/node/commit/f68189b839)] - **test\_runner**: add `testId` to test events (Moshe Atlow) [#62772](https://github.com/nodejs/node/pull/62772)
+* \[[`5c2770446e`](https://github.com/nodejs/node/commit/5c2770446e)] - **test\_runner**: publish to TracingChannel for OTel instrumentation (Moshe Atlow) [#62502](https://github.com/nodejs/node/pull/62502)
+* \[[`d14029be7f`](https://github.com/nodejs/node/commit/d14029be7f)] - **(SEMVER-MINOR)** **test\_runner**: support test order randomization (Pietro Marchini) [#61747](https://github.com/nodejs/node/pull/61747)
+* \[[`3f74a58979`](https://github.com/nodejs/node/commit/3f74a58979)] - **test\_runner**: update node-config-schema (Pietro Marchini) [#58680](https://github.com/nodejs/node/pull/58680)
+* \[[`60c83f6199`](https://github.com/nodejs/node/commit/60c83f6199)] - **test\_runner**: fix failing suite hooks when marked with `todo` (Moshe Atlow) [#63097](https://github.com/nodejs/node/pull/63097)
+* \[[`d142c584cd`](https://github.com/nodejs/node/commit/d142c584cd)] - **(SEMVER-MINOR)** **test\_runner**: align mock timeout api (sangwook) [#62820](https://github.com/nodejs/node/pull/62820)
+* \[[`3e72065ed6`](https://github.com/nodejs/node/commit/3e72065ed6)] - **test\_runner**: fix suite rerun edge case (Moshe Atlow) [#62860](https://github.com/nodejs/node/pull/62860)
+* \[[`01a9552585`](https://github.com/nodejs/node/commit/01a9552585)] - **(SEMVER-MINOR)** **test\_runner**: add mock-timers support for AbortSignal.timeout (DeveloperViraj) [#60751](https://github.com/nodejs/node/pull/60751)
+* \[[`dd43efffa6`](https://github.com/nodejs/node/commit/dd43efffa6)] - **test\_runner**: add passed, attempt, and diagnostic to SuiteContext (Moshe Atlow) [#62504](https://github.com/nodejs/node/pull/62504)
+* \[[`a12dc445cc`](https://github.com/nodejs/node/commit/a12dc445cc)] - **tools**: add a check for clean git tree after tests (Antoine du Hamel) [#62661](https://github.com/nodejs/node/pull/62661)
+* \[[`5b49178375`](https://github.com/nodejs/node/commit/5b49178375)] - **tools**: use LTS Node.js in notify-on-push workflow (Nenad Spasenic) [#63084](https://github.com/nodejs/node/pull/63084)
+* \[[`5a93bde5bb`](https://github.com/nodejs/node/commit/5a93bde5bb)] - **tools**: update gr2m/create-or-update-pull-request-action to v1.10.1 (Mike McCready) [#63065](https://github.com/nodejs/node/pull/63065)
+* \[[`b133019d19`](https://github.com/nodejs/node/commit/b133019d19)] - **tools**: simplify `update-undici.sh` (Antoine du Hamel) [#63044](https://github.com/nodejs/node/pull/63044)
+* \[[`04d3538074`](https://github.com/nodejs/node/commit/04d3538074)] - **tools**: do not run `test-linux` on unrelated tools changes (Antoine du Hamel) [#63037](https://github.com/nodejs/node/pull/63037)
+* \[[`4d396ac4a5`](https://github.com/nodejs/node/commit/4d396ac4a5)] - **tools**: bump the eslint group in /tools/eslint with 4 updates (dependabot\[bot]) [#62848](https://github.com/nodejs/node/pull/62848)
+* \[[`9354bf40e7`](https://github.com/nodejs/node/commit/9354bf40e7)] - **tools**: update gyp-next to 0.22.1 (Node.js GitHub Bot) [#62961](https://github.com/nodejs/node/pull/62961)
+* \[[`c23db1ca85`](https://github.com/nodejs/node/commit/c23db1ca85)] - **tools**: fix commit linter for semver-major release proposals (Antoine du Hamel) [#62993](https://github.com/nodejs/node/pull/62993)
+* \[[`6e097ee3f1`](https://github.com/nodejs/node/commit/6e097ee3f1)] - **tools**: consolidate and simplify .editorconfig deps section (Daijiro Wachi) [#62887](https://github.com/nodejs/node/pull/62887)
+* \[[`a47ea6d6ea`](https://github.com/nodejs/node/commit/a47ea6d6ea)] - **tools**: set bot as author of tools-deps-update PRs (Antoine du Hamel) [#62856](https://github.com/nodejs/node/pull/62856)
+* \[[`00e86f0471`](https://github.com/nodejs/node/commit/00e86f0471)] - **tools**: bump brace-expansion from 5.0.4 to 5.0.5 in /tools/eslint (dependabot\[bot]) [#62458](https://github.com/nodejs/node/pull/62458)
+* \[[`cd7e262e75`](https://github.com/nodejs/node/commit/cd7e262e75)] - **tools**: bump brace-expansion in /tools/clang-format (dependabot\[bot]) [#62467](https://github.com/nodejs/node/pull/62467)
+* \[[`bfc1319bc8`](https://github.com/nodejs/node/commit/bfc1319bc8)] - **tools**: exclude @node-core/doc-kit from dependabot cooldown (Levi Zim) [#62775](https://github.com/nodejs/node/pull/62775)
+* \[[`a932fbd10b`](https://github.com/nodejs/node/commit/a932fbd10b)] - **tools**: re-enable undici WPTs in daily wpt.fyi job (Filip Skokan) [#62677](https://github.com/nodejs/node/pull/62677)
+* \[[`f7bd9e3055`](https://github.com/nodejs/node/commit/f7bd9e3055)] - **tools**: update gyp-next to 0.22.0 (Node.js GitHub Bot) [#62697](https://github.com/nodejs/node/pull/62697)
+* \[[`c400d46d87`](https://github.com/nodejs/node/commit/c400d46d87)] - **tools**: improve backport review script (Antoine du Hamel) [#62573](https://github.com/nodejs/node/pull/62573)
+* \[[`be23b75814`](https://github.com/nodejs/node/commit/be23b75814)] - **tools**: improve output for unexpected passes in WTP tests (Antoine du Hamel) [#62587](https://github.com/nodejs/node/pull/62587)
+* \[[`609c013ece`](https://github.com/nodejs/node/commit/609c013ece)] - **tools**: revert OpenSSL update workflow to ubuntu-latest (Richard Lau) [#62627](https://github.com/nodejs/node/pull/62627)
+* \[[`81bac1ebfd`](https://github.com/nodejs/node/commit/81bac1ebfd)] - **tools**: bump the eslint group in /tools/eslint with 2 updates (dependabot\[bot]) [#62552](https://github.com/nodejs/node/pull/62552)
+* \[[`1fee26522d`](https://github.com/nodejs/node/commit/1fee26522d)] - **tools**: allow triagers to queue a PR for CI until it's reviewed (Antoine du Hamel) [#62524](https://github.com/nodejs/node/pull/62524)
+* \[[`332088f929`](https://github.com/nodejs/node/commit/332088f929)] - **tools**: do not run `commit-lint` on release proposals (Antoine du Hamel) [#62523](https://github.com/nodejs/node/pull/62523)
+* \[[`9a25fc8a4d`](https://github.com/nodejs/node/commit/9a25fc8a4d)] - **url**: process crash via malformed UNC hostname in pathToFileURL() (Nicola Del Gobbo) [#62574](https://github.com/nodejs/node/pull/62574)
+* \[[`7bd08ff60a`](https://github.com/nodejs/node/commit/7bd08ff60a)] - **url**: optimize URLSearchParams set/delete duplicate handling (Gürgün Dayıoğlu) [#62266](https://github.com/nodejs/node/pull/62266)
+* \[[`2d636388fa`](https://github.com/nodejs/node/commit/2d636388fa)] - **url**: align default argument handling for URLPattern with webidl (Filip Skokan) [#62719](https://github.com/nodejs/node/pull/62719)
+* \[[`00705a459a`](https://github.com/nodejs/node/commit/00705a459a)] - **(SEMVER-MINOR)** **util**: colorize text with hex colors (Guilherme Araújo) [#61556](https://github.com/nodejs/node/pull/61556)
+* \[[`0e2adb3e45`](https://github.com/nodejs/node/commit/0e2adb3e45)] - **watch**: track worker entry files in watch mode (SudhansuBandha) [#62368](https://github.com/nodejs/node/pull/62368)
+* \[[`c58fe38211`](https://github.com/nodejs/node/commit/c58fe38211)] - **watch**: fix --env-file-if-exists crashing on linux if the file is missing (Efe) [#61870](https://github.com/nodejs/node/pull/61870)
+
 <a id="24.15.0"></a>
 
 ## 2026-04-15, Version 24.15.0 'Krypton' (LTS), @aduh95

From d92ee51aa6dc44c7026948514ff058913b9dfb75 Mon Sep 17 00:00:00 2001
From: Chengzhong Wu <cwu631@bloomberg.net>
Date: Thu, 21 May 2026 09:50:23 -0400
Subject: [PATCH 37/83] src: expose `node::RegisterContext` to make a node
 managed context

Signed-off-by: Chengzhong Wu <cwu631@bloomberg.net>
PR-URL: https://github.com/nodejs/node/pull/62322
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
---
 src/api/environment.cc                        | 13 ++++
 src/env.h                                     |  2 +
 src/node.h                                    | 14 ++++
 test/addons/new-context-inspector/binding.cc  | 69 +++++++++++++++++++
 test/addons/new-context-inspector/binding.gyp |  9 +++
 .../new-context-inspector/test-inspector.js   | 51 ++++++++++++++
 test/addons/new-context-inspector/test.js     | 18 +++++
 7 files changed, 176 insertions(+)
 create mode 100644 test/addons/new-context-inspector/binding.cc
 create mode 100644 test/addons/new-context-inspector/binding.gyp
 create mode 100644 test/addons/new-context-inspector/test-inspector.js
 create mode 100644 test/addons/new-context-inspector/test.js

diff --git a/src/api/environment.cc b/src/api/environment.cc
index 25657d99bddaa3..c3fd1e58373516 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -2,6 +2,7 @@
 #if HAVE_OPENSSL
 #include "crypto/crypto_util.h"
 #endif  // HAVE_OPENSSL
+#include "env.h"
 #include "env_properties.h"
 #include "node.h"
 #include "node_builtins.h"
@@ -1053,6 +1054,18 @@ Maybe<bool> InitializeContext(Local<Context> context) {
   return Just(true);
 }
 
+void RegisterContext(Environment* env,
+                     v8::Local<v8::Context> context,
+                     std::string_view name,
+                     std::string_view origin) {
+  ContextInfo info{std::string(name), std::string(origin)};
+  env->AssignToContext(context, nullptr, info);
+}
+
+void UnregisterContext(Environment* env, v8::Local<v8::Context> context) {
+  env->UnassignFromContext(context);
+}
+
 uv_loop_t* GetCurrentEventLoop(Isolate* isolate) {
   HandleScope handle_scope(isolate);
   Local<Context> context = isolate->GetCurrentContext();
diff --git a/src/env.h b/src/env.h
index 616f6e7d04109a..61512d9494ff61 100644
--- a/src/env.h
+++ b/src/env.h
@@ -257,6 +257,8 @@ class NODE_EXTERN_PRIVATE IsolateData : public MemoryRetainer {
 
 struct ContextInfo {
   explicit ContextInfo(const std::string& name) : name(name) {}
+  ContextInfo(const std::string& name, const std::string& origin)
+      : name(name), origin(origin) {}
   const std::string name;
   std::string origin;
   bool is_default = false;
diff --git a/src/node.h b/src/node.h
index eba7b8698187b1..e25fe19c9ab30c 100644
--- a/src/node.h
+++ b/src/node.h
@@ -563,6 +563,8 @@ NODE_EXTERN v8::Isolate* NewIsolate(
     const IsolateSettings& settings = {});
 
 // Creates a new context with Node.js-specific tweaks.
+// Call `RegisterContext` after the context been created to register
+// the context with Node.js specific setups like the inspector.
 NODE_EXTERN v8::Local<v8::Context> NewContext(
     v8::Isolate* isolate,
     v8::Local<v8::ObjectTemplate> object_template =
@@ -572,6 +574,18 @@ NODE_EXTERN v8::Local<v8::Context> NewContext(
 // Return value indicates success of operation
 NODE_EXTERN v8::Maybe<bool> InitializeContext(v8::Local<v8::Context> context);
 
+// Associate the context with the given Environment. This registers the context
+// as known to Node.js, makes it available to the inspector. This also registers
+// Node.js promise hooks on the context.
+NODE_EXTERN void RegisterContext(Environment* env,
+                                 v8::Local<v8::Context> context,
+                                 std::string_view name = "",
+                                 std::string_view origin = "");
+// Unregister the context. Call this when the embedder finished all work with
+// this context.
+NODE_EXTERN void UnregisterContext(Environment* env,
+                                   v8::Local<v8::Context> context);
+
 // If `platform` is passed, it will be used to register new Worker instances.
 // It can be `nullptr`, in which case creating new Workers inside of
 // Environments that use this `IsolateData` will not work.
diff --git a/test/addons/new-context-inspector/binding.cc b/test/addons/new-context-inspector/binding.cc
new file mode 100644
index 00000000000000..b5a025b18d0df6
--- /dev/null
+++ b/test/addons/new-context-inspector/binding.cc
@@ -0,0 +1,69 @@
+#include <node.h>
+#include <v8.h>
+
+namespace {
+
+using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Script;
+using v8::String;
+using v8::Value;
+
+void MakeContext(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = Isolate::GetCurrent();
+  HandleScope handle_scope(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  node::Environment* env = node::GetCurrentEnvironment(context);
+  assert(env);
+
+  // Create a new context with Node.js-specific setup.
+  v8::MaybeLocal<Context> maybe_context = node::NewContext(isolate);
+  v8::Local<Context> new_context;
+  if (!maybe_context.ToLocal(&new_context)) {
+    return;
+  }
+  node::RegisterContext(env, new_context, "Addon Context", "addon://about");
+
+  // Return the global proxy object.
+  args.GetReturnValue().Set(new_context->Global());
+}
+
+void RunInContext(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = Isolate::GetCurrent();
+  HandleScope handle_scope(isolate);
+  assert(args.Length() == 2);
+
+  assert(args[0]->IsObject());
+  Local<Object> global_proxy = args[0].As<Object>();
+  v8::MaybeLocal<Context> maybe_context = global_proxy->GetCreationContext();
+  v8::Local<Context> new_context;
+  if (!maybe_context.ToLocal(&new_context)) {
+    return;
+  }
+  Context::Scope context_scope(new_context);
+
+  assert(args[1]->IsString());
+  Local<String> source = args[1].As<String>();
+  Local<Script> script;
+  Local<Value> result;
+
+  if (Script::Compile(new_context, source).ToLocal(&script) &&
+      script->Run(new_context).ToLocal(&result)) {
+    args.GetReturnValue().Set(result);
+  }
+}
+
+void Initialize(Local<Object> exports,
+                Local<Value> module,
+                Local<Context> context) {
+  NODE_SET_METHOD(exports, "makeContext", MakeContext);
+  NODE_SET_METHOD(exports, "runInContext", RunInContext);
+}
+
+}  // anonymous namespace
+
+NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Initialize)
diff --git a/test/addons/new-context-inspector/binding.gyp b/test/addons/new-context-inspector/binding.gyp
new file mode 100644
index 00000000000000..2eb456719623b9
--- /dev/null
+++ b/test/addons/new-context-inspector/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'sources': ['binding.cc'],
+      'includes': ['../common.gypi'],
+    },
+  ]
+}
diff --git a/test/addons/new-context-inspector/test-inspector.js b/test/addons/new-context-inspector/test-inspector.js
new file mode 100644
index 00000000000000..18a3bf4ea9dc49
--- /dev/null
+++ b/test/addons/new-context-inspector/test-inspector.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('node:assert');
+const { once } = require('node:events');
+const { Session } = require('node:inspector');
+
+const binding = require(`./build/${common.buildType}/binding`);
+
+const session = new Session();
+session.connect();
+
+(async function() {
+  const mainContextPromise =
+      once(session, 'Runtime.executionContextCreated');
+  session.post('Runtime.enable', assert.ifError);
+  await mainContextPromise;
+
+  // Addon-created context should be reported to the inspector.
+  {
+    const addonContextPromise =
+        once(session, 'Runtime.executionContextCreated');
+
+    const ctx = binding.makeContext();
+    const result = binding.runInContext(ctx, '1 + 1');
+    assert.strictEqual(result, 2);
+
+    const { 0: contextCreated } = await addonContextPromise;
+    const { name, origin, auxData } = contextCreated.params.context;
+    assert.strictEqual(name, 'Addon Context',
+                       JSON.stringify(contextCreated));
+    assert.strictEqual(origin, 'addon://about',
+                       JSON.stringify(contextCreated));
+    assert.strictEqual(auxData.isDefault, false,
+                       JSON.stringify(contextCreated));
+  }
+
+  // `debugger` statement should pause in addon-created context.
+  {
+    session.post('Debugger.enable', assert.ifError);
+
+    const pausedPromise = once(session, 'Debugger.paused');
+    const ctx = binding.makeContext();
+    binding.runInContext(ctx, 'debugger');
+    await pausedPromise;
+
+    session.post('Debugger.resume');
+  }
+})().then(common.mustCall());
diff --git a/test/addons/new-context-inspector/test.js b/test/addons/new-context-inspector/test.js
new file mode 100644
index 00000000000000..bf0f7268281a01
--- /dev/null
+++ b/test/addons/new-context-inspector/test.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+
+const binding = require(`./build/${common.buildType}/binding`);
+
+// This verifies that the addon-created context has an independent
+// global object.
+{
+  const ctx = binding.makeContext();
+  const result = binding.runInContext(ctx, `
+  globalThis.foo = 'bar';
+  foo;
+  `);
+  assert.strictEqual(result, 'bar');
+  assert.strictEqual(globalThis.foo, undefined);
+}

From 9fc42e325588f521635d6137c88b9718d27c2e1f Mon Sep 17 00:00:00 2001
From: Yuya Inoue <65857152+inoway46@users.noreply.github.com>
Date: Fri, 22 May 2026 01:05:33 +0900
Subject: [PATCH 38/83] test: wait for ok before initial break after restart

Signed-off-by: inoway46 <inoueyuya416@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/62807
Refs: https://github.com/nodejs/node/issues/61762
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/parallel/test-debugger-run-after-quit-restart.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/parallel/test-debugger-run-after-quit-restart.js b/test/parallel/test-debugger-run-after-quit-restart.js
index 397c25cceaff65..d81d3890bcd655 100644
--- a/test/parallel/test-debugger-run-after-quit-restart.js
+++ b/test/parallel/test-debugger-run-after-quit-restart.js
@@ -42,6 +42,7 @@ const path = require('path');
       assert.match(cli.output, /Use `run` to start the app again/);
     })
     .then(() => cli.command('run'))
+    .then(() => cli.waitFor(/ ok\n/))
     .then(() => cli.waitForInitialBreak())
     .then(() => cli.waitForPrompt())
     .then(() => {
@@ -58,9 +59,9 @@ const path = require('path');
       );
     })
     .then(() => cli.command('restart'))
-    .then(() => cli.waitFor(/Debugger attached\./))
-    .then(() => cli.waitForPrompt())
+    .then(() => cli.waitFor(/ ok\n/))
     .then(() => cli.waitForInitialBreak())
+    .then(() => cli.waitForPrompt())
     .then(() => {
       assert.deepStrictEqual(
         cli.breakInfo,
@@ -74,6 +75,7 @@ const path = require('path');
       assert.match(cli.output, /Use `run` to start the app again/);
     })
     .then(() => cli.command('run'))
+    .then(() => cli.waitFor(/ ok\n/))
     .then(() => cli.waitForInitialBreak())
     .then(() => cli.waitForPrompt())
     .then(() => {

From 7e8641a411261b1aeb1a26e5670671c009e97f9f Mon Sep 17 00:00:00 2001
From: Daijiro Wachi <daijiro.wachi@gmail.com>
Date: Fri, 22 May 2026 01:06:04 +0900
Subject: [PATCH 39/83] doc: fix typo in deprecations

Signed-off-by: Daijiro Wachi <daijiro.wachi@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63434
Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
---
 doc/api/deprecations.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 6e4f4de2f144a7..6776c790d0a433 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -810,7 +810,7 @@ changes:
 Type: Revoked
 
 The [`events.listenerCount(emitter, eventName)`][] API was deprecated, as it
-provided identical fuctionality to [`emitter.listenerCount(eventName)`][]. The
+provided identical functionality to [`emitter.listenerCount(eventName)`][]. The
 deprecation was revoked because this function has been repurposed to also
 accept {EventTarget} arguments.
 

From e6e670015c625d4188b37e4499c890318741af13 Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Thu, 21 May 2026 19:06:26 +0300
Subject: [PATCH 40/83] test_runner: add parentId to test events with testId

Signed-off-by: Moshe Atlow <moshe@atlow.co.il>
PR-URL: https://github.com/nodejs/node/pull/63435
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 doc/api/test.md                          | 21 +++++++++++++++++++++
 lib/internal/test_runner/test.js         | 18 ++++++++++--------
 lib/internal/test_runner/tests_stream.js | 18 ++++++++++++------
 3 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index 19b7e87e099221..2d38f136f28332 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -3437,6 +3437,9 @@ added:
   - v18.9.0
   - v16.19.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63435
+    description: Added `parentId` to test events that carry a `testId`.
   - version:
     - v20.0.0
     - v19.9.0
@@ -3524,6 +3527,9 @@ Emitted when code coverage is enabled and all tests have completed.
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
@@ -3550,6 +3556,9 @@ The corresponding declaration ordered events are `'test:pass'` and `'test:fail'`
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
@@ -3594,6 +3603,9 @@ defined.
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
@@ -3623,6 +3635,9 @@ Emitted when a test is enqueued for execution.
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
@@ -3685,6 +3700,9 @@ since the parent runner only knows about file-level tests. When using
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
@@ -3727,6 +3745,9 @@ defined.
     `undefined` if the test was run through the REPL.
   * `name` {string} The test name.
   * `nesting` {number} The nesting level of the test.
+  * `parentId` {number|undefined} The `testId` of the enclosing test, or
+    `undefined` for top-level tests. Lets custom reporters track lineage
+    when concurrent siblings at the same nesting level interleave.
   * `tags` {string\[]} The flattened lowercased tags declared on the test
     and its ancestor suites, in declaration order. Empty for untagged tests.
     See [Test tags][].
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index cae309ffc23938..7210ff38f2b518 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -955,7 +955,7 @@ class Test extends AsyncResource {
       const deferred = this.dequeuePendingSubtest();
       const test = deferred.test;
       this.assignReportOrder(test);
-      test.reporter.dequeue(test.nesting, test.loc, test.name, this.reportedType, test.testId, test.tags);
+      test.reporter.dequeue(test.nesting, test.loc, test.name, this.reportedType, test.testId, this.testId, test.tags);
       await test.run();
       deferred.resolve();
     }
@@ -1212,7 +1212,8 @@ class Test extends AsyncResource {
     // it. Otherwise, return a Promise to the caller and mark the test as
     // pending for later execution.
     this.parent.unfinishedSubtests.add(this);
-    this.reporter.enqueue(this.nesting, this.loc, this.name, this.reportedType, this.testId, this.tags);
+    this.reporter.enqueue(this.nesting, this.loc, this.name, this.reportedType,
+                          this.testId, this.parent?.testId, this.tags);
     if (this.root.harness.buildPromise || !this.parent.hasConcurrency()) {
       const deferred = PromiseWithResolvers();
 
@@ -1235,7 +1236,8 @@ class Test extends AsyncResource {
     }
 
     this.parent.assignReportOrder(this);
-    this.reporter.dequeue(this.nesting, this.loc, this.name, this.reportedType, this.testId, this.tags);
+    this.reporter.dequeue(this.nesting, this.loc, this.name, this.reportedType,
+                          this.testId, this.parent?.testId, this.tags);
     return this.run();
   }
 
@@ -1509,7 +1511,7 @@ class Test extends AsyncResource {
         this.testNumber ||= ++this.parent.outputSubtestCount;
         this.reporter.complete(
           this.nesting, this.loc, this.testNumber, this.name,
-          report.details, report.directive, this.testId, this.tags,
+          report.details, report.directive, this.testId, this.parent?.testId, this.tags,
         );
         this.parent.activeSubtests--;
       }
@@ -1665,12 +1667,12 @@ class Test extends AsyncResource {
     if (this.passed) {
       this.reporter.ok(
         this.nesting, this.loc, this.testNumber, this.name,
-        report.details, report.directive, this.testId, this.tags,
+        report.details, report.directive, this.testId, this.parent?.testId, this.tags,
       );
     } else {
       this.reporter.fail(
         this.nesting, this.loc, this.testNumber, this.name,
-        report.details, report.directive, this.testId, this.tags,
+        report.details, report.directive, this.testId, this.parent?.testId, this.tags,
       );
     }
 
@@ -1685,7 +1687,7 @@ class Test extends AsyncResource {
     }
     this.#reportedSubtest = true;
     this.parent.reportStarted();
-    this.reporter.start(this.nesting, this.loc, this.name, this.testId, this.tags);
+    this.reporter.start(this.nesting, this.loc, this.name, this.testId, this.parent?.testId, this.tags);
   }
 
   clearExecutionTime() {
@@ -1747,7 +1749,7 @@ class TestHook extends Test {
         __proto__: null,
         duration_ms: this.duration(),
         error,
-      }, undefined, undefined, parent.tags);
+      }, undefined, undefined, undefined, parent.tags);
     }
   }
 }
diff --git a/lib/internal/test_runner/tests_stream.js b/lib/internal/test_runner/tests_stream.js
index 622e6372fa1d13..8be33f90dfa0f2 100644
--- a/lib/internal/test_runner/tests_stream.js
+++ b/lib/internal/test_runner/tests_stream.js
@@ -35,13 +35,14 @@ class TestsStream extends Readable {
     }
   }
 
-  fail(nesting, loc, testNumber, name, details, directive, testId, tags) {
+  fail(nesting, loc, testNumber, name, details, directive, testId, parentId, tags) {
     this[kEmitMessage]('test:fail', {
       __proto__: null,
       name,
       nesting,
       testNumber,
       testId,
+      parentId,
       details,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
@@ -49,13 +50,14 @@ class TestsStream extends Readable {
     });
   }
 
-  ok(nesting, loc, testNumber, name, details, directive, testId, tags) {
+  ok(nesting, loc, testNumber, name, details, directive, testId, parentId, tags) {
     this[kEmitMessage]('test:pass', {
       __proto__: null,
       name,
       nesting,
       testNumber,
       testId,
+      parentId,
       details,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
@@ -63,13 +65,14 @@ class TestsStream extends Readable {
     });
   }
 
-  complete(nesting, loc, testNumber, name, details, directive, testId, tags) {
+  complete(nesting, loc, testNumber, name, details, directive, testId, parentId, tags) {
     this[kEmitMessage]('test:complete', {
       __proto__: null,
       name,
       nesting,
       testNumber,
       testId,
+      parentId,
       details,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
@@ -98,36 +101,39 @@ class TestsStream extends Readable {
     return { __proto__: null, expectFailure: expectation ?? true };
   }
 
-  enqueue(nesting, loc, name, type, testId, tags) {
+  enqueue(nesting, loc, name, type, testId, parentId, tags) {
     this[kEmitMessage]('test:enqueue', {
       __proto__: null,
       nesting,
       name,
       type,
       testId,
+      parentId,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
     });
   }
 
-  dequeue(nesting, loc, name, type, testId, tags) {
+  dequeue(nesting, loc, name, type, testId, parentId, tags) {
     this[kEmitMessage]('test:dequeue', {
       __proto__: null,
       nesting,
       name,
       type,
       testId,
+      parentId,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
     });
   }
 
-  start(nesting, loc, name, testId, tags) {
+  start(nesting, loc, name, testId, parentId, tags) {
     this[kEmitMessage]('test:start', {
       __proto__: null,
       nesting,
       name,
       testId,
+      parentId,
       tags: ArrayPrototypeSlice(tags),
       ...loc,
     });

From 9c60b08df5b9bdea637aa44fca0b58a8068e4444 Mon Sep 17 00:00:00 2001
From: Richard Lau <richard.lau@ibm.com>
Date: Thu, 21 May 2026 21:48:51 +0100
Subject: [PATCH 41/83] doc: update toolchain for official releases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

RHEL 8 machines now use clang 20.1.

Signed-off-by: Richard Lau <richard.lau@ibm.com>
PR-URL: https://github.com/nodejs/node/pull/63441
Refs: https://github.com/nodejs/build/issues/4265
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Stewart X Addison <sxa@redhat.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 BUILDING.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/BUILDING.md b/BUILDING.md
index d70f084783d527..c302cf3f8f6083 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -175,10 +175,10 @@ Binaries at <https://nodejs.org/download/release/> are produced on:
 | aix-ppc64               | AIX 7.2 TL04 on PPC64BE with GCC 12[^5]                       |
 | darwin-x64              | macOS 15, Xcode 16 with -mmacosx-version-min=13.5             |
 | darwin-arm64 (and .pkg) | macOS 15 (arm64), Xcode 16 with -mmacosx-version-min=13.5     |
-| linux-arm64             | RHEL 8 with Clang 19.1 and gcc-toolset-14-libatomic-devel[^6] |
-| linux-ppc64le           | RHEL 8 with Clang 19.1 and gcc-toolset-14-libatomic-devel[^6] |
-| linux-s390x             | RHEL 8 with Clang 19.1 and gcc-toolset-14-libatomic-devel[^6] |
-| linux-x64               | RHEL 8 with Clang 19.1 and gcc-toolset-14-libatomic-devel[^6] |
+| linux-arm64             | RHEL 8 with Clang 20.1 and gcc-toolset-14-libatomic-devel[^6] |
+| linux-ppc64le           | RHEL 8 with Clang 20.1 and gcc-toolset-14-libatomic-devel[^6] |
+| linux-s390x             | RHEL 8 with Clang 20.1 and gcc-toolset-14-libatomic-devel[^6] |
+| linux-x64               | RHEL 8 with Clang 20.1 and gcc-toolset-14-libatomic-devel[^6] |
 | win-arm64               | Windows Server 2022 (x64) with Visual Studio 2022             |
 | win-x64                 | Windows Server 2022 (x64) with Visual Studio 2022             |
 

From 436748fc28cc177596a0384b8894152a920e5d5a Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 7 May 2026 20:59:58 -0700
Subject: [PATCH 42/83] src,lib: implement experimental DTLS API

Decided to take a short break from the work on QUIC
to implement a DTLS API. Very experimental at this
point but the basic API is there (inspired by the
QUIC API work).

The implementation is based on OpenSSL's built-in
DTLS support and no other dependencies are required.

DTLS is a datagram-based version of TLS that is used
for things like WebRTC and CoAP. It provides similar
security guarantees as TLS but is designed to work over
UDP instead of TCP.

This shouldn't be considered ready for production
but it is a good starting point for experimentation
and feedback.

```bash
./configure --experimental-dtls
make -j{nproc}
./node --experimental-dtls my-dtls-app.js
```

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63182
Fixes: https://github.com/nodejs/node/issues/61630
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 configure.py                                  |  11 +
 doc/api/cli.md                                |  13 +
 doc/api/dtls.md                               | 371 ++++++++++
 doc/node.1                                    |   5 +
 lib/dtls.js                                   |  36 +
 lib/internal/bootstrap/node.js                |   5 +
 lib/internal/bootstrap/realm.js               |   3 +-
 lib/internal/dtls/dtls.js                     | 637 +++++++++++++++++
 lib/internal/dtls/state.js                    | 168 +++++
 lib/internal/dtls/stats.js                    |  43 ++
 lib/internal/dtls/symbols.js                  |  37 +
 lib/internal/modules/cjs/loader.js            |   3 +
 lib/internal/process/pre_execution.js         |  10 +
 node.gyp                                      |  19 +
 src/async_wrap.h                              |   2 +
 src/dtls/dtls.cc                              |  80 +++
 src/dtls/dtls.h                               |  59 ++
 src/dtls/dtls_context.cc                      | 460 ++++++++++++
 src/dtls/dtls_context.h                       |  94 +++
 src/dtls/dtls_endpoint.cc                     | 624 ++++++++++++++++
 src/dtls/dtls_endpoint.h                      | 147 ++++
 src/dtls/dtls_session.cc                      | 672 ++++++++++++++++++
 src/dtls/dtls_session.h                       | 167 +++++
 src/env_properties.h                          |   3 +
 src/node_binding.cc                           |   1 +
 src/node_binding.h                            |   9 +-
 src/node_builtins.cc                          |   5 +
 src/node_options.cc                           |   9 +
 src/node_options.h                            |   1 +
 test/common/index.js                          |   2 +
 test/common/index.mjs                         |   2 +
 test/doctool/test-make-doc.mjs                |   2 +-
 test/parallel/test-dtls-alpn.mjs              |  56 ++
 test/parallel/test-dtls-async-dispose.mjs     |  50 ++
 test/parallel/test-dtls-basic.mjs             |  90 +++
 test/parallel/test-dtls-close.mjs             | 110 +++
 test/parallel/test-dtls-multiple-clients.mjs  |  81 +++
 test/parallel/test-dtls-options.mjs           |  53 ++
 .../parallel/test-dtls-session-properties.mjs |  64 ++
 test/parallel/test-permission-net-dtls.mjs    |  59 ++
 test/parallel/test-process-features.js        |   1 +
 test/parallel/test-process-get-builtin.mjs    |   2 +
 test/sequential/test-async-wrap-getasyncid.js |   2 +
 43 files changed, 4265 insertions(+), 3 deletions(-)
 create mode 100644 doc/api/dtls.md
 create mode 100644 lib/dtls.js
 create mode 100644 lib/internal/dtls/dtls.js
 create mode 100644 lib/internal/dtls/state.js
 create mode 100644 lib/internal/dtls/stats.js
 create mode 100644 lib/internal/dtls/symbols.js
 create mode 100644 src/dtls/dtls.cc
 create mode 100644 src/dtls/dtls.h
 create mode 100644 src/dtls/dtls_context.cc
 create mode 100644 src/dtls/dtls_context.h
 create mode 100644 src/dtls/dtls_endpoint.cc
 create mode 100644 src/dtls/dtls_endpoint.h
 create mode 100644 src/dtls/dtls_session.cc
 create mode 100644 src/dtls/dtls_session.h
 create mode 100644 test/parallel/test-dtls-alpn.mjs
 create mode 100644 test/parallel/test-dtls-async-dispose.mjs
 create mode 100644 test/parallel/test-dtls-basic.mjs
 create mode 100644 test/parallel/test-dtls-close.mjs
 create mode 100644 test/parallel/test-dtls-multiple-clients.mjs
 create mode 100644 test/parallel/test-dtls-options.mjs
 create mode 100644 test/parallel/test-dtls-session-properties.mjs
 create mode 100644 test/parallel/test-permission-net-dtls.mjs

diff --git a/configure.py b/configure.py
index ae5f9e70a69a35..57177b969bb523 100755
--- a/configure.py
+++ b/configure.py
@@ -1073,6 +1073,12 @@
     default=None,
     help='build with experimental QUIC support')
 
+parser.add_argument('--experimental-dtls',
+    action='store_true',
+    dest='experimental_dtls',
+    default=None,
+    help='build with experimental DTLS support')
+
 parser.add_argument('--ninja',
     action='store_true',
     dest='use_ninja',
@@ -2362,6 +2368,10 @@ def configure_quic(o):
   o['variables']['node_use_quic'] = b(options.experimental_quic and
                                       not options.without_ssl)
 
+def configure_dtls(o):
+  o['variables']['node_use_dtls'] = b(options.experimental_dtls and
+                                      not options.without_ssl)
+
 def configure_static(o):
   if options.fully_static or options.partly_static:
     if flavor == 'mac':
@@ -2820,6 +2830,7 @@ def make_bin_override():
 configure_v8(output, configurations)
 configure_openssl(output)
 configure_quic(output)
+configure_dtls(output)
 configure_intl(output)
 configure_static(output)
 configure_inspector(output)
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 28d85a74c8707c..bc1f69483f3f7f 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1212,6 +1212,17 @@ If present, Node.js will look for a
 `node.config.json` file in the current working directory and load it as a
 configuration file.
 
+### `--experimental-dtls`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Enable experimental support for the DTLS protocol. See the
+[dtls documentation][] for details.
+
 ### `--experimental-eventsource`
 
 <!-- YAML
@@ -3760,6 +3771,7 @@ one is included in the list below.
 * `--experimental-abortcontroller`
 * `--experimental-addon-modules`
 * `--experimental-detect-module`
+* `--experimental-dtls`
 * `--experimental-eventsource`
 * `--experimental-ffi`
 * `--experimental-import-meta-resolve`
@@ -4431,6 +4443,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [debugger]: debugger.md
 [debugging security implications]: https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications
 [deprecation warnings]: deprecations.md#list-of-deprecated-apis
+[dtls documentation]: dtls.md
 [emit_warning]: process.md#processemitwarningwarning-options
 [environment_variables]: #environment-variables_1
 [filtering tests by name]: test.md#filtering-tests-by-name
diff --git a/doc/api/dtls.md b/doc/api/dtls.md
new file mode 100644
index 00000000000000..28f3aad5c8ce49
--- /dev/null
+++ b/doc/api/dtls.md
@@ -0,0 +1,371 @@
+# DTLS
+
+<!-- YAML
+added: REPLACEME
+-->
+
+<!-- introduced_in=REPLACEME -->
+
+> Stability: 1 - Experimental
+
+<!-- source_link=lib/dtls.js -->
+
+The `node:dtls` module provides an implementation of the Datagram Transport
+Layer Security (DTLS) protocol over UDP. DTLS provides TLS-equivalent
+security guarantees for datagram-based communication, including
+confidentiality, integrity, and authentication.
+
+To use this module, it must be enabled at build time with the
+`--experimental-dtls` configure flag and at runtime with the
+`--experimental-dtls` CLI flag.
+
+```bash
+node --experimental-dtls app.mjs
+```
+
+```mjs
+import { listen, connect } from 'node:dtls';
+```
+
+```cjs
+const { listen, connect } = require('node:dtls');
+```
+
+## Permission model
+
+When using the [Permission Model][], the `--allow-net` flag must be passed to
+allow DTLS network operations. Without it, calling [`dtls.connect()`][] or
+[`dtls.listen()`][] will throw an `ERR_ACCESS_DENIED` error.
+
+```console
+node --permission --allow-fs-read=* --experimental-dtls index.mjs
+Error: Access to this API has been restricted. Use --allow-net to manage permissions.
+  code: 'ERR_ACCESS_DENIED',
+  permission: 'Net',
+}
+```
+
+Creating a [`DTLSEndpoint`][] instance without connecting or listening
+is permitted even without `--allow-net`, since no network I/O occurs until
+[`dtls.connect()`][] or [`dtls.listen()`][] is called.
+
+## DTLS vs TLS
+
+DTLS is designed for UDP transport and differs from TLS in several key ways:
+
+* No stream guarantees: Messages may arrive out of order or be lost.
+  DTLS preserves datagram semantics.
+* One socket, many peers: A single UDP socket can serve multiple DTLS
+  sessions. The `DTLSEndpoint` manages this multiplexing.
+* Cookie exchange: DTLS servers use a stateless cookie mechanism
+  (HelloVerifyRequest) to prevent denial-of-service amplification attacks.
+* Retransmission: DTLS handles handshake retransmission internally since
+  UDP does not guarantee delivery.
+
+## `dtls.listen(callback, options)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `callback` {Function} Called for each new DTLS session accepted by the
+  server.
+  * `session` {DTLSSession} The new session.
+* `options` {Object}
+  * `cert` {string|Buffer} Server certificate in PEM format. **Required.**
+  * `key` {string|Buffer} Server private key in PEM format. **Required.**
+  * `port` {number} Port to bind to. **Required.**
+  * `host` {string} Address to bind to. **Default:** `'0.0.0.0'`.
+  * `ca` {string|Buffer|string\[]|Buffer\[]} CA certificates in PEM format.
+  * `ciphers` {string} OpenSSL cipher list string.
+  * `alpn` {string\[]|Buffer} ALPN protocol names.
+  * `srtp` {string} Colon-separated SRTP protection profile names
+    (e.g., `'SRTP_AES128_CM_SHA1_80:SRTP_AEAD_AES_128_GCM'`).
+  * `requestCert` {boolean} Request client certificate. **Default:** `false`.
+  * `mtu` {number} Maximum transmission unit for DTLS records.
+    **Default:** `1200`.
+* Returns: {DTLSEndpoint}
+
+Creates a DTLS server bound to the specified address and port. The server
+uses automatic HMAC-based cookie exchange for DoS protection.
+
+```mjs
+import { listen } from 'node:dtls';
+import { readFileSync } from 'node:fs';
+
+const endpoint = listen((session) => {
+  session.onmessage = (data) => {
+    console.log('Received:', data.toString());
+    session.send('pong');
+  };
+
+  session.onhandshake = (protocol) => {
+    console.log('Handshake complete:', protocol);
+  };
+}, {
+  cert: readFileSync('server-cert.pem'),
+  key: readFileSync('server-key.pem'),
+  port: 4433,
+});
+
+console.log('DTLS server listening on', endpoint.address);
+```
+
+## `dtls.connect(host, port[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `host` {string} Remote host to connect to.
+* `port` {number} Remote port to connect to.
+* `options` {Object}
+  * `ca` {string|Buffer|string\[]|Buffer\[]} CA certificates in PEM format.
+  * `cert` {string|Buffer} Client certificate in PEM format.
+  * `key` {string|Buffer} Client private key in PEM format.
+  * `rejectUnauthorized` {boolean} Reject connections with unverifiable
+    certificates. **Default:** `true`.
+  * `bindHost` {string} Local bind address. **Default:** `'0.0.0.0'`.
+  * `bindPort` {number} Local bind port. **Default:** `0` (ephemeral).
+  * `alpn` {string\[]|Buffer} ALPN protocol names.
+  * `srtp` {string} SRTP protection profile names.
+  * `mtu` {number} Maximum transmission unit. **Default:** `1200`.
+* Returns: {DTLSSession}
+
+Connects to a DTLS server. Returns a `DTLSSession` whose `opened` property
+is a `Promise` that resolves when the handshake completes.
+
+```mjs
+import { connect } from 'node:dtls';
+import { readFileSync } from 'node:fs';
+
+const session = connect('localhost', 4433, {
+  ca: [readFileSync('ca-cert.pem')],
+});
+
+await session.opened;
+session.send('hello');
+
+session.onmessage = (data) => {
+  console.log('Received:', data.toString());
+};
+```
+
+## Class: `DTLSEndpoint`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Manages a UDP socket and multiplexes DTLS sessions.
+
+### `endpoint.address`
+
+* Returns: {Object} `{ address, family, port }`
+
+The local address the endpoint is bound to.
+
+### `endpoint.state`
+
+* Returns: {DTLSEndpointState}
+
+Shared state object with properties:
+
+* `bound` {boolean}
+* `listening` {boolean}
+* `closing` {boolean}
+* `destroyed` {boolean}
+* `sessionCount` {number}
+* `busy` {boolean}
+
+### `endpoint.busy`
+
+* {boolean}
+
+When `true`, the endpoint rejects new incoming connections. Can be set
+to implement backpressure.
+
+### `endpoint.close()`
+
+* Returns: {Promise} Resolves when the endpoint is fully closed.
+
+Gracefully closes the endpoint. All active sessions are closed with
+`close_notify` alerts before the UDP socket is released.
+
+### `endpoint.destroy([error])`
+
+Immediately destroys the endpoint without sending `close_notify` alerts.
+
+### `endpoint.closed`
+
+* {Promise} Resolves when the endpoint has fully closed.
+
+### `endpoint[Symbol.asyncDispose]()`
+
+Equivalent to calling `endpoint.close()`.
+
+## Class: `DTLSSession`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Represents a DTLS association with a single remote peer.
+
+### `session.send(data)`
+
+* `data` {string|Buffer} The data to send.
+* Returns: {number} The number of bytes written to the DTLS layer.
+
+Send application data to the peer. The data is encrypted by DTLS before
+being sent over UDP. Can only be called after the handshake completes
+(`session.opened` has resolved).
+
+### `session.close()`
+
+* Returns: {Promise} Resolves when the session is closed.
+
+Initiates a graceful DTLS shutdown by sending a `close_notify` alert.
+
+### `session.destroy([error])`
+
+Immediately destroys the session without sending `close_notify`.
+
+### `session.opened`
+
+* {Promise} Resolves with `{ protocol }` when the DTLS handshake completes.
+
+### `session.closed`
+
+* {Promise} Resolves when the session is fully closed.
+
+### `session.remoteAddress`
+
+* Returns: {Object} `{ address, family, port }`
+
+### `session.protocol`
+
+* Returns: {string} The negotiated DTLS protocol version
+  (e.g., `'DTLSv1.2'`).
+
+### `session.cipher`
+
+* Returns: {Object} `{ name, standardName, version }`
+
+### `session.peerCertificate`
+
+* Returns: {string|undefined} The peer's certificate in PEM format.
+
+### `session.alpnProtocol`
+
+* Returns: {string|undefined} The negotiated ALPN protocol.
+
+### `session.srtpProfile`
+
+* Returns: {string|undefined} The negotiated SRTP protection profile name.
+
+### `session.exportKeyingMaterial(length, label[, context])`
+
+* `length` {number} Number of bytes to export.
+* `label` {string} The label for the exported keying material.
+* `context` {Buffer} Optional context value.
+* Returns: {Buffer}
+
+Exports keying material from the DTLS session, as defined in
+[RFC 5705][]. This is commonly used with DTLS-SRTP to derive
+encryption keys for media streams.
+
+### Callback properties
+
+#### `session.onmessage`
+
+* {Function}
+  * `data` {Buffer}
+
+Set to receive application data from the peer.
+
+#### `session.onerror`
+
+* {Function}
+  * `error` {Error}
+
+Set to receive error notifications.
+
+#### `session.onhandshake`
+
+* {Function}
+  * `protocol` {string}
+
+Set to receive handshake completion notifications.
+
+#### `session.onkeylog`
+
+* {Function}
+  * `line` {string}
+
+Set to receive TLS key log lines (for debugging with Wireshark).
+
+### `session[Symbol.asyncDispose]()`
+
+Equivalent to calling `session.close()`.
+
+## DTLS-SRTP example
+
+DTLS-SRTP is used by WebRTC for media encryption. The DTLS handshake
+negotiates the SRTP protection profile and provides keying material.
+
+```mjs
+import { listen, connect } from 'node:dtls';
+import { readFileSync } from 'node:fs';
+
+// Server with SRTP
+const server = listen((session) => {
+  session.onhandshake = () => {
+    console.log('SRTP profile:', session.srtpProfile);
+    const keys = session.exportKeyingMaterial(
+      60,
+      'EXTRACTOR-dtls_srtp',
+    );
+    console.log('SRTP keying material:', keys);
+  };
+}, {
+  cert: readFileSync('server-cert.pem'),
+  key: readFileSync('server-key.pem'),
+  port: 5004,
+  srtp: 'SRTP_AES128_CM_SHA1_80:SRTP_AEAD_AES_128_GCM',
+});
+
+// Client with SRTP
+const session = connect('localhost', 5004, {
+  rejectUnauthorized: false,
+  srtp: 'SRTP_AEAD_AES_128_GCM:SRTP_AES128_CM_SHA1_80',
+});
+
+await session.opened;
+console.log('Negotiated SRTP:', session.srtpProfile);
+const keys = session.exportKeyingMaterial(60, 'EXTRACTOR-dtls_srtp');
+```
+
+## MTU considerations
+
+Since libuv does not currently support path MTU discovery, the DTLS module
+uses a conservative default MTU of 1200 bytes. This value works across
+virtually all network paths but may be suboptimal for local networks.
+
+The MTU can be configured via the `mtu` option:
+
+```mjs
+// For a local network where you know the path MTU
+const endpoint = listen(callback, {
+  // ...
+  mtu: 1400,
+});
+```
+
+The minimum allowed MTU is 256 bytes. The maximum is 65535.
+
+[Permission Model]: permissions.md#permission-model
+[RFC 5705]: https://www.rfc-editor.org/rfc/rfc5705
+[`DTLSEndpoint`]: #class-dtlsendpoint
+[`dtls.connect()`]: #dtlsconnecthost-port-options
+[`dtls.listen()`]: #dtlslistencallback-options
diff --git a/doc/node.1 b/doc/node.1
index e79021eaa666a3..2f847f91bd08ea 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -719,6 +719,9 @@ If present, Node.js will look for a
 \fBnode.config.json\fR file in the current working directory and load it as a
 configuration file.
 .
+.It Fl -experimental-dtls
+Enable experimental support for the DTLS protocol.
+.
 .It Fl -experimental-eventsource
 Enable exposition of EventSource Web API on the global scope.
 .
@@ -1914,6 +1917,8 @@ one is included in the list below.
 .It
 \fB--experimental-detect-module\fR
 .It
+\fB--experimental-dtls\fR
+.It
 \fB--experimental-eventsource\fR
 .It
 \fB--experimental-ffi\fR
diff --git a/lib/dtls.js b/lib/dtls.js
new file mode 100644
index 00000000000000..c4dc01052ea6ab
--- /dev/null
+++ b/lib/dtls.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const {
+  ObjectCreate,
+  ObjectSeal,
+} = primordials;
+
+const {
+  emitExperimentalWarning,
+} = require('internal/util');
+emitExperimentalWarning('dtls');
+
+const {
+  connect,
+  listen,
+  DTLSEndpoint,
+  DTLSSession,
+} = require('internal/dtls/dtls');
+
+function getEnumerableConstant(value) {
+  return {
+    __proto__: null,
+    value,
+    enumerable: true,
+    configurable: false,
+    writable: false,
+  };
+}
+
+module.exports = ObjectSeal(ObjectCreate(null, {
+  __proto__: null,
+  connect: getEnumerableConstant(connect),
+  listen: getEnumerableConstant(listen),
+  DTLSEndpoint: getEnumerableConstant(DTLSEndpoint),
+  DTLSSession: getEnumerableConstant(DTLSSession),
+}));
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 8bb014426a0359..bde4cb2be84b2d 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -285,6 +285,11 @@ const features = {
   get require_module() {
     return getOptionValue('--require-module');
   },
+  get dtls() {
+    return process.config.variables.node_use_dtls &&
+           hasOpenSSL &&
+           getOptionValue('--experimental-dtls');
+  },
   get quic() {
     // TODO(@jasnell): When the implementation is updated to support Boring,
     // then this should be refactored to depend not only on the OpenSSL version.
diff --git a/lib/internal/bootstrap/realm.js b/lib/internal/bootstrap/realm.js
index 0415763e360246..0fa7a8c4c1bcb7 100644
--- a/lib/internal/bootstrap/realm.js
+++ b/lib/internal/bootstrap/realm.js
@@ -124,6 +124,7 @@ const legacyWrapperList = new SafeSet([
 // beginning with "internal/".
 // Modules that can only be imported via the node: scheme.
 const schemelessBlockList = new SafeSet([
+  'dtls',
   'ffi',
   'sea',
   'sqlite',
@@ -132,7 +133,7 @@ const schemelessBlockList = new SafeSet([
   'test/reporters',
 ]);
 // Modules that will only be enabled at run time.
-const experimentalModuleList = new SafeSet(['ffi', 'sqlite', 'quic', 'stream/iter', 'zlib/iter']);
+const experimentalModuleList = new SafeSet(['dtls', 'ffi', 'sqlite', 'quic', 'stream/iter', 'zlib/iter']);
 
 // Set up process.binding() and process._linkedBinding().
 {
diff --git a/lib/internal/dtls/dtls.js b/lib/internal/dtls/dtls.js
new file mode 100644
index 00000000000000..d797f74b41e0df
--- /dev/null
+++ b/lib/internal/dtls/dtls.js
@@ -0,0 +1,637 @@
+'use strict';
+
+const {
+  ArrayIsArray,
+  FunctionPrototypeBind,
+  PromiseWithResolvers,
+  SafeSet,
+  SymbolAsyncDispose,
+} = primordials;
+
+const {
+  getOptionValue,
+} = require('internal/options');
+
+// DTLS requires that Node.js be compiled with crypto support.
+if (!process.features.dtls || !getOptionValue('--experimental-dtls')) {
+  return;
+}
+
+const {
+  codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_STATE,
+    ERR_MISSING_ARGS,
+  },
+} = require('internal/errors');
+
+const {
+  validateFunction,
+  validateObject,
+  validateString,
+  validateInteger,
+} = require('internal/validators');
+
+const {
+  Buffer,
+} = require('buffer');
+
+const {
+  DTLSEndpointState,
+  DTLSSessionState,
+} = require('internal/dtls/state');
+
+const {
+  kOwner,
+  kPrivateConstructor,
+  kSessionHandshake,
+  kSessionMessage,
+  kSessionError,
+  kSessionClose,
+  kSessionKeylog,
+} = require('internal/dtls/symbols');
+
+const {
+  DTLSContext: DTLSContext_,
+  DTLSEndpoint: DTLSEndpoint_,
+  SSL_VERIFY_NONE_VALUE,
+  SSL_VERIFY_PEER_VALUE,
+  SSL_VERIFY_FAIL_IF_NO_PEER_CERT_VALUE,
+} = internalBinding('dtls');
+
+const kEmptyObject = { __proto__: null };
+
+// ============================================================================
+// DTLSSession -- represents a single DTLS peer association
+// ============================================================================
+
+class DTLSSession {
+  #handle;
+  #endpoint;
+  #state;
+  #pendingOpen;
+  #pendingClose;
+  #onmessage;
+  #onerror;
+  #onhandshake;
+  #onkeylog;
+  #ownsEndpoint = false;
+
+  constructor(privateSymbol, handle, endpoint) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+
+    this.#handle = handle;
+    this.#handle[kOwner] = this;
+    this.#endpoint = endpoint;
+    this.#state = new DTLSSessionState(
+      kPrivateConstructor, handle.getState());
+    this.#pendingOpen = PromiseWithResolvers();
+    this.#pendingClose = PromiseWithResolvers();
+  }
+
+  // --- Callback setters ---
+
+  set onmessage(fn) {
+    if (fn !== undefined && fn !== null) {
+      validateFunction(fn, 'onmessage');
+      this.#onmessage = FunctionPrototypeBind(fn, this);
+      this.#state.hasMessageListener = true;
+    } else {
+      this.#onmessage = undefined;
+      this.#state.hasMessageListener = false;
+    }
+  }
+
+  get onmessage() { return this.#onmessage; }
+
+  set onerror(fn) {
+    if (fn !== undefined && fn !== null) {
+      validateFunction(fn, 'onerror');
+      this.#onerror = FunctionPrototypeBind(fn, this);
+    } else {
+      this.#onerror = undefined;
+    }
+  }
+
+  get onerror() { return this.#onerror; }
+
+  set onhandshake(fn) {
+    if (fn !== undefined && fn !== null) {
+      validateFunction(fn, 'onhandshake');
+      this.#onhandshake = FunctionPrototypeBind(fn, this);
+    } else {
+      this.#onhandshake = undefined;
+    }
+  }
+
+  get onhandshake() { return this.#onhandshake; }
+
+  set onkeylog(fn) {
+    if (fn !== undefined && fn !== null) {
+      validateFunction(fn, 'onkeylog');
+      this.#onkeylog = FunctionPrototypeBind(fn, this);
+    } else {
+      this.#onkeylog = undefined;
+    }
+  }
+
+  get onkeylog() { return this.#onkeylog; }
+
+  // --- Send data ---
+
+  send(data) {
+    if (this.#handle === null) {
+      throw new ERR_INVALID_STATE('Session is destroyed');
+    }
+    if (typeof data === 'string') {
+      data = Buffer.from(data);
+    }
+    if (!Buffer.isBuffer(data)) {
+      throw new ERR_INVALID_ARG_TYPE('data', ['string', 'Buffer'], data);
+    }
+    return this.#handle.send(data);
+  }
+
+  // --- Lifecycle ---
+
+  close() {
+    if (this.#handle === null) return this.closed;
+    const handle = this.#handle;
+    this.#handle = null;
+    handle.close();
+    return this.closed;
+  }
+
+  destroy(error) {
+    if (this.#handle === null) return;
+    const handle = this.#handle;
+    this.#handle = null;
+    handle.destroy();
+    if (error) {
+      this.#pendingClose.reject(error);
+    } else {
+      this.#pendingClose.resolve();
+    }
+  }
+
+  get opened() { return this.#pendingOpen.promise; }
+  get closed() { return this.#pendingClose.promise; }
+
+  // --- Properties ---
+
+  get remoteAddress() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getRemoteAddress();
+  }
+
+  get protocol() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getProtocol();
+  }
+
+  get cipher() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getCipher();
+  }
+
+  get peerCertificate() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getPeerCertificate();
+  }
+
+  get alpnProtocol() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getALPNProtocol();
+  }
+
+  get srtpProfile() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getSRTPProfile();
+  }
+
+  get servername() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getServername();
+  }
+
+  get state() { return this.#state; }
+  get endpoint() { return this.#endpoint; }
+
+  exportKeyingMaterial(length, label, context) {
+    if (this.#handle === null) {
+      throw new ERR_INVALID_STATE('Session is destroyed');
+    }
+    return this.#handle.exportKeyingMaterial(length, label, context);
+  }
+
+  // --- Internal callbacks (called from C++ via endpoint dispatch) ---
+
+  [kSessionHandshake](protocol) {
+    this.#pendingOpen.resolve({ protocol });
+    if (this.#onhandshake) {
+      this.#onhandshake(protocol);
+    }
+  }
+
+  [kSessionMessage](data) {
+    if (this.#onmessage) {
+      this.#onmessage(data);
+    }
+  }
+
+  [kSessionError](message) {
+    const error = new ERR_INVALID_STATE(message);
+    if (this.#onerror) {
+      this.#onerror(error);
+    }
+    this.#pendingOpen.reject(error);
+  }
+
+  [kSessionClose]() {
+    this.#pendingClose.resolve();
+    this.#handle = null;
+    // Remove from the endpoint's JS-side session set.
+    if (this.#endpoint) {
+      this.#endpoint.sessions.delete(this);
+    }
+    // If this session owns its endpoint (client-side connect()),
+    // close the endpoint too so the process can exit.
+    if (this.#ownsEndpoint && this.#endpoint) {
+      this.#endpoint.close();
+    }
+  }
+
+  // Mark that this session owns its endpoint (for client sessions
+  // created by connect() where the endpoint is internal).
+  get ownsEndpoint() { return this.#ownsEndpoint; }
+  set ownsEndpoint(val) { this.#ownsEndpoint = val; }
+
+  [kSessionKeylog](line) {
+    if (this.#onkeylog) {
+      this.#onkeylog(line);
+    }
+  }
+
+  async [SymbolAsyncDispose]() {
+    await this.close();
+  }
+}
+
+// ============================================================================
+// DTLSEndpoint -- manages a UDP socket and routes datagrams to sessions
+// ============================================================================
+
+class DTLSEndpoint {
+  #handle;
+  #state;
+  #sessions = new SafeSet();
+  #pendingClose;
+  #onsession;
+  #onerror;
+
+  constructor(options = kEmptyObject) {
+    this.#handle = new DTLSEndpoint_();
+    this.#handle[kOwner] = this;
+    this.#state = new DTLSEndpointState(
+      kPrivateConstructor, this.#handle.getState());
+    this.#pendingClose = PromiseWithResolvers();
+
+    if (options.mtu !== undefined) {
+      validateInteger(options.mtu, 'options.mtu', 256, 65535);
+      this.#handle.setMTU(options.mtu);
+    }
+
+    // Set up the callback dispatch from C++ to JS.
+    this.#handle.setCallbacks({
+      __proto__: null,
+      onEndpointClose: () => this.#onEndpointClose(),
+      onEndpointError: (msg) => this.#onEndpointError(msg),
+      onSessionNew: (handle) => this.#onSessionNew(handle),
+      onSessionClose: function() {
+        this[kOwner]?.[kSessionClose]();
+      },
+      onSessionError: function(msg) {
+        this[kOwner]?.[kSessionError](msg);
+      },
+      onSessionHandshake: function(protocol) {
+        this[kOwner]?.[kSessionHandshake](protocol);
+      },
+      onSessionMessage: function(data) {
+        this[kOwner]?.[kSessionMessage](data);
+      },
+      onSessionKeylog: function(line) {
+        this[kOwner]?.[kSessionKeylog](line);
+      },
+      onSessionTicket: function() {
+        // Session ticket handling - placeholder for resumption.
+      },
+    });
+  }
+
+  // --- Server mode ---
+
+  listen(callback, context) {
+    validateFunction(callback, 'callback');
+    this.#onsession = callback;
+    this.#handle.listen(context);
+    return this;
+  }
+
+  // --- Client mode ---
+
+  connect(context, host, port, servername) {
+    const sessionHandle = this.#handle.connect(context, host, port);
+    if (servername) {
+      sessionHandle.setServername(servername);
+    }
+    const session = new DTLSSession(
+      kPrivateConstructor, sessionHandle, this);
+    this.#sessions.add(session);
+    return session;
+  }
+
+  // --- Bind ---
+
+  bind(host, port) {
+    this.#handle.bind(host, port);
+    return this;
+  }
+
+  // --- Lifecycle ---
+
+  close() {
+    if (this.#handle === null) return this.closed;
+    const handle = this.#handle;
+    this.#handle = null;
+    handle.close();
+    return this.closed;
+  }
+
+  destroy(error) {
+    if (this.#handle === null) return;
+    const handle = this.#handle;
+    this.#handle = null;
+    handle.destroy();
+    if (error) {
+      this.#pendingClose.reject(error);
+    } else {
+      this.#pendingClose.resolve();
+    }
+  }
+
+  get closed() { return this.#pendingClose.promise; }
+
+  // --- Properties ---
+
+  get address() {
+    if (this.#handle === null) return undefined;
+    return this.#handle.getAddress();
+  }
+
+  get state() { return this.#state; }
+  get sessions() { return this.#sessions; }
+
+  get onerror() { return this.#onerror; }
+  set onerror(fn) {
+    if (fn !== undefined && fn !== null) {
+      validateFunction(fn, 'onerror');
+      this.#onerror = fn;
+    } else {
+      this.#onerror = undefined;
+    }
+  }
+
+  set busy(val) {
+    this.#state.busy = !!val;
+  }
+
+  get busy() {
+    return this.#state.busy;
+  }
+
+  // --- Internal callbacks ---
+
+  #onEndpointClose() {
+    this.#sessions.clear();
+    this.#pendingClose.resolve();
+    this.#handle = null;
+  }
+
+  #onEndpointError(message) {
+    if (this.#onerror) {
+      this.#onerror(new ERR_INVALID_STATE(message));
+    }
+  }
+
+  #onSessionNew(handle) {
+    const session = new DTLSSession(kPrivateConstructor, handle, this);
+    this.#sessions.add(session);
+    if (this.#onsession) {
+      this.#onsession(session);
+    }
+  }
+
+  async [SymbolAsyncDispose]() {
+    await this.close();
+  }
+}
+
+// ============================================================================
+// Public API functions
+// ============================================================================
+
+function createContext(options = kEmptyObject) {
+  validateObject(options, 'options');
+
+  const isServer = options.isServer === true;
+  const context = new DTLSContext_(isServer);
+
+  // Certificate
+  if (options.cert !== undefined) {
+    let cert = options.cert;
+    if (Buffer.isBuffer(cert)) cert = cert.toString();
+    validateString(cert, 'options.cert');
+    context.setCert(cert);
+  }
+
+  // Private key
+  if (options.key !== undefined) {
+    let key = options.key;
+    if (Buffer.isBuffer(key)) key = key.toString();
+    validateString(key, 'options.key');
+    context.setKey(key);
+  }
+
+  // CA certificates: if custom CAs are provided, use only those.
+  // Otherwise load system default CAs. This matches Node.js TLS behavior.
+  if (options.ca !== undefined) {
+    const cas = ArrayIsArray(options.ca) ? options.ca : [options.ca];
+    for (let ca of cas) {
+      if (Buffer.isBuffer(ca)) ca = ca.toString();
+      validateString(ca, 'options.ca');
+      context.addCACert(ca);
+    }
+  } else {
+    context.loadDefaultCAs();
+  }
+
+  // Ciphers
+  if (options.ciphers !== undefined) {
+    validateString(options.ciphers, 'options.ciphers');
+    context.setCiphers(options.ciphers);
+  }
+
+  // ECDH curve (default: 'auto' = OpenSSL default selection)
+  const ecdhCurve = options.ecdhCurve || 'auto';
+  validateString(ecdhCurve, 'options.ecdhCurve');
+  context.setECDHCurve(ecdhCurve);
+
+  // ALPN protocols
+  if (options.alpn !== undefined) {
+    let protocols = options.alpn;
+    if (ArrayIsArray(protocols)) {
+      // Convert string array to wire-format buffer.
+      const bufs = [];
+      for (const proto of protocols) {
+        validateString(proto, 'options.alpn[]');
+        const buf = Buffer.from(proto);
+        bufs.push(Buffer.from([buf.length]), buf);
+      }
+      protocols = Buffer.concat(bufs);
+    }
+    if (!Buffer.isBuffer(protocols)) {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.alpn', ['string[]', 'Buffer'], protocols);
+    }
+    context.setALPN(protocols);
+  }
+
+  // SRTP profiles
+  if (options.srtp !== undefined) {
+    validateString(options.srtp, 'options.srtp');
+    context.setSRTP(options.srtp);
+  }
+
+  // Verification mode
+  if (options.rejectUnauthorized !== undefined) {
+    const mode = options.rejectUnauthorized ?
+      (SSL_VERIFY_PEER_VALUE | SSL_VERIFY_FAIL_IF_NO_PEER_CERT_VALUE) :
+      SSL_VERIFY_NONE_VALUE;
+    context.setVerifyMode(mode);
+  } else if (options.requestCert) {
+    context.setVerifyMode(
+      SSL_VERIFY_PEER_VALUE | SSL_VERIFY_FAIL_IF_NO_PEER_CERT_VALUE);
+  }
+
+  return context;
+}
+
+/**
+ * Start a DTLS server.
+ * @param {Function} onsession Callback invoked for each new DTLS session.
+ * @param {object} options Server configuration.
+ * @param {string|Buffer} options.cert Server certificate (PEM).
+ * @param {string|Buffer} options.key Server private key (PEM).
+ * @param {string|Buffer|Array} [options.ca] CA certificates (PEM).
+ * @param {string} [options.host] Bind address.
+ * @param {number} options.port Bind port.
+ * @param {number} [options.mtu] MTU for DTLS records.
+ * @param {string[]} [options.alpn] ALPN protocol list.
+ * @param {string} [options.srtp] SRTP profile string.
+ * @param {boolean} [options.requestCert] Request client certificates.
+ * @returns {DTLSEndpoint}
+ */
+function listen(onsession, options = kEmptyObject) {
+  validateFunction(onsession, 'onsession');
+  validateObject(options, 'options');
+
+  if (options.cert === undefined) {
+    throw new ERR_MISSING_ARGS('options.cert');
+  }
+  if (options.key === undefined) {
+    throw new ERR_MISSING_ARGS('options.key');
+  }
+  if (options.port === undefined) {
+    throw new ERR_MISSING_ARGS('options.port');
+  }
+
+  const host = options.host || '0.0.0.0';
+  const port = options.port;
+
+  validateString(host, 'options.host');
+  validateInteger(port, 'options.port', 0, 65535);
+
+  const context = createContext({
+    ...options,
+    isServer: true,
+  });
+
+  const endpoint = new DTLSEndpoint({
+    mtu: options.mtu,
+  });
+
+  endpoint.bind(host, port);
+  endpoint.listen(onsession, context);
+
+  return endpoint;
+}
+
+/**
+ * Connect to a DTLS server.
+ * @param {string} host Remote host.
+ * @param {number} port Remote port.
+ * @param {object} [options] Client configuration.
+ * @param {string|Buffer|Array} [options.ca] CA certificates (PEM).
+ * @param {string|Buffer} [options.cert] Client certificate (PEM).
+ * @param {string|Buffer} [options.key] Client private key (PEM).
+ * @param {boolean} [options.rejectUnauthorized] Reject unauthorized.
+ * @param {string} [options.bindHost] Local bind address.
+ * @param {number} [options.bindPort] Local bind port (0 = ephemeral).
+ * @param {number} [options.mtu] MTU for DTLS records.
+ * @param {string[]} [options.alpn] ALPN protocol list.
+ * @param {string} [options.srtp] SRTP profile string.
+ * @returns {DTLSSession}
+ */
+function connect(host, port, options = kEmptyObject) {
+  validateString(host, 'host');
+  validateInteger(port, 'port', 0, 65535);
+  validateObject(options, 'options');
+
+  const bindHost = options.bindHost || '0.0.0.0';
+  const bindPort = options.bindPort || 0;
+
+  const context = createContext({
+    ...options,
+    isServer: false,
+    rejectUnauthorized: options.rejectUnauthorized !== false,
+  });
+
+  const endpoint = new DTLSEndpoint({
+    mtu: options.mtu,
+  });
+
+  endpoint.bind(bindHost, bindPort);
+
+  // Default SNI servername to the host argument (matching Node.js TLS).
+  // Can be overridden with options.servername, or disabled with '' or false.
+  const servername = options.servername !== undefined ?
+    (options.servername || undefined) :
+    host;
+
+  const session = endpoint.connect(context, host, port, servername);
+  // Mark that this session owns the endpoint so it gets closed
+  // automatically when the session closes, allowing process exit.
+  session.ownsEndpoint = true;
+  return session;
+}
+
+module.exports = {
+  connect,
+  listen,
+  createContext,
+  DTLSEndpoint,
+  DTLSSession,
+};
diff --git a/lib/internal/dtls/state.js b/lib/internal/dtls/state.js
new file mode 100644
index 00000000000000..be8272661740fe
--- /dev/null
+++ b/lib/internal/dtls/state.js
@@ -0,0 +1,168 @@
+'use strict';
+
+const {
+  DataView,
+  DataViewPrototypeGetByteLength,
+  DataViewPrototypeGetUint32,
+  DataViewPrototypeGetUint8,
+  DataViewPrototypeSetUint8,
+} = primordials;
+
+const {
+  getOptionValue,
+} = require('internal/options');
+
+if (!process.features.dtls || !getOptionValue('--experimental-dtls')) {
+  return;
+}
+
+const {
+  codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
+    ERR_INVALID_STATE,
+  },
+} = require('internal/errors');
+
+const {
+  kPrivateConstructor,
+} = require('internal/dtls/symbols');
+
+const {
+  IDX_ENDPOINT_STATE_BOUND,
+  IDX_ENDPOINT_STATE_LISTENING,
+  IDX_ENDPOINT_STATE_CLOSING,
+  IDX_ENDPOINT_STATE_DESTROYED,
+  IDX_ENDPOINT_STATE_SESSION_COUNT,
+  IDX_ENDPOINT_STATE_BUSY,
+  IDX_SESSION_STATE_HANDSHAKING,
+  IDX_SESSION_STATE_OPEN,
+  IDX_SESSION_STATE_CLOSING,
+  IDX_SESSION_STATE_DESTROYED,
+  IDX_SESSION_STATE_HAS_MESSAGE_LISTENER,
+} = internalBinding('dtls');
+
+function isAlive(view) {
+  return DataViewPrototypeGetByteLength(view) > 0;
+}
+
+// DTLSEndpointState wraps the shared ArrayBuffer from C++.
+// The C++ struct layout (DTLSEndpointStateData) is:
+//   uint8_t bound;          // offset 0
+//   uint8_t listening;      // offset 1
+//   uint8_t closing;        // offset 2
+//   uint8_t destroyed;      // offset 3
+//   uint32_t session_count; // offset 4 (4-byte aligned)
+//   uint8_t busy;           // offset 8
+class DTLSEndpointState {
+  #handle;
+
+  constructor(privateSymbol, buffer) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+    this.#handle = new DataView(buffer);
+  }
+
+  get bound() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_BOUND) === 1;
+  }
+
+  get listening() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_LISTENING) === 1;
+  }
+
+  get closing() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_CLOSING) === 1;
+  }
+
+  get destroyed() {
+    if (!isAlive(this.#handle)) return true;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_DESTROYED) === 1;
+  }
+
+  get sessionCount() {
+    if (!isAlive(this.#handle)) return 0;
+    return DataViewPrototypeGetUint32(
+      this.#handle, IDX_ENDPOINT_STATE_SESSION_COUNT, true);
+  }
+
+  get busy() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_BUSY) === 1;
+  }
+
+  set busy(val) {
+    if (!isAlive(this.#handle)) {
+      throw new ERR_INVALID_STATE('Endpoint is destroyed');
+    }
+    DataViewPrototypeSetUint8(
+      this.#handle, IDX_ENDPOINT_STATE_BUSY, val ? 1 : 0);
+  }
+}
+
+// DTLSSessionState wraps the shared ArrayBuffer from C++.
+// The C++ struct layout (DTLSSessionStateData) is:
+//   uint8_t handshaking;          // offset 0
+//   uint8_t open;                 // offset 1
+//   uint8_t closing;              // offset 2
+//   uint8_t destroyed;            // offset 3
+//   uint8_t has_message_listener; // offset 4
+class DTLSSessionState {
+  #handle;
+
+  constructor(privateSymbol, buffer) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+    this.#handle = new DataView(buffer);
+  }
+
+  get handshaking() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_SESSION_STATE_HANDSHAKING) === 1;
+  }
+
+  get open() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_SESSION_STATE_OPEN) === 1;
+  }
+
+  get closing() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_SESSION_STATE_CLOSING) === 1;
+  }
+
+  get destroyed() {
+    if (!isAlive(this.#handle)) return true;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_SESSION_STATE_DESTROYED) === 1;
+  }
+
+  get hasMessageListener() {
+    if (!isAlive(this.#handle)) return false;
+    return DataViewPrototypeGetUint8(
+      this.#handle, IDX_SESSION_STATE_HAS_MESSAGE_LISTENER) === 1;
+  }
+
+  set hasMessageListener(val) {
+    if (!isAlive(this.#handle)) return;
+    DataViewPrototypeSetUint8(
+      this.#handle, IDX_SESSION_STATE_HAS_MESSAGE_LISTENER, val ? 1 : 0);
+  }
+}
+
+module.exports = {
+  DTLSEndpointState,
+  DTLSSessionState,
+};
diff --git a/lib/internal/dtls/stats.js b/lib/internal/dtls/stats.js
new file mode 100644
index 00000000000000..645c57fc6c05c1
--- /dev/null
+++ b/lib/internal/dtls/stats.js
@@ -0,0 +1,43 @@
+'use strict';
+
+// Placeholder for DTLS statistics tracking.
+// Will be expanded as the implementation matures.
+
+const {
+  getOptionValue,
+} = require('internal/options');
+
+if (!process.features.dtls || !getOptionValue('--experimental-dtls')) {
+  return;
+}
+
+const {
+  codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
+  },
+} = require('internal/errors');
+
+const {
+  kPrivateConstructor,
+} = require('internal/dtls/symbols');
+
+class DTLSEndpointStats {
+  constructor(privateSymbol) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+  }
+}
+
+class DTLSSessionStats {
+  constructor(privateSymbol) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+  }
+}
+
+module.exports = {
+  DTLSEndpointStats,
+  DTLSSessionStats,
+};
diff --git a/lib/internal/dtls/symbols.js b/lib/internal/dtls/symbols.js
new file mode 100644
index 00000000000000..0fe418d023d4de
--- /dev/null
+++ b/lib/internal/dtls/symbols.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const {
+  Symbol,
+} = primordials;
+
+const {
+  getOptionValue,
+} = require('internal/options');
+
+if (!process.features.dtls || !getOptionValue('--experimental-dtls')) {
+  return;
+}
+
+module.exports = {
+  // Private symbols for internal communication between classes.
+  kOwner: Symbol('kOwner'),
+  kHandle: Symbol('kHandle'),
+  kListen: Symbol('kListen'),
+  kConnect: Symbol('kConnect'),
+  kFinishClose: Symbol('kFinishClose'),
+  kNewSession: Symbol('kNewSession'),
+  kRemoveSession: Symbol('kRemoveSession'),
+  kHandshake: Symbol('kHandshake'),
+  kReceive: Symbol('kReceive'),
+  kError: Symbol('kError'),
+  kClose: Symbol('kClose'),
+  kMessage: Symbol('kMessage'),
+  kKeylog: Symbol('kKeylog'),
+  kTicket: Symbol('kTicket'),
+  kPrivateConstructor: Symbol('kPrivateConstructor'),
+  kSessionHandshake: Symbol('dtls.session.handshake'),
+  kSessionMessage: Symbol('dtls.session.message'),
+  kSessionError: Symbol('dtls.session.error'),
+  kSessionClose: Symbol('dtls.session.close'),
+  kSessionKeylog: Symbol('dtls.session.keylog'),
+};
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 65a35299eb6552..824214b55a2cb5 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -487,6 +487,9 @@ function initializeCJS() {
   // This need to be done at runtime in case --expose-internals is set.
 
   let modules = Module.builtinModules = BuiltinModule.getAllBuiltinModuleIds();
+  if (!getOptionValue('--experimental-dtls')) {
+    modules = modules.filter((i) => i !== 'node:dtls');
+  }
   if (!getOptionValue('--experimental-quic')) {
     modules = modules.filter((i) => i !== 'node:quic');
   }
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 16a80c2d4f410f..394c18887f72ce 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -117,6 +117,7 @@ function prepareExecution(options) {
   setupFFI();
   setupSQLite();
   setupStreamIter();
+  setupDTLS();
   setupQuic();
   setupWebStorage();
   setupWebsocket();
@@ -412,6 +413,15 @@ function setupStreamIter() {
   BuiltinModule.allowRequireByUsers('zlib/iter');
 }
 
+function setupDTLS() {
+  if (!getOptionValue('--experimental-dtls')) {
+    return;
+  }
+
+  const { BuiltinModule } = require('internal/bootstrap/realm');
+  BuiltinModule.allowRequireByUsers('dtls');
+}
+
 function setupQuic() {
   if (!getOptionValue('--experimental-quic')) {
     return;
diff --git a/node.gyp b/node.gyp
index c06e95a98e5ce9..1a724ccb771342 100644
--- a/node.gyp
+++ b/node.gyp
@@ -37,6 +37,7 @@
     'node_use_node_snapshot%': 'false',
     'node_use_openssl%': 'true',
     'node_use_quic%': 'false',
+    'node_use_dtls%': 'false',
     'node_use_sqlite%': 'true',
     'node_use_ffi%': 'false',
     'node_use_v8_platform%': 'true',
@@ -380,6 +381,16 @@
       'src/quic/tlscontext.h',
       'src/quic/guard.h',
     ],
+    'node_dtls_sources': [
+      'src/dtls/dtls.cc',
+      'src/dtls/dtls_context.cc',
+      'src/dtls/dtls_endpoint.cc',
+      'src/dtls/dtls_session.cc',
+      'src/dtls/dtls.h',
+      'src/dtls/dtls_context.h',
+      'src/dtls/dtls_endpoint.h',
+      'src/dtls/dtls_session.h',
+    ],
     'node_crypto_sources': [
       'src/crypto/crypto_aes.cc',
       'src/crypto/crypto_argon2.cc',
@@ -1086,6 +1097,14 @@
             '<@(node_quic_sources)',
           ],
         }],
+        [ 'node_use_dtls=="true"', {
+          'sources': [
+            '<@(node_dtls_sources)',
+          ],
+          'defines': [
+            'HAVE_DTLS=1',
+          ],
+        }],
         [ 'OS in "linux freebsd mac solaris openharmony" and '
           'target_arch=="x64" and '
           'node_target_type=="executable"', {
diff --git a/src/async_wrap.h b/src/async_wrap.h
index bf926754547706..8c8f1e59de366a 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -52,6 +52,8 @@ namespace node {
   V(HTTPINCOMINGMESSAGE)                                                       \
   V(HTTPCLIENTREQUEST)                                                         \
   V(LOCKS)                                                                     \
+  V(DTLS_ENDPOINT)                                                             \
+  V(DTLS_SESSION)                                                              \
   V(JSSTREAM)                                                                  \
   V(JSUDPWRAP)                                                                 \
   V(MESSAGEPORT)                                                               \
diff --git a/src/dtls/dtls.cc b/src/dtls/dtls.cc
new file mode 100644
index 00000000000000..ccd8b98eaab8bb
--- /dev/null
+++ b/src/dtls/dtls.cc
@@ -0,0 +1,80 @@
+#include "dtls.h"
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include "dtls_context.h"
+#include "dtls_endpoint.h"
+#include "dtls_session.h"
+
+#include <env-inl.h>
+#include <node_external_reference.h>
+#include <node_sockaddr-inl.h>
+#include <util-inl.h>
+#include <v8.h>
+
+namespace node {
+
+using v8::Context;
+using v8::Local;
+using v8::Object;
+using v8::ObjectTemplate;
+using v8::Value;
+
+namespace dtls {
+
+void CreatePerContextProperties(Local<Object> target,
+                                Local<Value> unused,
+                                Local<Context> context,
+                                void* priv) {
+  Environment* env = Environment::GetCurrent(context);
+
+  // Register constructors.
+  DTLSContext::InitPerContext(target, context, env);
+  DTLSEndpoint::InitPerContext(target, context, env);
+  DTLSSession::InitPerContext(target, context, env);
+
+  // Endpoint state indices
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_BOUND);
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_LISTENING);
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_CLOSING);
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_DESTROYED);
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_SESSION_COUNT);
+  NODE_DEFINE_CONSTANT(target, IDX_ENDPOINT_STATE_BUSY);
+
+  // Session state indices
+  NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_HANDSHAKING);
+  NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_OPEN);
+  NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_CLOSING);
+  NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_DESTROYED);
+  NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_HAS_MESSAGE_LISTENER);
+
+  // SSL verify mode constants
+  constexpr auto SSL_VERIFY_NONE_VALUE = SSL_VERIFY_NONE;
+  constexpr auto SSL_VERIFY_PEER_VALUE = SSL_VERIFY_PEER;
+  constexpr auto SSL_VERIFY_FAIL_IF_NO_PEER_CERT_VALUE =
+      SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
+  NODE_DEFINE_CONSTANT(target, SSL_VERIFY_NONE_VALUE);
+  NODE_DEFINE_CONSTANT(target, SSL_VERIFY_PEER_VALUE);
+  NODE_DEFINE_CONSTANT(target, SSL_VERIFY_FAIL_IF_NO_PEER_CERT_VALUE);
+}
+
+void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                Local<ObjectTemplate> target) {
+  // Per-isolate initialization (currently none needed).
+}
+
+void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  DTLSContext::RegisterExternalReferences(registry);
+  DTLSEndpoint::RegisterExternalReferences(registry);
+  DTLSSession::RegisterExternalReferences(registry);
+}
+
+}  // namespace dtls
+}  // namespace node
+
+NODE_BINDING_CONTEXT_AWARE_INTERNAL(dtls,
+                                    node::dtls::CreatePerContextProperties)
+NODE_BINDING_PER_ISOLATE_INIT(dtls, node::dtls::CreatePerIsolateProperties)
+NODE_BINDING_EXTERNAL_REFERENCE(dtls, node::dtls::RegisterExternalReferences)
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
diff --git a/src/dtls/dtls.h b/src/dtls/dtls.h
new file mode 100644
index 00000000000000..1b27c2fbf5740d
--- /dev/null
+++ b/src/dtls/dtls.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <env.h>
+#include <node_errors.h>
+#include <v8.h>
+
+namespace node::dtls {
+
+// State indices shared between C++ and JS via AliasedStruct/DataView.
+// Keep in sync with lib/internal/dtls/state.js.
+enum DTLSEndpointStateIndex {
+  IDX_ENDPOINT_STATE_BOUND = 0,
+  IDX_ENDPOINT_STATE_LISTENING,
+  IDX_ENDPOINT_STATE_CLOSING,
+  IDX_ENDPOINT_STATE_DESTROYED,
+  IDX_ENDPOINT_STATE_SESSION_COUNT,
+  IDX_ENDPOINT_STATE_BUSY,
+  IDX_ENDPOINT_STATE_COUNT
+};
+
+enum DTLSSessionStateIndex {
+  IDX_SESSION_STATE_HANDSHAKING = 0,
+  IDX_SESSION_STATE_OPEN,
+  IDX_SESSION_STATE_CLOSING,
+  IDX_SESSION_STATE_DESTROYED,
+  IDX_SESSION_STATE_HAS_MESSAGE_LISTENER,
+  IDX_SESSION_STATE_COUNT
+};
+
+// Callback indices for JS dispatch
+enum DTLSCallbackIndex {
+  DTLS_CB_ENDPOINT_CLOSE = 0,
+  DTLS_CB_ENDPOINT_ERROR,
+  DTLS_CB_SESSION_NEW,
+  DTLS_CB_SESSION_CLOSE,
+  DTLS_CB_SESSION_ERROR,
+  DTLS_CB_SESSION_HANDSHAKE,
+  DTLS_CB_SESSION_MESSAGE,
+  DTLS_CB_SESSION_KEYLOG,
+  DTLS_CB_SESSION_TICKET,
+  DTLS_CB_COUNT
+};
+
+void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                v8::Local<v8::Value> unused,
+                                v8::Local<v8::Context> context,
+                                void* priv);
+void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                v8::Local<v8::ObjectTemplate> target);
+void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+}  // namespace node::dtls
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/dtls/dtls_context.cc b/src/dtls/dtls_context.cc
new file mode 100644
index 00000000000000..ca5003df46c295
--- /dev/null
+++ b/src/dtls/dtls_context.cc
@@ -0,0 +1,460 @@
+#include "dtls_context.h"
+#include "dtls_session.h"
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <base_object-inl.h>
+#include <crypto/crypto_util.h>
+#include <env-inl.h>
+#include <memory_tracker-inl.h>
+#include <node_errors.h>
+#include <node_sockaddr-inl.h>
+#include <util-inl.h>
+
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <openssl/rand.h>
+#include <openssl/srtp.h>
+#include <openssl/ssl.h>
+
+#include <cstring>
+
+namespace node {
+
+using v8::Context;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::Value;
+
+namespace dtls {
+
+namespace {
+// The cookie secret is 32 bytes (256 bits).
+constexpr size_t kCookieSecretLen = 32;
+}  // namespace
+
+DTLSContext::DTLSContext(Environment* env,
+                         Local<Object> wrap,
+                         SSL_CTX* ctx,
+                         bool is_server)
+    : BaseObject(env, wrap),
+      ctx_(ctx),
+      is_server_(is_server),
+      cookie_secret_(kCookieSecretLen) {
+  MakeWeak();
+
+  // Generate random cookie secret for HMAC-based cookie generation.
+  CHECK_EQ(RAND_bytes(cookie_secret_.data(), kCookieSecretLen), 1);
+
+  // Cookie generate/verify callbacks are registered on the SSL_CTX so they
+  // are inherited by all SSL objects created from it. However, we do NOT set
+  // SSL_OP_COOKIE_EXCHANGE on the context -- DTLSv1_listen() sets this option
+  // automatically on the per-SSL object when it runs (see d1_lib.c:804 in
+  // OpenSSL). This is important: if SSL_OP_COOKIE_EXCHANGE were set on the
+  // context, any SSL created from it would attempt a fresh cookie exchange,
+  // which is wrong for session SSLs that have already completed cookie
+  // verification via DTLSv1_listen().
+  SSL_CTX_set_cookie_generate_cb(ctx_.get(), CookieGenerateCallback);
+  SSL_CTX_set_cookie_verify_cb(ctx_.get(), CookieVerifyCallback);
+
+  // Store pointer to this context in the SSL_CTX app data for callbacks.
+  SSL_CTX_set_app_data(ctx_.get(), this);
+}
+
+void DTLSContext::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("cookie_secret", cookie_secret_.size());
+  tracker->TrackFieldWithSize("alpn_protos", alpn_protos_.size());
+}
+
+Local<FunctionTemplate> DTLSContext::GetConstructorTemplate(Environment* env) {
+  auto tmpl = env->dtls_context_constructor_template();
+  if (tmpl.IsEmpty()) {
+    Isolate* isolate = env->isolate();
+    tmpl = NewFunctionTemplate(isolate, New);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "DTLSContext"));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        BaseObject::kInternalFieldCount);
+
+    SetProtoMethod(isolate, tmpl, "setCert", SetCert);
+    SetProtoMethod(isolate, tmpl, "setKey", SetKey);
+    SetProtoMethod(isolate, tmpl, "addCACert", AddCACert);
+    SetProtoMethod(isolate, tmpl, "setCiphers", SetCiphers);
+    SetProtoMethod(isolate, tmpl, "setALPN", SetALPN);
+    SetProtoMethod(isolate, tmpl, "setSRTP", SetSRTP);
+    SetProtoMethod(isolate, tmpl, "setVerifyMode", SetVerifyMode);
+    SetProtoMethod(isolate, tmpl, "loadDefaultCAs", LoadDefaultCAs);
+    SetProtoMethod(isolate, tmpl, "setECDHCurve", SetECDHCurve);
+
+    env->set_dtls_context_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void DTLSContext::InitPerContext(Local<Object> target,
+                                 Local<Context> context,
+                                 Environment* env) {
+  SetConstructorFunction(
+      context, target, "DTLSContext", GetConstructorTemplate(env));
+}
+
+void DTLSContext::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(SetCert);
+  registry->Register(SetKey);
+  registry->Register(AddCACert);
+  registry->Register(SetCiphers);
+  registry->Register(SetALPN);
+  registry->Register(SetSRTP);
+  registry->Register(SetVerifyMode);
+  registry->Register(LoadDefaultCAs);
+  registry->Register(SetECDHCurve);
+}
+
+// new DTLSContext(isServer)
+void DTLSContext::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args.IsConstructCall());
+
+  bool is_server = args[0]->IsTrue();
+
+  const SSL_METHOD* method;
+  if (is_server) {
+    method = DTLS_server_method();
+  } else {
+    method = DTLS_client_method();
+  }
+
+  SSL_CTX* ctx = SSL_CTX_new(method);
+  if (ctx == nullptr) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "Failed to create DTLS SSL_CTX");
+  }
+
+  // Default to DTLS 1.2 only. DTLS 1.0 (based on TLS 1.1) is deprecated
+  // by RFC 8996 and lacks AEAD cipher suites.
+  SSL_CTX_set_min_proto_version(ctx, DTLS1_2_VERSION);
+  SSL_CTX_set_max_proto_version(ctx, DTLS1_2_VERSION);
+
+  // Disable OpenSSL's MTU querying (we manage MTU manually).
+  SSL_CTX_set_options(ctx, SSL_OP_NO_QUERY_MTU);
+
+  // Enable all workarounds for maximum compatibility.
+  SSL_CTX_set_options(ctx, SSL_OP_ALL);
+
+  if (is_server) {
+    // NOTE: SSL_OP_COOKIE_EXCHANGE must NOT be set on the context.
+    // DTLSv1_listen() sets it per-SSL automatically (see d1_lib.c:804).
+    // Setting it here would cause session SSLs created via CreateFromSSL()
+    // to attempt a redundant cookie exchange, hanging the handshake.
+
+    // Enable session caching for session resumption.
+    SSL_CTX_set_session_cache_mode(
+        ctx, SSL_SESS_CACHE_SERVER | SSL_SESS_CACHE_NO_AUTO_CLEAR);
+  } else {
+    // Client session caching for resumption.
+    SSL_CTX_set_session_cache_mode(
+        ctx, SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_NO_INTERNAL);
+  }
+
+  // NOTE: We do NOT call SSL_CTX_set_default_verify_paths() here.
+  // CA loading is handled in JS: if the user provides custom CAs, only
+  // those are loaded (via addCACert). Otherwise, system default CAs are
+  // loaded via loadDefaultCAs(). This matches Node.js TLS behavior.
+
+  new DTLSContext(env, args.This(), ctx, is_server);
+}
+
+void DTLSContext::SetCert(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!args[0]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "cert must be a string (PEM)");
+  }
+
+  Utf8Value cert_pem(env->isolate(), args[0]);
+
+  BIO* bio = BIO_new_mem_buf(*cert_pem, cert_pem.length());
+  if (bio == nullptr) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "BIO_new_mem_buf failed");
+  }
+
+  X509* x509 = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
+  if (x509 == nullptr) {
+    BIO_free(bio);
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "PEM_read_bio_X509 failed");
+  }
+
+  int ret = SSL_CTX_use_certificate(ctx->ctx_.get(), x509);
+  X509_free(x509);
+
+  // Read any additional chain certificates.
+  while ((x509 = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr)) !=
+         nullptr) {
+    SSL_CTX_add_extra_chain_cert(ctx->ctx_.get(), x509);
+    // Note: SSL_CTX_add_extra_chain_cert takes ownership, don't free x509.
+  }
+
+  // Clear any error from the chain reading loop (expected EOF).
+  ERR_clear_error();
+  BIO_free(bio);
+
+  if (ret != 1) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "SSL_CTX_use_certificate failed");
+  }
+}
+
+void DTLSContext::SetKey(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!args[0]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "key must be a string (PEM)");
+  }
+
+  Utf8Value key_pem(env->isolate(), args[0]);
+
+  BIO* bio = BIO_new_mem_buf(*key_pem, key_pem.length());
+  if (bio == nullptr) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "BIO_new_mem_buf failed");
+  }
+
+  EVP_PKEY* pkey = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr);
+  BIO_free(bio);
+
+  if (pkey == nullptr) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "PEM_read_bio_PrivateKey failed");
+  }
+
+  int ret = SSL_CTX_use_PrivateKey(ctx->ctx_.get(), pkey);
+  EVP_PKEY_free(pkey);
+
+  if (ret != 1) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "SSL_CTX_use_PrivateKey failed");
+  }
+
+  // Verify that the private key matches the certificate.
+  if (SSL_CTX_check_private_key(ctx->ctx_.get()) != 1) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(
+        env, "Private key does not match certificate");
+  }
+}
+
+void DTLSContext::AddCACert(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!args[0]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "ca must be a string (PEM)");
+  }
+
+  Utf8Value ca_pem(env->isolate(), args[0]);
+
+  BIO* bio = BIO_new_mem_buf(*ca_pem, ca_pem.length());
+  if (bio == nullptr) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "BIO_new_mem_buf failed");
+  }
+
+  X509_STORE* store = SSL_CTX_get_cert_store(ctx->ctx_.get());
+  X509* x509;
+  int count = 0;
+  while ((x509 = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr)) !=
+         nullptr) {
+    X509_STORE_add_cert(store, x509);
+    X509_free(x509);
+    count++;
+  }
+  ERR_clear_error();
+  BIO_free(bio);
+
+  if (count == 0) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(
+        env, "No CA certificates found in PEM data");
+  }
+}
+
+void DTLSContext::SetCiphers(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!args[0]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "ciphers must be a string");
+  }
+
+  Utf8Value ciphers(env->isolate(), args[0]);
+  if (SSL_CTX_set_cipher_list(ctx->ctx_.get(), *ciphers) != 1) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                             "SSL_CTX_set_cipher_list failed");
+  }
+}
+
+void DTLSContext::SetALPN(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!Buffer::HasInstance(args[0])) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "alpnProtocols must be a Buffer");
+  }
+
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(Buffer::Data(args[0]));
+  size_t len = Buffer::Length(args[0]);
+
+  if (ctx->is_server_) {
+    // Server: store protocols for the selection callback.
+    ctx->alpn_protos_.assign(data, data + len);
+    SSL_CTX_set_alpn_select_cb(ctx->ctx_.get(), ALPNSelectCallback, ctx);
+  } else {
+    // Client: advertise protocols to the server.
+    SSL_CTX_set_alpn_protos(ctx->ctx_.get(), data, len);
+  }
+}
+
+void DTLSContext::SetSRTP(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  if (!args[0]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "srtpProfiles must be a string");
+  }
+
+  Utf8Value profiles(env->isolate(), args[0]);
+  if (SSL_CTX_set_tlsext_use_srtp(ctx->ctx_.get(), *profiles) != 0) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(
+        env, "SSL_CTX_set_tlsext_use_srtp failed");
+  }
+}
+
+void DTLSContext::SetVerifyMode(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+
+  int mode = args[0]->Int32Value(ctx->env()->context()).FromJust();
+  SSL_CTX_set_verify(ctx->ctx_.get(), mode, nullptr);
+}
+
+void DTLSContext::LoadDefaultCAs(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  SSL_CTX_set_default_verify_paths(ctx->ctx_.get());
+}
+
+void DTLSContext::SetECDHCurve(const FunctionCallbackInfo<Value>& args) {
+  DTLSContext* ctx;
+  ASSIGN_OR_RETURN_UNWRAP(&ctx, args.This());
+  Environment* env = ctx->env();
+
+  CHECK(args[0]->IsString());
+  Utf8Value curve(env->isolate(), args[0]);
+
+  // "auto" means use OpenSSL's default curve selection.
+  if (strcmp(*curve, "auto") != 0) {
+    if (!SSL_CTX_set1_curves_list(ctx->ctx_.get(), *curve)) {
+      return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to set ECDH curve");
+    }
+  }
+}
+
+// HMAC-SHA256 based cookie generation using the peer's address.
+// During DTLSv1_listen(), the peer address is taken from
+// DTLSContext::current_cookie_peer_ (set synchronously before the call).
+// During session handshake, the peer address is taken from the
+// DTLSSession stored in SSL app_data.
+int DTLSContext::CookieGenerateCallback(SSL* ssl,
+                                        unsigned char* cookie,
+                                        unsigned int* cookie_len) {
+  SSL_CTX* ctx = SSL_get_SSL_CTX(ssl);
+  DTLSContext* dtls_ctx = static_cast<DTLSContext*>(SSL_CTX_get_app_data(ctx));
+  CHECK_NOT_NULL(dtls_ctx);
+
+  unsigned char addr_buf[sizeof(struct sockaddr_storage)];
+  size_t addr_len = 0;
+
+  void* app_data = SSL_get_app_data(ssl);
+  if (app_data != nullptr) {
+    // Session handshake path.
+    auto* session = static_cast<DTLSSession*>(app_data);
+    const sockaddr* sa = session->remote_address().data();
+    addr_len = SocketAddress::GetLength(sa);
+    memcpy(addr_buf, sa, addr_len);
+  } else {
+    // DTLSv1_listen path — use the peer address stored on the context.
+    const sockaddr* sa = dtls_ctx->current_cookie_peer_.data();
+    addr_len = SocketAddress::GetLength(sa);
+    memcpy(addr_buf, sa, addr_len);
+  }
+
+  unsigned int hmac_len = 0;
+  unsigned char* result = HMAC(EVP_sha256(),
+                               dtls_ctx->cookie_secret_.data(),
+                               dtls_ctx->cookie_secret_.size(),
+                               addr_buf,
+                               addr_len,
+                               cookie,
+                               &hmac_len);
+
+  if (result == nullptr) return 0;
+
+  *cookie_len = hmac_len;
+  return 1;
+}
+
+int DTLSContext::CookieVerifyCallback(SSL* ssl,
+                                      const unsigned char* cookie,
+                                      unsigned int cookie_len) {
+  // Generate the expected cookie and compare.
+  unsigned char expected[EVP_MAX_MD_SIZE];
+  unsigned int expected_len = 0;
+
+  if (CookieGenerateCallback(ssl, expected, &expected_len) != 1) {
+    return 0;
+  }
+
+  if (cookie_len != expected_len) return 0;
+
+  return CRYPTO_memcmp(cookie, expected, expected_len) == 0 ? 1 : 0;
+}
+
+int DTLSContext::ALPNSelectCallback(SSL* ssl,
+                                    const unsigned char** out,
+                                    unsigned char* outlen,
+                                    const unsigned char* in,
+                                    unsigned int inlen,
+                                    void* arg) {
+  DTLSContext* ctx = static_cast<DTLSContext*>(arg);
+
+  if (ctx->alpn_protos_.empty()) {
+    return SSL_TLSEXT_ERR_NOACK;
+  }
+
+  int ret = SSL_select_next_proto(const_cast<unsigned char**>(out),
+                                  outlen,
+                                  ctx->alpn_protos_.data(),
+                                  ctx->alpn_protos_.size(),
+                                  in,
+                                  inlen);
+
+  if (ret != OPENSSL_NPN_NEGOTIATED) {
+    return SSL_TLSEXT_ERR_NOACK;
+  }
+
+  return SSL_TLSEXT_ERR_OK;
+}
+
+}  // namespace dtls
+}  // namespace node
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
diff --git a/src/dtls/dtls_context.h b/src/dtls/dtls_context.h
new file mode 100644
index 00000000000000..11d8113d308125
--- /dev/null
+++ b/src/dtls/dtls_context.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <base_object.h>
+#include <env.h>
+#include <ncrypto.h>
+#include <node_sockaddr.h>
+#include <v8.h>
+
+#include <openssl/dtls1.h>
+#include <openssl/ssl.h>
+
+#include <vector>
+
+namespace node::dtls {
+
+// DTLSContext wraps an SSL_CTX configured for DTLS.
+// It manages certificate/key configuration, cipher selection,
+// ALPN, and automatic cookie generation/verification for servers.
+class DTLSContext final : public BaseObject {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerContext(v8::Local<v8::Object> target,
+                             v8::Local<v8::Context> context,
+                             Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  DTLSContext(Environment* env,
+              v8::Local<v8::Object> wrap,
+              SSL_CTX* ctx,
+              bool is_server);
+
+  SSL_CTX* ssl_ctx() const { return ctx_.get(); }
+
+  // Set the peer address for cookie generation during DTLSv1_listen().
+  void set_cookie_peer(const SocketAddress& addr) {
+    current_cookie_peer_ = addr;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(DTLSContext)
+  SET_SELF_SIZE(DTLSContext)
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetCert(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetKey(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddCACert(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetCiphers(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetALPN(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSRTP(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetVerifyMode(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoadDefaultCAs(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetECDHCurve(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // Automatic DTLS cookie callbacks
+  static int CookieGenerateCallback(SSL* ssl,
+                                    unsigned char* cookie,
+                                    unsigned int* cookie_len);
+  static int CookieVerifyCallback(SSL* ssl,
+                                  const unsigned char* cookie,
+                                  unsigned int cookie_len);
+
+  // ALPN selection callback (server-side)
+  static int ALPNSelectCallback(SSL* ssl,
+                                const unsigned char** out,
+                                unsigned char* outlen,
+                                const unsigned char* in,
+                                unsigned int inlen,
+                                void* arg);
+
+  ncrypto::SSLCtxPointer ctx_;
+  bool is_server_;
+
+  // Secret key for HMAC-based cookie generation
+  std::vector<uint8_t> cookie_secret_;
+
+  // Peer address for current DTLSv1_listen cookie exchange.
+  // Set synchronously before DTLSv1_listen() and consumed by the
+  // cookie generate/verify callbacks during that call.
+  SocketAddress current_cookie_peer_;
+
+  // ALPN protocols (server-side selection list)
+  std::vector<uint8_t> alpn_protos_;
+};
+
+}  // namespace node::dtls
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/dtls/dtls_endpoint.cc b/src/dtls/dtls_endpoint.cc
new file mode 100644
index 00000000000000..b1c91d4f221b8e
--- /dev/null
+++ b/src/dtls/dtls_endpoint.cc
@@ -0,0 +1,624 @@
+#include "dtls_endpoint.h"
+#include "dtls.h"
+#include "dtls_context.h"
+#include "dtls_session.h"
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <aliased_struct-inl.h>
+#include <base_object-inl.h>
+#include <env-inl.h>
+#include <handle_wrap.h>
+#include <memory_tracker-inl.h>
+#include <node_buffer.h>
+#include <node_errors.h>
+#include <node_sockaddr-inl.h>
+#include <permission/permission.h>
+#include <util-inl.h>
+
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+
+#include <cstring>
+
+namespace node {
+
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Int32;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace dtls {
+
+namespace {
+struct SendReq {
+  uv_udp_send_t req;
+  uv_buf_t buf;
+  std::vector<uint8_t> data;
+};
+}  // namespace
+
+DTLSEndpoint::DTLSEndpoint(Environment* env, Local<Object> wrap)
+    : HandleWrap(env,
+                 wrap,
+                 reinterpret_cast<uv_handle_t*>(&handle_),
+                 PROVIDER_DTLS_ENDPOINT),
+      state_(env->isolate()) {
+  CHECK_EQ(uv_udp_init(env->event_loop(), &handle_), 0);
+  handle_.data = this;
+  MakeWeak();
+}
+
+Local<FunctionTemplate> DTLSEndpoint::GetConstructorTemplate(Environment* env) {
+  auto tmpl = env->dtls_endpoint_constructor_template();
+  if (tmpl.IsEmpty()) {
+    Isolate* isolate = env->isolate();
+    tmpl = NewFunctionTemplate(isolate, New);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "DTLSEndpoint"));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        HandleWrap::kInternalFieldCount);
+
+    SetProtoMethod(isolate, tmpl, "bind", DoBind);
+    SetProtoMethod(isolate, tmpl, "listen", DoListen);
+    SetProtoMethod(isolate, tmpl, "connect", DoConnect);
+    SetProtoMethod(isolate, tmpl, "close", DoClose);
+    SetProtoMethod(isolate, tmpl, "destroy", DoDestroy);
+    SetProtoMethod(isolate, tmpl, "getState", GetState);
+    SetProtoMethod(isolate, tmpl, "getAddress", GetAddress);
+    SetProtoMethod(isolate, tmpl, "setMTU", SetMTU);
+    SetProtoMethod(isolate, tmpl, "setCallbacks", DoSetCallbacks);
+
+    env->set_dtls_endpoint_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void DTLSEndpoint::InitPerContext(Local<Object> target,
+                                  Local<Context> context,
+                                  Environment* env) {
+  SetConstructorFunction(
+      context, target, "DTLSEndpoint", GetConstructorTemplate(env));
+}
+
+void DTLSEndpoint::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(DoBind);
+  registry->Register(DoListen);
+  registry->Register(DoConnect);
+  registry->Register(DoClose);
+  registry->Register(DoDestroy);
+  registry->Register(GetState);
+  registry->Register(GetAddress);
+  registry->Register(SetMTU);
+  registry->Register(DoSetCallbacks);
+}
+
+void DTLSEndpoint::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args.IsConstructCall());
+  new DTLSEndpoint(env, args.This());
+}
+
+int DTLSEndpoint::Bind(const SocketAddress& address) {
+  if (IsHandleClosing()) return UV_EINVAL;
+  if (state_->bound) return UV_EALREADY;
+
+  unsigned int flags = 0;
+  if (address.family() == AF_INET6) {
+    flags |= UV_UDP_IPV6ONLY;
+  }
+
+  int err = uv_udp_bind(&handle_, address.data(), flags);
+  if (err != 0) return err;
+
+  state_->bound = 1;
+
+  // Don't keep the event loop alive unless we're listening or have sessions.
+  uv_unref(reinterpret_cast<uv_handle_t*>(&handle_));
+
+  return 0;
+}
+
+int DTLSEndpoint::Listen(DTLSContext* context) {
+  if (IsHandleClosing()) return UV_EINVAL;
+  if (listening_) return UV_EALREADY;
+
+  server_context_.reset(context);
+  listening_ = true;
+  state_->listening = 1;
+
+  // Start receiving UDP datagrams.
+  int err = uv_udp_recv_start(&handle_, OnAlloc, OnRecv);
+  if (err != 0) {
+    listening_ = false;
+    state_->listening = 0;
+    server_context_.reset();
+    return err;
+  }
+
+  // Ref the handle while listening.
+  uv_ref(reinterpret_cast<uv_handle_t*>(&handle_));
+
+  return 0;
+}
+
+BaseObjectPtr<DTLSSession> DTLSEndpoint::Connect(DTLSContext* context,
+                                                 const SocketAddress& remote) {
+  if (IsHandleClosing()) {
+    THROW_ERR_INVALID_STATE(env(), "Endpoint is closing");
+    return {};
+  }
+
+  // Check if we already have a session for this address.
+  auto it = sessions_.find(remote);
+  if (it != sessions_.end()) {
+    THROW_ERR_INVALID_STATE(env(), "Session already exists for this address");
+    return {};
+  }
+
+  auto session = DTLSSession::Create(
+      env(), this, context->ssl_ctx(), remote, false /* is_server */);
+
+  if (!session) return {};
+
+  sessions_[remote] = session;
+  state_->session_count = sessions_.size();
+
+  // Ref the handle while we have sessions.
+  uv_ref(reinterpret_cast<uv_handle_t*>(&handle_));
+
+  // Start receiving if not already.
+  if (!listening_) {
+    uv_udp_recv_start(&handle_, OnAlloc, OnRecv);
+  }
+
+  // Initiate the DTLS handshake by running Cycle.
+  session->Cycle();
+
+  return session;
+}
+
+int DTLSEndpoint::SendTo(const SocketAddress& dest,
+                         const uint8_t* data,
+                         size_t len) {
+  if (IsHandleClosing()) return UV_EINVAL;
+
+  // Try synchronous send first.
+  uv_buf_t buf =
+      uv_buf_init(const_cast<char*>(reinterpret_cast<const char*>(data)), len);
+  int err = uv_udp_try_send(&handle_, &buf, 1, dest.data());
+
+  if (err == static_cast<int>(len)) {
+    return 0;  // Sent successfully.
+  }
+
+  if (err != UV_EAGAIN && err < 0) {
+    return err;  // Real error.
+  }
+
+  // Async send: copy the data since it won't outlive this call.
+  auto* req = new SendReq();
+  req->data.assign(data, data + len);
+  req->buf = uv_buf_init(reinterpret_cast<char*>(req->data.data()), len);
+
+  err = uv_udp_send(&req->req, &handle_, &req->buf, 1, dest.data(), OnSend);
+  if (err != 0) {
+    delete req;
+    return err;
+  }
+
+  return 0;
+}
+
+void DTLSEndpoint::RemoveSession(const SocketAddress& addr) {
+  sessions_.erase(addr);
+  state_->session_count = sessions_.size();
+
+  // Unref if no more sessions and not listening.
+  if (sessions_.empty() && !listening_ && !IsHandleClosing()) {
+    uv_unref(reinterpret_cast<uv_handle_t*>(&handle_));
+  }
+}
+
+void DTLSEndpoint::CloseGracefully() {
+  if (IsHandleClosing()) return;
+
+  state_->closing = 1;
+
+  // Close all sessions gracefully (this may send close_notify).
+  auto sessions_copy = sessions_;
+  sessions_.clear();
+  state_->session_count = 0;
+  for (auto& [addr, session] : sessions_copy) {
+    session->Close();
+  }
+
+  // Stop listening.
+  if (listening_) {
+    uv_udp_recv_stop(&handle_);
+    listening_ = false;
+    state_->listening = 0;
+  }
+
+  server_context_.reset();
+
+  // HandleWrap::Close() calls uv_close and manages the lifecycle.
+  HandleWrap::Close();
+}
+
+void DTLSEndpoint::Destroy() {
+  if (IsHandleClosing()) return;
+
+  state_->destroyed = 1;
+
+  // Copy session list to avoid iterator invalidation.
+  auto sessions_copy = sessions_;
+  sessions_.clear();
+  state_->session_count = 0;
+  for (auto& [addr, session] : sessions_copy) {
+    session->Destroy();
+  }
+
+  server_context_.reset();
+
+  if (listening_) {
+    uv_udp_recv_stop(&handle_);
+    listening_ = false;
+    state_->listening = 0;
+  }
+
+  HandleWrap::Close();
+}
+
+Local<Function> DTLSEndpoint::GetCallback(int index) const {
+  if (index < 0 || index >= DTLS_CB_COUNT) return Local<Function>();
+  Local<Function> cb = callbacks_[index].Get(env()->isolate());
+  return cb;
+}
+
+void DTLSEndpoint::SetCallbacks(Local<Object> callbacks) {
+  Isolate* isolate = env()->isolate();
+  Local<Context> context = env()->context();
+
+  const char* names[] = {
+      "onEndpointClose",
+      "onEndpointError",
+      "onSessionNew",
+      "onSessionClose",
+      "onSessionError",
+      "onSessionHandshake",
+      "onSessionMessage",
+      "onSessionKeylog",
+      "onSessionTicket",
+  };
+
+  for (int i = 0; i < DTLS_CB_COUNT; i++) {
+    Local<String> name;
+    if (!String::NewFromUtf8(isolate, names[i]).ToLocal(&name)) {
+      THROW_ERR_OPERATION_FAILED(isolate,
+                                 "Failed to create callback name string");
+      return;
+    }
+    Local<Value> val;
+    if (!callbacks->Get(context, name).ToLocal(&val) || !val->IsFunction()) {
+      THROW_ERR_MISSING_ARGS(
+          isolate, ("Missing DTLS callback: " + std::string(names[i])).c_str());
+      return;
+    }
+    callbacks_[i].Reset(isolate, val.As<Function>());
+  }
+}
+
+// --- libuv callbacks ---
+
+void DTLSEndpoint::OnAlloc(uv_handle_t* handle,
+                           size_t suggested_size,
+                           uv_buf_t* buf) {
+  buf->base = new char[65536];
+  buf->len = 65536;
+}
+
+void DTLSEndpoint::OnRecv(uv_udp_t* handle,
+                          ssize_t nread,
+                          const uv_buf_t* buf,
+                          const struct sockaddr* addr,
+                          unsigned int flags) {
+  DTLSEndpoint* endpoint = static_cast<DTLSEndpoint*>(handle->data);
+
+  if (nread == 0 && addr == nullptr) {
+    delete[] buf->base;
+    return;
+  }
+
+  if (nread < 0) {
+    delete[] buf->base;
+    HandleScope handle_scope(endpoint->env()->isolate());
+    Context::Scope context_scope(endpoint->env()->context());
+    Local<Value> argv[] = {
+        String::NewFromUtf8(endpoint->env()->isolate(), uv_strerror(nread))
+            .ToLocalChecked(),
+    };
+    Local<Function> cb = endpoint->GetCallback(DTLS_CB_ENDPOINT_ERROR);
+    if (!cb.IsEmpty()) {
+      endpoint->MakeCallback(cb, 1, argv);
+    }
+    return;
+  }
+
+  if (addr == nullptr) {
+    delete[] buf->base;
+    return;
+  }
+
+  SocketAddress remote(addr);
+  endpoint->ProcessDatagram(
+      reinterpret_cast<const uint8_t*>(buf->base), nread, remote);
+
+  delete[] buf->base;
+}
+
+void DTLSEndpoint::OnSend(uv_udp_send_t* req, int status) {
+  SendReq* send_req = reinterpret_cast<SendReq*>(req);
+  delete send_req;
+}
+
+void DTLSEndpoint::OnClose() {
+  state_->closing = 0;
+  state_->destroyed = 1;
+
+  Local<Function> cb = GetCallback(DTLS_CB_ENDPOINT_CLOSE);
+  if (!cb.IsEmpty()) {
+    Local<Value> argv[] = {};
+    MakeCallback(cb, 0, argv);
+  }
+}
+
+void DTLSEndpoint::ProcessDatagram(const uint8_t* data,
+                                   size_t len,
+                                   const SocketAddress& remote) {
+  if (IsHandleClosing()) return;
+
+  // Look up existing session by remote address.
+  auto it = sessions_.find(remote);
+  if (it != sessions_.end()) {
+    it->second->Receive(data, len);
+    return;
+  }
+
+  // No existing session. If we're in server mode, try to accept.
+  if (listening_ && server_context_) {
+    AcceptConnection(data, len, remote);
+  }
+}
+
+void DTLSEndpoint::AcceptConnection(const uint8_t* data,
+                                    size_t len,
+                                    const SocketAddress& remote) {
+  if (state_->busy) return;
+
+  HandleScope handle_scope(env()->isolate());
+  Context::Scope context_scope(env()->context());
+
+  // Stateless cookie exchange via DTLSv1_listen() for DoS protection.
+  //
+  // The standard OpenSSL DTLS server flow (see s_server.c) is:
+  //   1. Create SSL with BIO_s_datagram() wrapping the UDP socket
+  //   2. DTLSv1_listen(ssl, &peer) -- stateless cookie exchange
+  //   3. Connect the socket to the verified peer
+  //   4. SSL_accept(ssl) -- continue the handshake on the SAME SSL
+  //
+  // We diverge in one key way: we use memory BIOs instead of datagram
+  // BIOs because Node.js manages UDP I/O through libuv (uv_udp_t),
+  // not through raw socket FDs. This means DTLSv1_listen()'s internal
+  // BIO_dgram_get_peer()/set_peer() calls are no-ops -- we provide the
+  // peer address to the cookie callbacks via DTLSContext::current_cookie_peer_
+  // instead. After DTLSv1_listen() returns 1, we hand the SSL (with its
+  // memory BIOs) to a DTLSSession via CreateFromSSL(). The SSL's internal
+  // state machine has been prepared by DTLSv1_listen() to continue the
+  // handshake from TLS_ST_SR_CLNT_HELLO, so Cycle() -> SSL_do_handshake()
+  // immediately produces the ServerHello flight.
+  SSL* tmp_ssl = SSL_new(server_context_->ssl_ctx());
+  if (tmp_ssl == nullptr) return;
+
+  BIO* in = BIO_new(BIO_s_mem());
+  BIO* out = BIO_new(BIO_s_mem());
+  if (in == nullptr || out == nullptr) {
+    BIO_free(in);
+    BIO_free(out);
+    SSL_free(tmp_ssl);
+    return;
+  }
+
+  BIO_set_mem_eof_return(in, -1);
+  BIO_set_mem_eof_return(out, -1);
+  SSL_set_bio(tmp_ssl, in, out);
+  SSL_set_accept_state(tmp_ssl);
+  SSL_set_options(tmp_ssl, SSL_OP_NO_QUERY_MTU | SSL_OP_COOKIE_EXCHANGE);
+  SSL_set_mtu(tmp_ssl, mtu_);
+
+  // Set peer address on context for the cookie callbacks.
+  server_context_->set_cookie_peer(remote);
+
+  BIO_write(in, data, len);
+
+  BIO_ADDR* peer = BIO_ADDR_new();
+  int ret = DTLSv1_listen(tmp_ssl, peer);
+  BIO_ADDR_free(peer);
+
+  if (ret == 0) {
+    // Send HelloVerifyRequest.
+    uint8_t resp_buf[65536];
+    int resp_len;
+    while ((resp_len = BIO_read(out, resp_buf, sizeof(resp_buf))) > 0) {
+      SendTo(remote, resp_buf, resp_len);
+    }
+    SSL_free(tmp_ssl);
+    return;
+  }
+
+  if (ret < 0) {
+    SSL_free(tmp_ssl);
+    return;  // Error — drop packet.
+  }
+
+  // Cookie verified. Hand the SSL (which has already completed cookie
+  // exchange and consumed the ClientHello) to a DTLSSession. Calling
+  // Cycle() will drive SSL_do_handshake to produce the ServerHello.
+  ncrypto::SSLPointer ssl(tmp_ssl);
+
+  auto session =
+      DTLSSession::CreateFromSSL(env(), this, std::move(ssl), in, out, remote);
+
+  if (!session) return;
+
+  sessions_[remote] = session;
+  state_->session_count = sessions_.size();
+
+  uv_ref(reinterpret_cast<uv_handle_t*>(&handle_));
+
+  // Drive the handshake forward — produces ServerHello etc.
+  session->Cycle();
+
+  // Emit the new session to JS.
+  Local<Value> argv[] = {session->object()};
+  Local<Function> cb = GetCallback(DTLS_CB_SESSION_NEW);
+  if (!cb.IsEmpty()) {
+    MakeCallback(cb, 1, argv);
+  }
+}
+
+// --- JS binding methods ---
+
+void DTLSEndpoint::DoBind(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  Environment* env = endpoint->env();
+
+  CHECK(args[0]->IsString());  // host
+  CHECK(args[1]->IsInt32());   // port
+
+  Utf8Value host(env->isolate(), args[0]);
+  int port = args[1].As<Int32>()->Value();
+
+  SocketAddress addr;
+  if (!SocketAddress::New(*host, port, &addr)) {
+    return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid address");
+  }
+
+  int err = endpoint->Bind(addr);
+  if (err != 0) {
+    return THROW_ERR_INVALID_STATE(env, uv_strerror(err));
+  }
+}
+
+void DTLSEndpoint::DoListen(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  Environment* env = endpoint->env();
+
+  THROW_IF_INSUFFICIENT_PERMISSIONS(env, permission::PermissionScope::kNet, "");
+
+  DTLSContext* context;
+  ASSIGN_OR_RETURN_UNWRAP(&context, args[0].As<Object>());
+
+  int err = endpoint->Listen(context);
+  if (err != 0) {
+    return THROW_ERR_INVALID_STATE(env, uv_strerror(err));
+  }
+}
+
+void DTLSEndpoint::DoConnect(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  Environment* env = endpoint->env();
+
+  DTLSContext* context;
+  ASSIGN_OR_RETURN_UNWRAP(&context, args[0].As<Object>());
+
+  CHECK(args[1]->IsString());  // host
+  CHECK(args[2]->IsInt32());   // port
+
+  Utf8Value host(env->isolate(), args[1]);
+  int port = args[2].As<Int32>()->Value();
+
+  SocketAddress remote;
+  if (!SocketAddress::New(*host, port, &remote)) {
+    return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid remote address");
+  }
+
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kNet, remote.ToString());
+
+  auto session = endpoint->Connect(context, remote);
+  if (session) {
+    args.GetReturnValue().Set(session->object());
+  }
+}
+
+void DTLSEndpoint::DoClose(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  endpoint->CloseGracefully();
+}
+
+void DTLSEndpoint::DoDestroy(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  endpoint->Destroy();
+}
+
+void DTLSEndpoint::GetState(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  args.GetReturnValue().Set(endpoint->state_.GetArrayBuffer());
+}
+
+void DTLSEndpoint::GetAddress(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+
+  if (endpoint->IsHandleClosing()) return;
+
+  SocketAddress addr = SocketAddress::FromSockName(endpoint->handle_);
+  Local<Object> obj;
+  if (addr.ToJS(endpoint->env()).ToLocal(&obj)) {
+    args.GetReturnValue().Set(obj);
+  }
+}
+
+void DTLSEndpoint::SetMTU(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+
+  CHECK(args[0]->IsInt32());
+  int mtu = args[0].As<Int32>()->Value();
+  if (mtu < 256 || mtu > 65535) {
+    return THROW_ERR_OUT_OF_RANGE(endpoint->env(),
+                                  "MTU must be between 256 and 65535");
+  }
+  endpoint->mtu_ = mtu;
+}
+
+void DTLSEndpoint::DoSetCallbacks(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  CHECK(args[0]->IsObject());
+  endpoint->SetCallbacks(args[0].As<Object>());
+}
+
+void DTLSEndpoint::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("sessions", sessions_.size());
+}
+
+}  // namespace dtls
+}  // namespace node
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
diff --git a/src/dtls/dtls_endpoint.h b/src/dtls/dtls_endpoint.h
new file mode 100644
index 00000000000000..06ffe4bcc39ed2
--- /dev/null
+++ b/src/dtls/dtls_endpoint.h
@@ -0,0 +1,147 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <aliased_struct.h>
+#include <env.h>
+#include <handle_wrap.h>
+#include <node_sockaddr.h>
+#include <uv.h>
+#include <v8.h>
+
+#include <openssl/ssl.h>
+
+#include <unordered_map>
+
+#include "dtls.h"
+#include "dtls_context.h"
+#include "dtls_session.h"
+
+namespace node::dtls {
+
+// Shared C++ <-> JS state for a DTLS endpoint.
+struct DTLSEndpointStateData {
+  uint8_t bound = 0;
+  uint8_t listening = 0;
+  uint8_t closing = 0;
+  uint8_t destroyed = 0;
+  uint32_t session_count = 0;
+  uint8_t busy = 0;
+};
+
+// DTLSEndpoint manages a single UDP socket and dispatches incoming
+// datagrams to the appropriate DTLSSession based on the remote address.
+// For server mode, it handles stateless cookie exchange via DTLSv1_listen()
+// before creating new sessions.
+class DTLSEndpoint final : public HandleWrap {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerContext(v8::Local<v8::Object> target,
+                             v8::Local<v8::Context> context,
+                             Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  DTLSEndpoint(Environment* env, v8::Local<v8::Object> wrap);
+
+  // Bind the UDP socket to the given address.
+  int Bind(const SocketAddress& address);
+
+  // Start listening for incoming DTLS connections (server mode).
+  // |context| provides the SSL_CTX for creating new sessions.
+  int Listen(DTLSContext* context);
+
+  // Initiate a client connection to the given address.
+  // Returns the created DTLSSession.
+  BaseObjectPtr<DTLSSession> Connect(DTLSContext* context,
+                                     const SocketAddress& remote);
+
+  // Send a raw UDP datagram to the given address.
+  // Called by DTLSSession to send encrypted packets.
+  int SendTo(const SocketAddress& dest, const uint8_t* data, size_t len);
+
+  // Remove a session from the endpoint (called on session close/destroy).
+  void RemoveSession(const SocketAddress& addr);
+
+  // Close the endpoint gracefully (close all sessions first).
+  void CloseGracefully();
+
+  // Immediately destroy the endpoint.
+  void Destroy();
+
+  // Get the JS callback function for a given callback index.
+  v8::Local<v8::Function> GetCallback(int index) const;
+
+  // Set the JS callbacks.
+  void SetCallbacks(v8::Local<v8::Object> callbacks);
+
+  bool is_listening() const { return listening_; }
+  uint32_t mtu() const { return mtu_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(DTLSEndpoint)
+  SET_SELF_SIZE(DTLSEndpoint)
+
+ private:
+  // JS binding methods
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoBind(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoListen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoConnect(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoClose(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoDestroy(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetMTU(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoSetCallbacks(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // libuv callbacks
+  static void OnAlloc(uv_handle_t* handle,
+                      size_t suggested_size,
+                      uv_buf_t* buf);
+  static void OnRecv(uv_udp_t* handle,
+                     ssize_t nread,
+                     const uv_buf_t* buf,
+                     const struct sockaddr* addr,
+                     unsigned int flags);
+  static void OnSend(uv_udp_send_t* req, int status);
+
+  // Called by HandleWrap after uv_close completes.
+  void OnClose() override;
+
+  // Process an incoming datagram.
+  void ProcessDatagram(const uint8_t* data,
+                       size_t len,
+                       const SocketAddress& remote);
+
+  // Handle a new client connection (server mode).
+  void AcceptConnection(const uint8_t* data,
+                        size_t len,
+                        const SocketAddress& remote);
+
+  uv_udp_t handle_;
+
+  // Session table: maps remote address -> session.
+  std::unordered_map<SocketAddress,
+                     BaseObjectPtr<DTLSSession>,
+                     SocketAddress::Hash>
+      sessions_;
+
+  // Server context (set when listening).
+  BaseObjectPtr<DTLSContext> server_context_;
+
+  // JS callbacks
+  v8::Global<v8::Function> callbacks_[DTLS_CB_COUNT];
+
+  AliasedStruct<DTLSEndpointStateData> state_;
+
+  bool listening_ = false;
+  uint32_t mtu_ = 1200;  // Conservative default MTU for data payload
+};
+
+}  // namespace node::dtls
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/dtls/dtls_session.cc b/src/dtls/dtls_session.cc
new file mode 100644
index 00000000000000..f423451a5302b9
--- /dev/null
+++ b/src/dtls/dtls_session.cc
@@ -0,0 +1,672 @@
+#include "dtls_session.h"
+#include "dtls.h"
+#include "dtls_endpoint.h"
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <aliased_struct-inl.h>
+#include <async_wrap-inl.h>
+#include <base_object-inl.h>
+#include <env-inl.h>
+#include <memory_tracker-inl.h>
+#include <node_buffer.h>
+#include <node_errors.h>
+#include <node_sockaddr-inl.h>
+#include <timer_wrap-inl.h>
+#include <util-inl.h>
+
+#include <openssl/err.h>
+#include <openssl/srtp.h>
+#include <openssl/ssl.h>
+
+#include <cstring>
+
+namespace node {
+
+using v8::Context;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace dtls {
+
+DTLSSession::DTLSSession(Environment* env,
+                         Local<Object> wrap,
+                         DTLSEndpoint* endpoint,
+                         ncrypto::SSLPointer ssl,
+                         BIO* enc_in,
+                         BIO* enc_out,
+                         const SocketAddress& remote,
+                         bool is_server)
+    : AsyncWrap(env, wrap, PROVIDER_DTLS_SESSION),
+      endpoint_(endpoint),
+      ssl_(std::move(ssl)),
+      enc_in_(enc_in),
+      enc_out_(enc_out),
+      retransmit_timer_(env,
+                        [this] {
+                          if (destroyed_) return;
+                          int ret = DTLSv1_handle_timeout(ssl_.get());
+                          if (ret < 0) {
+                            // Handshake timeout expired.
+                            HandleScope hs(this->env()->isolate());
+                            Context::Scope cs(this->env()->context());
+                            Local<Value> argv[] = {
+                                String::NewFromUtf8(this->env()->isolate(),
+                                                    "DTLS handshake timeout")
+                                    .ToLocalChecked(),
+                            };
+                            EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);
+                            return;
+                          }
+                          Cycle();
+                        }),
+      remote_address_(remote),
+      is_server_(is_server),
+      state_(env->isolate()) {
+  MakeWeak();
+  retransmit_timer_.Unref();
+
+  // Update shared state.
+  state_->handshaking = 1;
+  state_->open = 0;
+
+  // Store this session in SSL app data for callbacks.
+  SSL_set_app_data(ssl_.get(), this);
+
+  // Enable keylog for TLS key export (useful for Wireshark debugging).
+  SSL_CTX_set_keylog_callback(SSL_get_SSL_CTX(ssl_.get()), SSLKeylogCallback);
+
+  // Set the MTU on the SSL object.
+  SSL_set_mtu(ssl_.get(), endpoint->mtu());
+}
+
+DTLSSession::~DTLSSession() = default;
+
+Local<FunctionTemplate> DTLSSession::GetConstructorTemplate(Environment* env) {
+  auto tmpl = env->dtls_session_constructor_template();
+  if (tmpl.IsEmpty()) {
+    Isolate* isolate = env->isolate();
+    tmpl = NewFunctionTemplate(isolate, New);
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "DTLSSession"));
+    tmpl->InstanceTemplate()->SetInternalFieldCount(
+        AsyncWrap::kInternalFieldCount);
+
+    SetProtoMethod(isolate, tmpl, "send", DoSend);
+    SetProtoMethod(isolate, tmpl, "close", DoClose);
+    SetProtoMethod(isolate, tmpl, "destroy", DoDestroy);
+    SetProtoMethod(isolate, tmpl, "getState", GetState);
+    SetProtoMethod(isolate, tmpl, "getRemoteAddress", GetRemoteAddress);
+    SetProtoMethod(isolate, tmpl, "getProtocol", GetProtocol);
+    SetProtoMethod(isolate, tmpl, "getCipher", GetCipher);
+    SetProtoMethod(isolate, tmpl, "getPeerCertificate", GetPeerCertificate);
+    SetProtoMethod(isolate, tmpl, "getALPNProtocol", GetALPNProtocol);
+    SetProtoMethod(isolate, tmpl, "exportKeyingMaterial", ExportKeyingMaterial);
+    SetProtoMethod(isolate, tmpl, "getSRTPProfile", GetSRTPProfile);
+    SetProtoMethod(isolate, tmpl, "setServername", SetServername);
+    SetProtoMethod(isolate, tmpl, "getServername", GetServername);
+
+    env->set_dtls_session_constructor_template(tmpl);
+  }
+  return tmpl;
+}
+
+void DTLSSession::InitPerContext(Local<Object> target,
+                                 Local<Context> context,
+                                 Environment* env) {
+  SetConstructorFunction(
+      context, target, "DTLSSession", GetConstructorTemplate(env));
+}
+
+void DTLSSession::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(DoSend);
+  registry->Register(DoClose);
+  registry->Register(DoDestroy);
+  registry->Register(GetState);
+  registry->Register(GetRemoteAddress);
+  registry->Register(GetProtocol);
+  registry->Register(GetCipher);
+  registry->Register(GetPeerCertificate);
+  registry->Register(GetALPNProtocol);
+  registry->Register(ExportKeyingMaterial);
+  registry->Register(GetSRTPProfile);
+  registry->Register(SetServername);
+  registry->Register(GetServername);
+}
+
+BaseObjectPtr<DTLSSession> DTLSSession::Create(Environment* env,
+                                               DTLSEndpoint* endpoint,
+                                               SSL_CTX* ssl_ctx,
+                                               const SocketAddress& remote,
+                                               bool is_server) {
+  // Create the SSL object.
+  SSL* ssl_raw = SSL_new(ssl_ctx);
+  if (ssl_raw == nullptr) {
+    THROW_ERR_CRYPTO_OPERATION_FAILED(env, "SSL_new failed");
+    return {};
+  }
+
+  ncrypto::SSLPointer ssl(ssl_raw);
+
+  // Create memory BIOs for encrypted data I/O.
+  BIO* enc_in = BIO_new(BIO_s_mem());
+  BIO* enc_out = BIO_new(BIO_s_mem());
+  if (enc_in == nullptr || enc_out == nullptr) {
+    BIO_free(enc_in);
+    BIO_free(enc_out);
+    THROW_ERR_CRYPTO_OPERATION_FAILED(env, "BIO_new failed");
+    return {};
+  }
+
+  // Make the BIOs non-blocking.
+  BIO_set_mem_eof_return(enc_in, -1);
+  BIO_set_mem_eof_return(enc_out, -1);
+
+  // Associate BIOs with the SSL object. SSL_set_bio takes ownership.
+  SSL_set_bio(ssl.get(), enc_in, enc_out);
+
+  // Set the MTU (since we use SSL_OP_NO_QUERY_MTU).
+  SSL_set_mtu(ssl.get(), endpoint->mtu());
+
+  // Set the handshake direction.
+  if (is_server) {
+    SSL_set_accept_state(ssl.get());
+  } else {
+    SSL_set_connect_state(ssl.get());
+  }
+
+  // Create the JS wrapper object.
+  Local<FunctionTemplate> tmpl = GetConstructorTemplate(env);
+  Local<Object> obj;
+  if (!tmpl->InstanceTemplate()->NewInstance(env->context()).ToLocal(&obj)) {
+    return {};
+  }
+
+  auto session = MakeBaseObject<DTLSSession>(
+      env, obj, endpoint, std::move(ssl), enc_in, enc_out, remote, is_server);
+
+  return session;
+}
+
+BaseObjectPtr<DTLSSession> DTLSSession::CreateFromSSL(
+    Environment* env,
+    DTLSEndpoint* endpoint,
+    ncrypto::SSLPointer ssl,
+    BIO* enc_in,
+    BIO* enc_out,
+    const SocketAddress& remote) {
+  Local<FunctionTemplate> tmpl = GetConstructorTemplate(env);
+  Local<Object> obj;
+  if (!tmpl->InstanceTemplate()->NewInstance(env->context()).ToLocal(&obj)) {
+    return {};
+  }
+
+  return MakeBaseObject<DTLSSession>(env,
+                                     obj,
+                                     endpoint,
+                                     std::move(ssl),
+                                     enc_in,
+                                     enc_out,
+                                     remote,
+                                     true /* is_server */);
+}
+
+void DTLSSession::New(const FunctionCallbackInfo<Value>& args) {
+  // Sessions are created internally via DTLSSession::Create,
+  // not directly from JS.
+  CHECK(args.IsConstructCall());
+}
+
+void DTLSSession::Receive(const uint8_t* data, size_t len) {
+  if (destroyed_ || closed_) return;
+
+  // Write the encrypted datagram into enc_in_ BIO.
+  int written = BIO_write(enc_in_, data, len);
+  if (written <= 0) return;
+
+  // Run the state machine.
+  Cycle();
+}
+
+void DTLSSession::Cycle() {
+  if (destroyed_) return;
+
+  // Prevent infinite recursion.
+  if (++cycle_depth_ > 1) {
+    cycle_depth_--;
+    return;
+  }
+
+  HandleScope handle_scope(env()->isolate());
+  Context::Scope context_scope(env()->context());
+
+  // If handshake is not yet complete, drive it forward.
+  if (!handshake_complete_) {
+    int ret = SSL_do_handshake(ssl_.get());
+    if (ret <= 0) {
+      int err = SSL_get_error(ssl_.get(), ret);
+      if (err == SSL_ERROR_SSL) {
+        unsigned long ossl_err = ERR_get_error();  // NOLINT(runtime/int)
+        char err_buf[256];
+        ERR_error_string_n(ossl_err, err_buf, sizeof(err_buf));
+        Local<Value> argv[] = {
+            String::NewFromUtf8(env()->isolate(), err_buf).ToLocalChecked(),
+        };
+        EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);
+        cycle_depth_--;
+        return;
+      }
+      // SSL_ERROR_WANT_READ/WRITE is normal during handshake.
+    }
+    // Flush any handshake data produced.
+    EncOut();
+
+    // Check if handshake just completed.
+    if (SSL_is_init_finished(ssl_.get()) && !handshake_complete_) {
+      handshake_complete_ = true;
+      state_->handshaking = 0;
+      state_->open = 1;
+
+      Local<Value> argv[] = {
+          String::NewFromUtf8(env()->isolate(), SSL_get_version(ssl_.get()))
+              .ToLocalChecked(),
+      };
+      EmitCallback(DTLS_CB_SESSION_HANDSHAKE, 1, argv);
+    }
+  }
+
+  // Read any decrypted application data.
+  ClearOut();
+  // Flush any pending encrypted output.
+  EncOut();
+
+  UpdateTimer();
+  cycle_depth_--;
+}
+
+void DTLSSession::ClearOut() {
+  if (destroyed_) return;
+
+  // Try to read decrypted application data from OpenSSL.
+  uint8_t buf[65536];
+  int read;
+
+  while ((read = SSL_read(ssl_.get(), buf, sizeof(buf))) > 0) {
+    // Emit the data to JS via callback.
+    Local<Value> argv[] = {
+        Buffer::Copy(env(), reinterpret_cast<const char*>(buf), read)
+            .ToLocalChecked(),
+    };
+    EmitCallback(DTLS_CB_SESSION_MESSAGE, 1, argv);
+  }
+
+  int err = SSL_get_error(ssl_.get(), read);
+  switch (err) {
+    case SSL_ERROR_WANT_READ:
+    case SSL_ERROR_WANT_WRITE:
+      // Normal - need more data or need to flush.
+      break;
+
+    case SSL_ERROR_ZERO_RETURN:
+      // Peer sent close_notify.
+      if (!closed_) {
+        closed_ = true;
+        state_->closing = 1;
+        state_->open = 0;
+        // Send our close_notify back.
+        SSL_shutdown(ssl_.get());
+        EncOut();
+        Local<Value> argv[] = {};
+        EmitCallback(DTLS_CB_SESSION_CLOSE, 0, argv);
+      }
+      break;
+
+    case SSL_ERROR_SSL: {
+      // SSL error during handshake or data exchange.
+      unsigned long ossl_err = ERR_get_error();  // NOLINT(runtime/int)
+      char err_buf[256];
+      ERR_error_string_n(ossl_err, err_buf, sizeof(err_buf));
+      Local<Value> argv[] = {
+          String::NewFromUtf8(env()->isolate(), err_buf).ToLocalChecked(),
+      };
+      EmitCallback(DTLS_CB_SESSION_ERROR, 1, argv);
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
+void DTLSSession::EncOut() {
+  if (destroyed_) return;
+  auto ep = endpoint_.get();
+  if (ep == nullptr) return;
+
+  // Read encrypted data from enc_out_ BIO and send via UDP.
+  // Read in a loop since there may be multiple DTLS records.
+  uint8_t buf[65536];
+  int read;
+  while ((read = BIO_read(enc_out_, buf, sizeof(buf))) > 0) {
+    ep->SendTo(remote_address_, buf, read);
+  }
+}
+
+void DTLSSession::UpdateTimer() {
+  if (destroyed_) return;
+
+  struct timeval tv;
+  if (DTLSv1_get_timeout(ssl_.get(), &tv)) {
+    uint64_t timeout_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    if (timeout_ms == 0) timeout_ms = 1;  // Minimum 1ms.
+    retransmit_timer_.Update(timeout_ms);
+  } else {
+    // No timeout needed (handshake complete or not started).
+    retransmit_timer_.Stop();
+  }
+}
+
+int DTLSSession::Send(const uint8_t* data, size_t len) {
+  if (destroyed_ || closed_) return -1;
+
+  if (!handshake_complete_) {
+    // Can't send application data before handshake.
+    return -1;
+  }
+
+  int written = SSL_write(ssl_.get(), data, len);
+  if (written > 0) {
+    EncOut();
+  }
+  return written;
+}
+
+void DTLSSession::Close() {
+  if (destroyed_ || closed_) return;
+
+  closed_ = true;
+  state_->closing = 1;
+
+  // Send close_notify.
+  int ret = SSL_shutdown(ssl_.get());
+  if (ret == 0) {
+    // Need to call again for bidirectional shutdown.
+    SSL_shutdown(ssl_.get());
+  }
+  EncOut();
+
+  retransmit_timer_.Stop();
+
+  state_->open = 0;
+
+  // Notify JS.
+  HandleScope handle_scope(env()->isolate());
+  Context::Scope context_scope(env()->context());
+  Local<Value> argv[] = {};
+  EmitCallback(DTLS_CB_SESSION_CLOSE, 0, argv);
+}
+
+void DTLSSession::Destroy() {
+  if (destroyed_) return;
+  destroyed_ = true;
+  closed_ = true;
+
+  state_->destroyed = 1;
+  state_->open = 0;
+  state_->handshaking = 0;
+
+  retransmit_timer_.Close();
+
+  // Promote to strong ref to keep endpoint alive during removal,
+  // then release our weak pointer.
+  BaseObjectPtr<DTLSEndpoint> ep = endpoint_;
+  endpoint_.reset();
+  if (ep) ep->RemoveSession(remote_address_);
+}
+
+void DTLSSession::SSLKeylogCallback(const SSL* ssl, const char* line) {
+  DTLSSession* session = static_cast<DTLSSession*>(SSL_get_app_data(ssl));
+  if (session == nullptr || session->destroyed_) return;
+
+  HandleScope handle_scope(session->env()->isolate());
+  Context::Scope context_scope(session->env()->context());
+
+  Local<Value> argv[] = {
+      String::NewFromUtf8(session->env()->isolate(), line).ToLocalChecked(),
+  };
+  session->EmitCallback(DTLS_CB_SESSION_KEYLOG, 1, argv);
+}
+
+MaybeLocal<Value> DTLSSession::EmitCallback(int cb_index,
+                                            int argc,
+                                            Local<Value>* argv) {
+  auto ep = endpoint_.get();
+  if (ep == nullptr) return MaybeLocal<Value>();
+  Local<Function> cb = ep->GetCallback(cb_index);
+  if (cb.IsEmpty()) return MaybeLocal<Value>();
+
+  return MakeCallback(cb, argc, argv);
+}
+
+// --- JS binding methods ---
+
+void DTLSSession::DoSend(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  if (!Buffer::HasInstance(args[0])) {
+    return THROW_ERR_INVALID_ARG_TYPE(session->env(), "data must be a Buffer");
+  }
+
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(Buffer::Data(args[0]));
+  size_t len = Buffer::Length(args[0]);
+
+  int written = session->Send(data, len);
+  args.GetReturnValue().Set(written);
+}
+
+void DTLSSession::DoClose(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  session->Close();
+}
+
+void DTLSSession::DoDestroy(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  session->Destroy();
+}
+
+void DTLSSession::GetState(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  args.GetReturnValue().Set(session->state_.GetArrayBuffer());
+}
+
+void DTLSSession::GetRemoteAddress(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = session->env();
+
+  Local<Object> obj;
+  if (session->remote_address_.ToJS(env).ToLocal(&obj)) {
+    args.GetReturnValue().Set(obj);
+  }
+}
+
+void DTLSSession::GetProtocol(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  const char* version = SSL_get_version(session->ssl_.get());
+  args.GetReturnValue().Set(
+      String::NewFromUtf8(session->env()->isolate(), version).ToLocalChecked());
+}
+
+void DTLSSession::GetCipher(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = session->env();
+
+  const SSL_CIPHER* cipher = SSL_get_current_cipher(session->ssl_.get());
+  if (cipher == nullptr) return;
+
+  Local<Object> info = Object::New(env->isolate());
+  info->Set(env->context(),
+            FIXED_ONE_BYTE_STRING(env->isolate(), "name"),
+            String::NewFromUtf8(env->isolate(), SSL_CIPHER_get_name(cipher))
+                .ToLocalChecked())
+      .Check();
+  info->Set(
+          env->context(),
+          FIXED_ONE_BYTE_STRING(env->isolate(), "standardName"),
+          String::NewFromUtf8(env->isolate(), SSL_CIPHER_standard_name(cipher))
+              .ToLocalChecked())
+      .Check();
+  info->Set(env->context(),
+            FIXED_ONE_BYTE_STRING(env->isolate(), "version"),
+            String::NewFromUtf8(env->isolate(), SSL_CIPHER_get_version(cipher))
+                .ToLocalChecked())
+      .Check();
+
+  args.GetReturnValue().Set(info);
+}
+
+void DTLSSession::GetPeerCertificate(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = session->env();
+
+  X509* peer_cert = SSL_get0_peer_certificate(session->ssl_.get());
+  if (peer_cert == nullptr) return;
+
+  // Return the PEM-encoded certificate.
+  BIO* bio = BIO_new(BIO_s_mem());
+  if (PEM_write_bio_X509(bio, peer_cert)) {
+    char* data;
+    long len = BIO_get_mem_data(bio, &data);  // NOLINT(runtime/int)
+    if (len > 0) {
+      args.GetReturnValue().Set(
+          String::NewFromUtf8(
+              env->isolate(), data, v8::NewStringType::kNormal, len)
+              .ToLocalChecked());
+    }
+  }
+  BIO_free(bio);
+}
+
+void DTLSSession::GetALPNProtocol(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  const unsigned char* alpn = nullptr;
+  unsigned int alpn_len = 0;
+  SSL_get0_alpn_selected(session->ssl_.get(), &alpn, &alpn_len);
+
+  if (alpn != nullptr && alpn_len > 0) {
+    args.GetReturnValue().Set(
+        String::NewFromUtf8(session->env()->isolate(),
+                            reinterpret_cast<const char*>(alpn),
+                            v8::NewStringType::kNormal,
+                            alpn_len)
+            .ToLocalChecked());
+  }
+}
+
+void DTLSSession::ExportKeyingMaterial(
+    const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  Environment* env = session->env();
+
+  if (!args[0]->IsNumber() || !args[1]->IsString()) {
+    return THROW_ERR_INVALID_ARG_TYPE(
+        env, "Expected (length: number, label: string[, context: Buffer])");
+  }
+
+  int length = args[0]->Int32Value(env->context()).FromJust();
+  Utf8Value label(env->isolate(), args[1]);
+
+  const uint8_t* context_value = nullptr;
+  size_t context_len = 0;
+  bool use_context = false;
+
+  if (args.Length() > 2 && Buffer::HasInstance(args[2])) {
+    context_value = reinterpret_cast<const uint8_t*>(Buffer::Data(args[2]));
+    context_len = Buffer::Length(args[2]);
+    use_context = true;
+  }
+
+  std::vector<uint8_t> out(length);
+  int ret = SSL_export_keying_material(session->ssl_.get(),
+                                       out.data(),
+                                       length,
+                                       *label,
+                                       label.length(),
+                                       context_value,
+                                       context_len,
+                                       use_context ? 1 : 0);
+
+  if (ret != 1) {
+    return THROW_ERR_CRYPTO_OPERATION_FAILED(
+        env, "SSL_export_keying_material failed");
+  }
+
+  args.GetReturnValue().Set(
+      Buffer::Copy(env, reinterpret_cast<const char*>(out.data()), length)
+          .ToLocalChecked());
+}
+
+void DTLSSession::GetSRTPProfile(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  const SRTP_PROTECTION_PROFILE* profile =
+      SSL_get_selected_srtp_profile(session->ssl_.get());
+
+  if (profile != nullptr) {
+    args.GetReturnValue().Set(
+        String::NewFromUtf8(session->env()->isolate(), profile->name)
+            .ToLocalChecked());
+  }
+}
+
+void DTLSSession::SetServername(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  CHECK(args[0]->IsString());
+  Utf8Value servername(session->env()->isolate(), args[0]);
+  SSL_set_tlsext_host_name(session->ssl_.get(), *servername);
+}
+
+void DTLSSession::GetServername(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+  const char* servername =
+      SSL_get_servername(session->ssl_.get(), TLSEXT_NAMETYPE_host_name);
+  if (servername != nullptr) {
+    args.GetReturnValue().Set(
+        String::NewFromUtf8(session->env()->isolate(), servername)
+            .ToLocalChecked());
+  }
+}
+
+void DTLSSession::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackField("remote_address", remote_address_);
+}
+
+}  // namespace dtls
+}  // namespace node
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
diff --git a/src/dtls/dtls_session.h b/src/dtls/dtls_session.h
new file mode 100644
index 00000000000000..c4dee0c36d53dd
--- /dev/null
+++ b/src/dtls/dtls_session.h
@@ -0,0 +1,167 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#if HAVE_OPENSSL && HAVE_DTLS
+
+#include <aliased_struct.h>
+#include <async_wrap.h>
+#include <base_object.h>
+#include <env.h>
+#include <ncrypto.h>
+#include <node_sockaddr.h>
+#include <timer_wrap.h>
+#include <uv.h>
+#include <v8.h>
+
+#include <openssl/bio.h>
+#include <openssl/ssl.h>
+
+namespace node::dtls {
+
+class DTLSEndpoint;
+
+// Shared C++ <-> JS state for a DTLS session.
+struct DTLSSessionStateData {
+  uint8_t handshaking = 0;
+  uint8_t open = 0;
+  uint8_t closing = 0;
+  uint8_t destroyed = 0;
+  uint8_t has_message_listener = 0;
+};
+
+// DTLSSession represents a single DTLS association with a remote peer.
+// It wraps an OpenSSL SSL* object configured for DTLS, using memory BIOs
+// to interface with the endpoint's UDP socket.
+class DTLSSession final : public AsyncWrap {
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void InitPerContext(v8::Local<v8::Object> target,
+                             v8::Local<v8::Context> context,
+                             Environment* env);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  // Create a new DTLS session.
+  // |endpoint| - the owning endpoint (for sending packets)
+  // |ssl_ctx| - the SSL_CTX to create the SSL* from
+  // |remote| - the peer address
+  // |is_server| - true if this is a server-side session
+  static BaseObjectPtr<DTLSSession> Create(Environment* env,
+                                           DTLSEndpoint* endpoint,
+                                           SSL_CTX* ssl_ctx,
+                                           const SocketAddress& remote,
+                                           bool is_server);
+
+  // Create a session from an already-initialized SSL object.
+  // Used by the server after DTLSv1_listen() returns 1 — the SSL
+  // has already verified the cookie and is ready to continue.
+  static BaseObjectPtr<DTLSSession> CreateFromSSL(Environment* env,
+                                                  DTLSEndpoint* endpoint,
+                                                  ncrypto::SSLPointer ssl,
+                                                  BIO* enc_in,
+                                                  BIO* enc_out,
+                                                  const SocketAddress& remote);
+
+  ~DTLSSession() override;
+
+  // Called by the endpoint when a datagram arrives from this session's peer.
+  void Receive(const uint8_t* data, size_t len);
+
+  // Send application data to the peer.
+  int Send(const uint8_t* data, size_t len);
+
+  // Initiate a graceful shutdown (sends close_notify).
+  void Close();
+
+  // Immediately destroy the session without sending close_notify.
+  void Destroy();
+
+  const SocketAddress& remote_address() const { return remote_address_; }
+  bool is_server() const { return is_server_; }
+  bool is_handshake_complete() const { return handshake_complete_; }
+  bool is_closed() const { return closed_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(DTLSSession)
+  SET_SELF_SIZE(DTLSSession)
+
+  // Public constructor required by MakeBaseObject<>.
+  DTLSSession(Environment* env,
+              v8::Local<v8::Object> wrap,
+              DTLSEndpoint* endpoint,
+              ncrypto::SSLPointer ssl,
+              BIO* enc_in,
+              BIO* enc_out,
+              const SocketAddress& remote,
+              bool is_server);
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoSend(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoClose(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoDestroy(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetRemoteAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCipher(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPeerCertificate(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetALPNProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ExportKeyingMaterial(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSRTPProfile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetServername(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetServername(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ public:
+  // The core state machine pump. Processes pending OpenSSL I/O:
+  //   1. ClearOut() - SSL_read() -> emit decrypted data to JS
+  //   2. ClearIn()  - SSL_write() pending cleartext
+  //   3. EncOut()   - read enc_out_ BIO -> send via endpoint UDP
+  //   4. UpdateTimer() - schedule retransmit timer if needed
+  void Cycle();
+
+ private:
+  // Read decrypted application data from OpenSSL and emit to JS.
+  void ClearOut();
+
+  // Flush encrypted data from enc_out_ BIO and send via the endpoint.
+  void EncOut();
+
+  // Update the DTLS retransmission timer based on OpenSSL's timeout.
+  void UpdateTimer();
+
+  // OpenSSL keylog callback.
+  static void SSLKeylogCallback(const SSL* ssl, const char* line);
+
+  // Emit a callback to JS via the endpoint's callback dispatch.
+  v8::MaybeLocal<v8::Value> EmitCallback(int cb_index,
+                                         int argc,
+                                         v8::Local<v8::Value>* argv);
+
+  BaseObjectWeakPtr<DTLSEndpoint> endpoint_;
+  ncrypto::SSLPointer ssl_;
+
+  // Memory BIOs: encrypted data flows through these.
+  // enc_in_: network datagrams written here -> SSL_read() extracts cleartext
+  // enc_out_: SSL_write() puts ciphertext here -> we read and send via UDP
+  BIO* enc_in_ = nullptr;
+  BIO* enc_out_ = nullptr;
+
+  TimerWrapHandle retransmit_timer_;
+
+  SocketAddress remote_address_;
+  bool is_server_;
+  bool handshake_complete_ = false;
+  bool closed_ = false;
+  bool destroyed_ = false;
+  int cycle_depth_ = 0;
+
+  AliasedStruct<DTLSSessionStateData> state_;
+};
+
+}  // namespace node::dtls
+
+#endif  // HAVE_OPENSSL && HAVE_DTLS
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/env_properties.h b/src/env_properties.h
index 6530f89ec918ac..113cc066ab2c5d 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -415,6 +415,9 @@
   V(ephemeral_key_template, v8::DictionaryTemplate)                            \
   V(dir_instance_template, v8::ObjectTemplate)                                 \
   V(dns_ns_record_template, v8::DictionaryTemplate)                            \
+  V(dtls_context_constructor_template, v8::FunctionTemplate)                   \
+  V(dtls_endpoint_constructor_template, v8::FunctionTemplate)                  \
+  V(dtls_session_constructor_template, v8::FunctionTemplate)                   \
   V(fd_constructor_template, v8::ObjectTemplate)                               \
   V(fdclose_constructor_template, v8::ObjectTemplate)                          \
   V(ffi_dynamic_library_constructor_template, v8::FunctionTemplate)            \
diff --git a/src/node_binding.cc b/src/node_binding.cc
index ee6fda2947db77..6ba22f5519b4c4 100644
--- a/src/node_binding.cc
+++ b/src/node_binding.cc
@@ -106,6 +106,7 @@
   NODE_BUILTIN_ICU_BINDINGS(V)                                                 \
   NODE_BUILTIN_PROFILER_BINDINGS(V)                                            \
   NODE_BUILTIN_DEBUG_BINDINGS(V)                                               \
+  NODE_BUILTIN_DTLS_BINDINGS(V)                                                \
   NODE_BUILTIN_QUIC_BINDINGS(V)                                                \
   NODE_BUILTIN_SQLITE_BINDINGS(V)                                              \
   NODE_BUILTIN_FFI_BINDINGS(V)
diff --git a/src/node_binding.h b/src/node_binding.h
index d785ccc2238c71..b05c68ad07260f 100644
--- a/src/node_binding.h
+++ b/src/node_binding.h
@@ -36,6 +36,12 @@ static_assert(static_cast<int>(NM_F_LINKED) ==
 #define NODE_BUILTIN_QUIC_BINDINGS(V)
 #endif
 
+#if HAVE_OPENSSL && HAVE_DTLS
+#define NODE_BUILTIN_DTLS_BINDINGS(V) V(dtls)
+#else
+#define NODE_BUILTIN_DTLS_BINDINGS(V)
+#endif
+
 #if HAVE_SQLITE
 #define NODE_BUILTIN_SQLITE_BINDINGS(V)                                        \
   V(sqlite)                                                                    \
@@ -71,7 +77,8 @@ static_assert(static_cast<int>(NM_F_LINKED) ==
   V(url)                                                                       \
   V(worker)                                                                    \
   NODE_BUILTIN_ICU_BINDINGS(V)                                                 \
-  NODE_BUILTIN_QUIC_BINDINGS(V)
+  NODE_BUILTIN_QUIC_BINDINGS(V)                                                \
+  NODE_BUILTIN_DTLS_BINDINGS(V)
 
 #define NODE_BINDING_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags)          \
   static node::node_module _module = {                                         \
diff --git a/src/node_builtins.cc b/src/node_builtins.cc
index b098a41cca9ea4..63dde770cc0195 100644
--- a/src/node_builtins.cc
+++ b/src/node_builtins.cc
@@ -140,9 +140,14 @@ BuiltinLoader::BuiltinCategories BuiltinLoader::GetBuiltinCategories() const {
         "internal/quic/quic", "internal/quic/symbols", "internal/quic/stats",
         "internal/quic/state",
 #endif  // !OPENSSL_NO_QUIC
+#if HAVE_DTLS
+        "internal/dtls/dtls", "internal/dtls/symbols", "internal/dtls/stats",
+        "internal/dtls/state",
+#endif  // HAVE_DTLS
 #if !HAVE_FFI
         "internal/ffi-shared-buffer",
 #endif                  // !HAVE_FFI
+        "dtls",         // Experimental.
         "ffi",          // Experimental.
         "quic",         // Experimental.
         "sqlite",       // Experimental.
diff --git a/src/node_options.cc b/src/node_options.cc
index 99c5a7dbe48200..bcb3819a643ede 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -610,6 +610,15 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "experimental iterable streams API (node:stream/iter)",
             &EnvironmentOptions::experimental_stream_iter,
             kAllowedInEnvvar);
+  AddOption("--experimental-dtls",
+#if HAVE_DTLS
+            "experimental DTLS support",
+            &EnvironmentOptions::experimental_dtls,
+#else
+            "" /* undocumented when no-op */,
+            NoOp{},
+#endif
+            kAllowedInEnvvar);
   AddOption("--experimental-quic",
 #ifndef OPENSSL_NO_QUIC
             "experimental QUIC support",
diff --git a/src/node_options.h b/src/node_options.h
index c69da1c9c313b5..3e6ecc51c78fec 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -133,6 +133,7 @@ class EnvironmentOptions : public Options {
   bool experimental_sqlite = HAVE_SQLITE;
   bool experimental_stream_iter = EXPERIMENTALS_DEFAULT_VALUE;
   bool webstorage = HAVE_SQLITE;
+  bool experimental_dtls = EXPERIMENTALS_DEFAULT_VALUE;
   bool experimental_quic = EXPERIMENTALS_DEFAULT_VALUE;
   std::string localstorage_file;
   bool experimental_global_navigator = true;
diff --git a/test/common/index.js b/test/common/index.js
index 09962cecd31932..7301ada71067b9 100755
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -72,6 +72,7 @@ const hasInspector = Boolean(process.features.inspector);
 const hasSQLite = Boolean(process.versions.sqlite);
 const hasFFI = Boolean(process.config.variables.node_use_ffi);
 
+const hasDtls = hasCrypto && !!process.features.dtls;
 const hasQuic = hasCrypto && !!process.features.quic;
 
 const hasLocalStorage = (() => {
@@ -984,6 +985,7 @@ const common = {
   hasTemporal,
   hasFullICU,
   hasCrypto,
+  hasDtls,
   hasQuic,
   hasInspector,
   hasSQLite,
diff --git a/test/common/index.mjs b/test/common/index.mjs
index d42172ff18f984..0bece9113a13db 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -16,6 +16,7 @@ const {
   getBufferSources,
   getTTYfd,
   hasCrypto,
+  hasDtls,
   hasQuic,
   hasInspector,
   hasSQLite,
@@ -73,6 +74,7 @@ export {
   getPort,
   getTTYfd,
   hasCrypto,
+  hasDtls,
   hasQuic,
   hasInspector,
   hasSQLite,
diff --git a/test/doctool/test-make-doc.mjs b/test/doctool/test-make-doc.mjs
index e7a6f1b85e75f8..555193227672cc 100644
--- a/test/doctool/test-make-doc.mjs
+++ b/test/doctool/test-make-doc.mjs
@@ -46,7 +46,7 @@ const expectedJsons = linkedHtmls
                        .map((name) => name.replace('.html', '.json'));
 const expectedDocs = linkedHtmls.concat(expectedJsons);
 const renamedDocs = ['policy.json', 'policy.html'];
-const skipedDocs = ['quic.json', 'quic.html'];
+const skipedDocs = ['dtls.json', 'dtls.html', 'quic.json', 'quic.html'];
 
 // Test that all the relative links in the TOC match to the actual documents.
 for (const expectedDoc of expectedDocs) {
diff --git a/test/parallel/test-dtls-alpn.mjs b/test/parallel/test-dtls-alpn.mjs
new file mode 100644
index 00000000000000..b51721760fdfad
--- /dev/null
+++ b/test/parallel/test-dtls-alpn.mjs
@@ -0,0 +1,56 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: ALPN negotiation in DTLS.
+
+import { hasCrypto, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { strictEqual } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const serverAlpnChecked = Promise.withResolvers();
+
+const endpoint = listen(mustCall(async (session) => {
+  session.onmessage = () => {};
+  await session.opened;
+  // Server should see the negotiated ALPN protocol.
+  strictEqual(session.alpnProtocol, 'coap');
+  serverAlpnChecked.resolve();
+}), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+  alpn: ['coap', 'h2'],
+});
+
+const session = connect('127.0.0.1', endpoint.address.port, {
+  ca: [ca.toString()],
+  rejectUnauthorized: false,
+  alpn: ['coap'],
+});
+
+await session.opened;
+
+// Client should see the negotiated protocol.
+strictEqual(session.alpnProtocol, 'coap');
+
+await serverAlpnChecked.promise;
+
+await session.close();
+await endpoint.close();
diff --git a/test/parallel/test-dtls-async-dispose.mjs b/test/parallel/test-dtls-async-dispose.mjs
new file mode 100644
index 00000000000000..f6c46c6168b187
--- /dev/null
+++ b/test/parallel/test-dtls-async-dispose.mjs
@@ -0,0 +1,50 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: Symbol.asyncDispose for DTLSEndpoint and DTLSSession.
+
+import { hasCrypto, skip, mustCall, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { strictEqual } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const endpoint = listen(mustCall((session) => {
+  session.onmessage = mustNotCall();
+}), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+const session = connect('127.0.0.1', endpoint.address.port, {
+  ca: [ca.toString()],
+  rejectUnauthorized: false,
+});
+
+await session.opened;
+
+// Test that Symbol.asyncDispose exists.
+strictEqual(typeof session[Symbol.asyncDispose], 'function');
+strictEqual(typeof endpoint[Symbol.asyncDispose], 'function');
+
+// Dispose the session.
+await session[Symbol.asyncDispose]();
+
+// Dispose the endpoint.
+await endpoint[Symbol.asyncDispose]();
diff --git a/test/parallel/test-dtls-basic.mjs b/test/parallel/test-dtls-basic.mjs
new file mode 100644
index 00000000000000..54f2c5b8e081ac
--- /dev/null
+++ b/test/parallel/test-dtls-basic.mjs
@@ -0,0 +1,90 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: Basic DTLS handshake and bidirectional data exchange.
+
+import { hasCrypto, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { ok, strictEqual, match } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const serverReceivedData = Promise.withResolvers();
+const clientReceivedData = Promise.withResolvers();
+
+let serverHandshakeDone = false;
+let clientHandshakeDone = false;
+
+// Start server.
+const endpoint = listen(mustCall((session) => {
+  session.onmessage = mustCall((data) => {
+    strictEqual(data.toString(), 'hello from client');
+    serverReceivedData.resolve();
+
+    // Send response back to client.
+    session.send('hello from server');
+  });
+
+  session.onhandshake = mustCall((protocol) => {
+    ok(protocol);
+    match(protocol, /DTLS/i);
+    serverHandshakeDone = true;
+  });
+}), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+const serverAddress = endpoint.address;
+ok(serverAddress);
+ok(serverAddress.port > 0);
+
+// Connect client.
+const clientSession = connect('127.0.0.1', serverAddress.port, {
+  ca: [ca.toString()],
+  rejectUnauthorized: false,
+});
+
+clientSession.onmessage = mustCall((data) => {
+  strictEqual(data.toString(), 'hello from server');
+  clientReceivedData.resolve();
+});
+
+clientSession.onhandshake = mustCall((protocol) => {
+  ok(protocol);
+  clientHandshakeDone = true;
+});
+
+// Wait for handshake.
+const { protocol } = await clientSession.opened;
+match(protocol, /DTLS/i);
+
+// Send data.
+clientSession.send('hello from client');
+
+// Wait for bidirectional exchange.
+await Promise.all([serverReceivedData.promise, clientReceivedData.promise]);
+
+// Verify handshakes completed.
+ok(clientHandshakeDone);
+ok(serverHandshakeDone);
+
+// Clean up.
+await clientSession.close();
+await endpoint.close();
diff --git a/test/parallel/test-dtls-close.mjs b/test/parallel/test-dtls-close.mjs
new file mode 100644
index 00000000000000..0efc3b043487d8
--- /dev/null
+++ b/test/parallel/test-dtls-close.mjs
@@ -0,0 +1,110 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: Graceful close (close_notify) and forced destroy.
+
+import { hasCrypto, skip, mustCall, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { ok, throws } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+// Test 1: Graceful close from client side.
+{
+  const serverSessionClosed = Promise.withResolvers();
+
+  const endpoint = listen(mustCall((session) => {
+    session.onmessage = mustNotCall();
+    session.closed.then(mustCall(() => {
+      serverSessionClosed.resolve();
+    }));
+  }), {
+    cert: serverCert.toString(),
+    key: serverKey.toString(),
+    port: 0,
+    host: '127.0.0.1',
+  });
+
+  const session = connect('127.0.0.1', endpoint.address.port, {
+    ca: [ca.toString()],
+    rejectUnauthorized: false,
+  });
+
+  await session.opened;
+
+  // Graceful close.
+  const closedPromise = session.close();
+  ok(closedPromise instanceof Promise);
+  await closedPromise;
+
+  // Wait for server to see the close.
+  await serverSessionClosed.promise;
+
+  endpoint.close();
+  await endpoint.closed;
+}
+
+// Test 2: Forced destroy.
+{
+  const endpoint = listen(mustCall((session) => {
+    session.onmessage = mustNotCall();
+  }), {
+    cert: serverCert.toString(),
+    key: serverKey.toString(),
+    port: 0,
+    host: '127.0.0.1',
+  });
+
+  const session = connect('127.0.0.1', endpoint.address.port, {
+    ca: [ca.toString()],
+    rejectUnauthorized: false,
+  });
+
+  await session.opened;
+
+  // Forced destroy - no close_notify.
+  session.destroy();
+
+  // After destroy, send should fail.
+  throws(() => {
+    session.send('should fail');
+  }, /destroyed/i);
+
+  endpoint.destroy();
+}
+
+// Test 3: Endpoint close closes all sessions.
+{
+  const endpoint = listen(mustCall((session) => {
+    session.onmessage = mustNotCall();
+  }), {
+    cert: serverCert.toString(),
+    key: serverKey.toString(),
+    port: 0,
+    host: '127.0.0.1',
+  });
+
+  const session = connect('127.0.0.1', endpoint.address.port, {
+    ca: [ca.toString()],
+    rejectUnauthorized: false,
+  });
+
+  await session.opened;
+
+  // Close the endpoint - this should close all sessions.
+  await endpoint.close();
+}
diff --git a/test/parallel/test-dtls-multiple-clients.mjs b/test/parallel/test-dtls-multiple-clients.mjs
new file mode 100644
index 00000000000000..c913c255d8bdb2
--- /dev/null
+++ b/test/parallel/test-dtls-multiple-clients.mjs
@@ -0,0 +1,81 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: Multiple clients connecting to the same DTLS server.
+
+import { hasCrypto, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { strictEqual } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const NUM_CLIENTS = 3;
+let sessionsAccepted = 0;
+const allClientsConnected = Promise.withResolvers();
+
+const endpoint = listen(mustCall((session) => {
+  session.onmessage = (data) => {
+    // Echo back with session identifier.
+    session.send(`echo:${data.toString()}`);
+  };
+
+  if (++sessionsAccepted === NUM_CLIENTS) {
+    allClientsConnected.resolve();
+  }
+}, NUM_CLIENTS), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+const serverAddress = endpoint.address;
+const clients = [];
+const clientResponses = [];
+
+for (let i = 0; i < NUM_CLIENTS; i++) {
+  const received = Promise.withResolvers();
+  clientResponses.push(received);
+
+  const session = connect('127.0.0.1', serverAddress.port, {
+    ca: [ca.toString()],
+    rejectUnauthorized: false,
+  });
+
+  session.onmessage = mustCall((data) => {
+    strictEqual(data.toString(), `echo:client${i}`);
+    received.resolve();
+  });
+
+  clients.push(session);
+}
+
+// Wait for all handshakes.
+await Promise.all(clients.map((c) => c.opened));
+
+// Send data from each client.
+for (let i = 0; i < NUM_CLIENTS; i++) {
+  clients[i].send(`client${i}`);
+}
+
+// Wait for all echoes.
+await Promise.all(clientResponses.map((r) => r.promise));
+
+// Clean up.
+await Promise.all(clients.map((c) => c.close()));
+
+await endpoint.close();
diff --git a/test/parallel/test-dtls-options.mjs b/test/parallel/test-dtls-options.mjs
new file mode 100644
index 00000000000000..c157222181e0f8
--- /dev/null
+++ b/test/parallel/test-dtls-options.mjs
@@ -0,0 +1,53 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: Option validation for DTLS API.
+
+import { hasCrypto, skip, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
+
+const { throws } = assert;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+// Test: listen() requires a callback.
+throws(() => {
+  listen(undefined, { cert: 'x', key: 'y', port: 0 });
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+
+// Test: listen() requires cert.
+throws(() => {
+  listen(mustNotCall(), { key: 'y', port: 0 });
+}, { code: 'ERR_MISSING_ARGS' });
+
+// Test: listen() requires key.
+throws(() => {
+  listen(mustNotCall(), { cert: 'x', port: 0 });
+}, { code: 'ERR_MISSING_ARGS' });
+
+// Test: listen() requires port.
+throws(() => {
+  listen(mustNotCall(), { cert: 'x', key: 'y' });
+}, { code: 'ERR_MISSING_ARGS' });
+
+// Test: connect() requires valid host.
+throws(() => {
+  connect(123, 4433);
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+
+// Test: connect() requires valid port.
+throws(() => {
+  connect('localhost', 'invalid');
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+
+// Test: connect() rejects out-of-range port.
+throws(() => {
+  connect('localhost', 99999);
+}, { code: 'ERR_OUT_OF_RANGE' });
diff --git a/test/parallel/test-dtls-session-properties.mjs b/test/parallel/test-dtls-session-properties.mjs
new file mode 100644
index 00000000000000..07710083f1c922
--- /dev/null
+++ b/test/parallel/test-dtls-session-properties.mjs
@@ -0,0 +1,64 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: DTLSSession properties after handshake.
+
+import { hasCrypto, skip, mustCall, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { ok, strictEqual, match } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const endpoint = listen(mustCall((session) => {
+  session.onmessage = mustNotCall();
+}), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+const session = connect('127.0.0.1', endpoint.address.port, {
+  ca: [ca.toString()],
+  rejectUnauthorized: false,
+});
+
+await session.opened;
+
+// Protocol should be DTLSv1.2.
+match(session.protocol, /DTLS/i);
+
+// Cipher should be an object with name, standardName, version.
+const cipher = session.cipher;
+strictEqual(typeof cipher?.name, 'string');
+strictEqual(typeof cipher?.standardName, 'string');
+strictEqual(typeof cipher?.version, 'string');
+
+// Remote address should be defined.
+const addr = session.remoteAddress;
+ok(addr);
+
+// Peer certificate should be available (PEM string).
+const peerCert = session.peerCertificate;
+ok(peerCert);
+ok(peerCert.includes('BEGIN CERTIFICATE'));
+
+// State should reflect open connection.
+ok(session.state);
+
+await session.close();
+await endpoint.close();
diff --git a/test/parallel/test-permission-net-dtls.mjs b/test/parallel/test-permission-net-dtls.mjs
new file mode 100644
index 00000000000000..f2f2b7af2d2c3b
--- /dev/null
+++ b/test/parallel/test-permission-net-dtls.mjs
@@ -0,0 +1,59 @@
+// Flags: --permission --allow-fs-read=* --experimental-dtls --no-warnings
+import { hasCrypto, skip, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { connect, listen, DTLSEndpoint } = await import('node:dtls');
+
+// Verify that the permission system correctly reports no net access.
+assert.ok(!process.permission.has('net'));
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturesDir = join(__dirname, '..', 'fixtures', 'keys');
+const cert = readFileSync(join(fixturesDir, 'agent1-cert.pem')).toString();
+const key = readFileSync(join(fixturesDir, 'agent1-key.pem')).toString();
+const ca = readFileSync(join(fixturesDir, 'ca1-cert.pem')).toString();
+
+// Test: connect() should throw ERR_ACCESS_DENIED
+{
+  assert.throws(
+    () => connect('127.0.0.1', 12345, { ca: [ca], rejectUnauthorized: false }),
+    {
+      code: 'ERR_ACCESS_DENIED',
+      permission: 'Net',
+    },
+  );
+}
+
+// Test: listen() should throw ERR_ACCESS_DENIED
+{
+  assert.throws(
+    () => listen(mustNotCall('onsession should not be called'), {
+      cert,
+      key,
+      port: 0,
+      host: '127.0.0.1',
+    }),
+    {
+      code: 'ERR_ACCESS_DENIED',
+      permission: 'Net',
+    },
+  );
+}
+
+// Test: Creating a DTLSEndpoint without connect/listen is allowed
+// since no network I/O occurs at construction time.
+{
+  const endpoint = new DTLSEndpoint();
+  assert.ok(endpoint);
+}
diff --git a/test/parallel/test-process-features.js b/test/parallel/test-process-features.js
index 2af4808b6c5953..e12ae0029080dd 100644
--- a/test/parallel/test-process-features.js
+++ b/test/parallel/test-process-features.js
@@ -10,6 +10,7 @@ const expectedKeys = new Map([
   ['uv', ['boolean']],
   ['ipv6', ['boolean']],
   ['openssl_is_boringssl', ['boolean']],
+  ['dtls', ['boolean', 'undefined']],
   ['quic', ['boolean', 'undefined']],
   ['tls_alpn', ['boolean']],
   ['tls_sni', ['boolean']],
diff --git a/test/parallel/test-process-get-builtin.mjs b/test/parallel/test-process-get-builtin.mjs
index 3582dcebca9eba..2295c160a874ac 100644
--- a/test/parallel/test-process-get-builtin.mjs
+++ b/test/parallel/test-process-get-builtin.mjs
@@ -36,6 +36,8 @@ if (!hasIntl) {
   publicBuiltins.delete('inspector');
   publicBuiltins.delete('trace_events');
 }
+// TODO(@jasnell): Remove this once node:dtls graduates from unflagged.
+publicBuiltins.delete('node:dtls');
 // TODO(@jasnell): Remove this once node:quic graduates from unflagged.
 publicBuiltins.delete('node:quic');
 
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 5db4a77631582c..9a976b7b8d86ce 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -76,6 +76,8 @@ const { getSystemErrorName } = require('util');
     delete providers.QUIC_SESSION;
     delete providers.QUIC_STREAM;
     delete providers.LOCKS;
+    delete providers.DTLS_ENDPOINT;
+    delete providers.DTLS_SESSION;
 
     const objKeys = Object.keys(providers);
     if (objKeys.length > 0)

From 067d2a21c208c46ac1c73d66ed5a4f447f7160a3 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sun, 10 May 2026 11:12:37 -0700
Subject: [PATCH 43/83] src, lib: add stats to dtls

PR-URL: https://github.com/nodejs/node/pull/63182
Fixes: https://github.com/nodejs/node/issues/61630
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 doc/api/dtls.md                   | 206 ++++++++++++++++++++
 lib/internal/dtls/dtls.js         |  13 ++
 lib/internal/dtls/stats.js        | 300 +++++++++++++++++++++++++++++-
 src/dtls/dtls.cc                  |  18 ++
 src/dtls/dtls.h                   |  48 +++++
 src/dtls/dtls_endpoint.cc         |  29 ++-
 src/dtls/dtls_endpoint.h          |   7 +
 src/dtls/dtls_session.cc          |  21 ++-
 src/dtls/dtls_session.h           |   9 +
 test/parallel/test-dtls-stats.mjs | 154 +++++++++++++++
 10 files changed, 798 insertions(+), 7 deletions(-)
 create mode 100644 test/parallel/test-dtls-stats.mjs

diff --git a/doc/api/dtls.md b/doc/api/dtls.md
index 28f3aad5c8ce49..444e5cbf0d7bb1 100644
--- a/doc/api/dtls.md
+++ b/doc/api/dtls.md
@@ -178,6 +178,17 @@ Shared state object with properties:
 * `sessionCount` {number}
 * `busy` {boolean}
 
+### `endpoint.stats`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {DTLSEndpoint.Stats}
+
+The statistics collected for this endpoint. Read only. The stats object is
+live and updated by the C++ internals as data flows through the endpoint.
+
 ### `endpoint.busy`
 
 * {boolean}
@@ -204,6 +215,99 @@ Immediately destroys the endpoint without sending `close_notify` alerts.
 
 Equivalent to calling `endpoint.close()`.
 
+## Class: `DTLSEndpoint.Stats`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A view of the collected statistics for an endpoint.
+
+### `endpointStats.createdAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when the endpoint was created. Read only.
+
+### `endpointStats.destroyedAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when the endpoint was destroyed. Read only.
+
+### `endpointStats.bytesReceived`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of bytes received by this endpoint. Read only.
+
+### `endpointStats.bytesSent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of bytes sent by this endpoint. Read only.
+
+### `endpointStats.packetsReceived`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of UDP packets received by this endpoint. Read only.
+
+### `endpointStats.packetsSent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of UDP packets sent by this endpoint. Read only.
+
+### `endpointStats.serverSessions`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of peer-initiated sessions accepted by this
+  endpoint. Read only.
+
+### `endpointStats.clientSessions`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of sessions initiated by this endpoint. Read only.
+
+### `endpointStats.serverBusyCount`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of incoming connections rejected because the
+  endpoint was marked busy. Read only.
+
+### `endpointStats.isConnected`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+
+`true` if the stats object is still connected to the underlying endpoint.
+Once the endpoint is destroyed, the stats become a stale snapshot.
+
 ## Class: `DTLSSession`
 
 <!-- YAML
@@ -264,6 +368,17 @@ Immediately destroys the session without sending `close_notify`.
 
 * Returns: {string|undefined} The negotiated SRTP protection profile name.
 
+### `session.stats`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {DTLSSession.Stats}
+
+The statistics collected for this session. Read only. The stats object is
+live and updated as data flows through the session.
+
 ### `session.exportKeyingMaterial(length, label[, context])`
 
 * `length` {number} Number of bytes to export.
@@ -275,6 +390,97 @@ Exports keying material from the DTLS session, as defined in
 [RFC 5705][]. This is commonly used with DTLS-SRTP to derive
 encryption keys for media streams.
 
+## Class: `DTLSSession.Stats`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A view of the collected statistics for a session.
+
+### `sessionStats.createdAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when the session was created. Read only.
+
+### `sessionStats.destroyedAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when the session was destroyed. Read only.
+
+### `sessionStats.closingAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when `close()` was called. Read only.
+
+### `sessionStats.handshakeCompletedAt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} A timestamp indicating when the DTLS handshake completed. Read only.
+
+### `sessionStats.bytesReceived`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of application data bytes received. Read only.
+
+### `sessionStats.bytesSent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of application data bytes sent. Read only.
+
+### `sessionStats.messagesReceived`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of application messages received. Read only.
+
+### `sessionStats.messagesSent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of application messages sent. Read only.
+
+### `sessionStats.retransmitCount`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint} The total number of DTLS handshake retransmissions. Read only.
+
+### `sessionStats.isConnected`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+
+`true` if the stats object is still connected to the underlying session.
+Once the session is destroyed, the stats become a stale snapshot.
+
 ### Callback properties
 
 #### `session.onmessage`
diff --git a/lib/internal/dtls/dtls.js b/lib/internal/dtls/dtls.js
index d797f74b41e0df..aa4018239d911a 100644
--- a/lib/internal/dtls/dtls.js
+++ b/lib/internal/dtls/dtls.js
@@ -42,6 +42,11 @@ const {
   DTLSSessionState,
 } = require('internal/dtls/state');
 
+const {
+  DTLSEndpointStats,
+  DTLSSessionStats,
+} = require('internal/dtls/stats');
+
 const {
   kOwner,
   kPrivateConstructor,
@@ -70,6 +75,7 @@ class DTLSSession {
   #handle;
   #endpoint;
   #state;
+  #stats;
   #pendingOpen;
   #pendingClose;
   #onmessage;
@@ -88,6 +94,8 @@ class DTLSSession {
     this.#endpoint = endpoint;
     this.#state = new DTLSSessionState(
       kPrivateConstructor, handle.getState());
+    this.#stats = new DTLSSessionStats(
+      kPrivateConstructor, handle.getStats());
     this.#pendingOpen = PromiseWithResolvers();
     this.#pendingClose = PromiseWithResolvers();
   }
@@ -218,6 +226,7 @@ class DTLSSession {
   }
 
   get state() { return this.#state; }
+  get stats() { return this.#stats; }
   get endpoint() { return this.#endpoint; }
 
   exportKeyingMaterial(length, label, context) {
@@ -287,6 +296,7 @@ class DTLSSession {
 class DTLSEndpoint {
   #handle;
   #state;
+  #stats;
   #sessions = new SafeSet();
   #pendingClose;
   #onsession;
@@ -297,6 +307,8 @@ class DTLSEndpoint {
     this.#handle[kOwner] = this;
     this.#state = new DTLSEndpointState(
       kPrivateConstructor, this.#handle.getState());
+    this.#stats = new DTLSEndpointStats(
+      kPrivateConstructor, this.#handle.getStats());
     this.#pendingClose = PromiseWithResolvers();
 
     if (options.mtu !== undefined) {
@@ -392,6 +404,7 @@ class DTLSEndpoint {
   }
 
   get state() { return this.#state; }
+  get stats() { return this.#stats; }
   get sessions() { return this.#sessions; }
 
   get onerror() { return this.#onerror; }
diff --git a/lib/internal/dtls/stats.js b/lib/internal/dtls/stats.js
index 645c57fc6c05c1..c1fbd7dc16f73a 100644
--- a/lib/internal/dtls/stats.js
+++ b/lib/internal/dtls/stats.js
@@ -1,7 +1,9 @@
 'use strict';
 
-// Placeholder for DTLS statistics tracking.
-// Will be expanded as the implementation matures.
+const {
+  BigUint64Array,
+  JSONStringify,
+} = primordials;
 
 const {
   getOptionValue,
@@ -11,29 +13,319 @@ if (!process.features.dtls || !getOptionValue('--experimental-dtls')) {
   return;
 }
 
+const {
+  isArrayBuffer,
+} = require('util/types');
+
 const {
   codes: {
     ERR_ILLEGAL_CONSTRUCTOR,
+    ERR_INVALID_ARG_TYPE,
   },
 } = require('internal/errors');
 
+const { inspect } = require('internal/util/inspect');
+const assert = require('internal/assert');
+
 const {
+  kFinishClose,
   kPrivateConstructor,
 } = require('internal/dtls/symbols');
 
+// This file defines the helper objects for accessing statistics collected
+// by DTLS endpoints and sessions. Each wraps a BigUint64Array backed by
+// a shared ArrayBuffer that is updated by the C++ internals.
+
+const {
+  IDX_STATS_ENDPOINT_CREATED_AT,
+  IDX_STATS_ENDPOINT_DESTROYED_AT,
+  IDX_STATS_ENDPOINT_BYTES_RECEIVED,
+  IDX_STATS_ENDPOINT_BYTES_SENT,
+  IDX_STATS_ENDPOINT_PACKETS_RECEIVED,
+  IDX_STATS_ENDPOINT_PACKETS_SENT,
+  IDX_STATS_ENDPOINT_SERVER_SESSIONS,
+  IDX_STATS_ENDPOINT_CLIENT_SESSIONS,
+  IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT,
+
+  IDX_STATS_SESSION_CREATED_AT,
+  IDX_STATS_SESSION_DESTROYED_AT,
+  IDX_STATS_SESSION_CLOSING_AT,
+  IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT,
+  IDX_STATS_SESSION_BYTES_RECEIVED,
+  IDX_STATS_SESSION_BYTES_SENT,
+  IDX_STATS_SESSION_MESSAGES_RECEIVED,
+  IDX_STATS_SESSION_MESSAGES_SENT,
+  IDX_STATS_SESSION_RETRANSMIT_COUNT,
+} = internalBinding('dtls');
+
+assert(IDX_STATS_ENDPOINT_CREATED_AT !== undefined);
+assert(IDX_STATS_ENDPOINT_DESTROYED_AT !== undefined);
+assert(IDX_STATS_ENDPOINT_BYTES_RECEIVED !== undefined);
+assert(IDX_STATS_ENDPOINT_BYTES_SENT !== undefined);
+assert(IDX_STATS_ENDPOINT_PACKETS_RECEIVED !== undefined);
+assert(IDX_STATS_ENDPOINT_PACKETS_SENT !== undefined);
+assert(IDX_STATS_ENDPOINT_SERVER_SESSIONS !== undefined);
+assert(IDX_STATS_ENDPOINT_CLIENT_SESSIONS !== undefined);
+assert(IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT !== undefined);
+assert(IDX_STATS_SESSION_CREATED_AT !== undefined);
+assert(IDX_STATS_SESSION_DESTROYED_AT !== undefined);
+assert(IDX_STATS_SESSION_CLOSING_AT !== undefined);
+assert(IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT !== undefined);
+assert(IDX_STATS_SESSION_BYTES_RECEIVED !== undefined);
+assert(IDX_STATS_SESSION_BYTES_SENT !== undefined);
+assert(IDX_STATS_SESSION_MESSAGES_RECEIVED !== undefined);
+assert(IDX_STATS_SESSION_MESSAGES_SENT !== undefined);
+assert(IDX_STATS_SESSION_RETRANSMIT_COUNT !== undefined);
+
 class DTLSEndpointStats {
-  constructor(privateSymbol) {
+  /** @type {BigUint64Array} */
+  #handle;
+  /** @type {boolean} */
+  #disconnected = false;
+
+  /**
+   * @param {symbol} privateSymbol
+   * @param {ArrayBuffer} buffer
+   */
+  constructor(privateSymbol, buffer) {
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
+    if (!isArrayBuffer(buffer)) {
+      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    }
+    this.#handle = new BigUint64Array(buffer);
+  }
+
+  /** @type {bigint} */
+  get createdAt() {
+    return this.#handle[IDX_STATS_ENDPOINT_CREATED_AT];
+  }
+
+  /** @type {bigint} */
+  get destroyedAt() {
+    return this.#handle[IDX_STATS_ENDPOINT_DESTROYED_AT];
+  }
+
+  /** @type {bigint} */
+  get bytesReceived() {
+    return this.#handle[IDX_STATS_ENDPOINT_BYTES_RECEIVED];
+  }
+
+  /** @type {bigint} */
+  get bytesSent() {
+    return this.#handle[IDX_STATS_ENDPOINT_BYTES_SENT];
+  }
+
+  /** @type {bigint} */
+  get packetsReceived() {
+    return this.#handle[IDX_STATS_ENDPOINT_PACKETS_RECEIVED];
+  }
+
+  /** @type {bigint} */
+  get packetsSent() {
+    return this.#handle[IDX_STATS_ENDPOINT_PACKETS_SENT];
+  }
+
+  /** @type {bigint} */
+  get serverSessions() {
+    return this.#handle[IDX_STATS_ENDPOINT_SERVER_SESSIONS];
+  }
+
+  /** @type {bigint} */
+  get clientSessions() {
+    return this.#handle[IDX_STATS_ENDPOINT_CLIENT_SESSIONS];
+  }
+
+  /** @type {bigint} */
+  get serverBusyCount() {
+    return this.#handle[IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT];
+  }
+
+  toString() {
+    return JSONStringify(this.toJSON());
+  }
+
+  toJSON() {
+    return {
+      __proto__: null,
+      connected: this.isConnected,
+      createdAt: `${this.createdAt}`,
+      destroyedAt: `${this.destroyedAt}`,
+      bytesReceived: `${this.bytesReceived}`,
+      bytesSent: `${this.bytesSent}`,
+      packetsReceived: `${this.packetsReceived}`,
+      packetsSent: `${this.packetsSent}`,
+      serverSessions: `${this.serverSessions}`,
+      clientSessions: `${this.clientSessions}`,
+      serverBusyCount: `${this.serverBusyCount}`,
+    };
+  }
+
+  [inspect.custom](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      __proto__: null,
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1,
+    };
+
+    return `DTLSEndpointStats ${inspect({
+      connected: this.isConnected,
+      createdAt: this.createdAt,
+      destroyedAt: this.destroyedAt,
+      bytesReceived: this.bytesReceived,
+      bytesSent: this.bytesSent,
+      packetsReceived: this.packetsReceived,
+      packetsSent: this.packetsSent,
+      serverSessions: this.serverSessions,
+      clientSessions: this.clientSessions,
+      serverBusyCount: this.serverBusyCount,
+    }, opts)}`;
+  }
+
+  /**
+   * True if this stats object is still connected to the underlying
+   * stats source. If false, the stats are stale.
+   * @type {boolean}
+   */
+  get isConnected() {
+    return !this.#disconnected;
+  }
+
+  [kFinishClose]() {
+    // Snapshot the stats into a new BigUint64Array since the underlying
+    // buffer will be destroyed.
+    this.#handle = new BigUint64Array(this.#handle);
+    this.#disconnected = true;
   }
 }
 
 class DTLSSessionStats {
-  constructor(privateSymbol) {
+  /** @type {BigUint64Array} */
+  #handle;
+  /** @type {boolean} */
+  #disconnected = false;
+
+  /**
+   * @param {symbol} privateSymbol
+   * @param {ArrayBuffer} buffer
+   */
+  constructor(privateSymbol, buffer) {
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
+    if (!isArrayBuffer(buffer)) {
+      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    }
+    this.#handle = new BigUint64Array(buffer);
+  }
+
+  /** @type {bigint} */
+  get createdAt() {
+    return this.#handle[IDX_STATS_SESSION_CREATED_AT];
+  }
+
+  /** @type {bigint} */
+  get destroyedAt() {
+    return this.#handle[IDX_STATS_SESSION_DESTROYED_AT];
+  }
+
+  /** @type {bigint} */
+  get closingAt() {
+    return this.#handle[IDX_STATS_SESSION_CLOSING_AT];
+  }
+
+  /** @type {bigint} */
+  get handshakeCompletedAt() {
+    return this.#handle[IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
+  }
+
+  /** @type {bigint} */
+  get bytesReceived() {
+    return this.#handle[IDX_STATS_SESSION_BYTES_RECEIVED];
+  }
+
+  /** @type {bigint} */
+  get bytesSent() {
+    return this.#handle[IDX_STATS_SESSION_BYTES_SENT];
+  }
+
+  /** @type {bigint} */
+  get messagesReceived() {
+    return this.#handle[IDX_STATS_SESSION_MESSAGES_RECEIVED];
+  }
+
+  /** @type {bigint} */
+  get messagesSent() {
+    return this.#handle[IDX_STATS_SESSION_MESSAGES_SENT];
+  }
+
+  /** @type {bigint} */
+  get retransmitCount() {
+    return this.#handle[IDX_STATS_SESSION_RETRANSMIT_COUNT];
+  }
+
+  toString() {
+    return JSONStringify(this.toJSON());
+  }
+
+  toJSON() {
+    return {
+      __proto__: null,
+      connected: this.isConnected,
+      createdAt: `${this.createdAt}`,
+      destroyedAt: `${this.destroyedAt}`,
+      closingAt: `${this.closingAt}`,
+      handshakeCompletedAt: `${this.handshakeCompletedAt}`,
+      bytesReceived: `${this.bytesReceived}`,
+      bytesSent: `${this.bytesSent}`,
+      messagesReceived: `${this.messagesReceived}`,
+      messagesSent: `${this.messagesSent}`,
+      retransmitCount: `${this.retransmitCount}`,
+    };
+  }
+
+  [inspect.custom](depth, options) {
+    if (depth < 0)
+      return this;
+
+    const opts = {
+      __proto__: null,
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1,
+    };
+
+    return `DTLSSessionStats ${inspect({
+      connected: this.isConnected,
+      createdAt: this.createdAt,
+      destroyedAt: this.destroyedAt,
+      closingAt: this.closingAt,
+      handshakeCompletedAt: this.handshakeCompletedAt,
+      bytesReceived: this.bytesReceived,
+      bytesSent: this.bytesSent,
+      messagesReceived: this.messagesReceived,
+      messagesSent: this.messagesSent,
+      retransmitCount: this.retransmitCount,
+    }, opts)}`;
+  }
+
+  /**
+   * True if this stats object is still connected to the underlying
+   * stats source. If false, the stats are stale.
+   * @type {boolean}
+   */
+  get isConnected() {
+    return !this.#disconnected;
+  }
+
+  [kFinishClose]() {
+    // Snapshot the stats into a new BigUint64Array since the underlying
+    // buffer will be destroyed.
+    this.#handle = new BigUint64Array(this.#handle);
+    this.#disconnected = true;
   }
 }
 
diff --git a/src/dtls/dtls.cc b/src/dtls/dtls.cc
index ccd8b98eaab8bb..288d317dfa14b6 100644
--- a/src/dtls/dtls.cc
+++ b/src/dtls/dtls.cc
@@ -48,6 +48,24 @@ void CreatePerContextProperties(Local<Object> target,
   NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_DESTROYED);
   NODE_DEFINE_CONSTANT(target, IDX_SESSION_STATE_HAS_MESSAGE_LISTENER);
 
+  // Endpoint stats indices (for BigUint64Array access from JS)
+#define V(name, _) IDX_STATS_ENDPOINT_##name,
+  enum IDX_STATS_ENDPOINT { DTLS_ENDPOINT_STATS(V) IDX_STATS_ENDPOINT_COUNT };
+#undef V
+#define V(name, _) NODE_DEFINE_CONSTANT(target, IDX_STATS_ENDPOINT_##name);
+  DTLS_ENDPOINT_STATS(V);
+#undef V
+  NODE_DEFINE_CONSTANT(target, IDX_STATS_ENDPOINT_COUNT);
+
+  // Session stats indices
+#define V(name, _) IDX_STATS_SESSION_##name,
+  enum IDX_STATS_SESSION { DTLS_SESSION_STATS(V) IDX_STATS_SESSION_COUNT };
+#undef V
+#define V(name, _) NODE_DEFINE_CONSTANT(target, IDX_STATS_SESSION_##name);
+  DTLS_SESSION_STATS(V);
+#undef V
+  NODE_DEFINE_CONSTANT(target, IDX_STATS_SESSION_COUNT);
+
   // SSL verify mode constants
   constexpr auto SSL_VERIFY_NONE_VALUE = SSL_VERIFY_NONE;
   constexpr auto SSL_VERIFY_PEER_VALUE = SSL_VERIFY_PEER;
diff --git a/src/dtls/dtls.h b/src/dtls/dtls.h
index 1b27c2fbf5740d..6f1737347433f2 100644
--- a/src/dtls/dtls.h
+++ b/src/dtls/dtls.h
@@ -6,10 +6,58 @@
 
 #include <env.h>
 #include <node_errors.h>
+#include <uv.h>
 #include <v8.h>
 
+#include <cstdint>
+
 namespace node::dtls {
 
+// Utilities for updating stats maintained in an AliasedStruct.
+template <typename Stats, uint64_t Stats::*member>
+void IncrementStat(Stats* stats, uint64_t amt = 1) {
+  stats->*member += amt;
+}
+
+template <typename Stats, uint64_t Stats::*member>
+void RecordTimestampStat(Stats* stats) {
+  stats->*member = uv_hrtime();
+}
+
+#define DTLS_STAT_INCREMENT(Type, name)                                        \
+  IncrementStat<Type, &Type::name>(stats_.Data())
+#define DTLS_STAT_INCREMENT_N(Type, name, amt)                                 \
+  IncrementStat<Type, &Type::name>(stats_.Data(), amt)
+#define DTLS_STAT_RECORD_TIMESTAMP(Type, name)                                 \
+  RecordTimestampStat<Type, &Type::name>(stats_.Data())
+
+#define DTLS_STAT_FIELD(_, name) uint64_t name;
+
+// ============================================================================
+// Stats X-macros: V(ENUM_NAME, field_name)
+
+#define DTLS_ENDPOINT_STATS(V)                                                 \
+  V(CREATED_AT, created_at)                                                    \
+  V(DESTROYED_AT, destroyed_at)                                                \
+  V(BYTES_RECEIVED, bytes_received)                                            \
+  V(BYTES_SENT, bytes_sent)                                                    \
+  V(PACKETS_RECEIVED, packets_received)                                        \
+  V(PACKETS_SENT, packets_sent)                                                \
+  V(SERVER_SESSIONS, server_sessions)                                          \
+  V(CLIENT_SESSIONS, client_sessions)                                          \
+  V(SERVER_BUSY_COUNT, server_busy_count)
+
+#define DTLS_SESSION_STATS(V)                                                  \
+  V(CREATED_AT, created_at)                                                    \
+  V(DESTROYED_AT, destroyed_at)                                                \
+  V(CLOSING_AT, closing_at)                                                    \
+  V(HANDSHAKE_COMPLETED_AT, handshake_completed_at)                            \
+  V(BYTES_RECEIVED, bytes_received)                                            \
+  V(BYTES_SENT, bytes_sent)                                                    \
+  V(MESSAGES_RECEIVED, messages_received)                                      \
+  V(MESSAGES_SENT, messages_sent)                                              \
+  V(RETRANSMIT_COUNT, retransmit_count)
+
 // State indices shared between C++ and JS via AliasedStruct/DataView.
 // Keep in sync with lib/internal/dtls/state.js.
 enum DTLSEndpointStateIndex {
diff --git a/src/dtls/dtls_endpoint.cc b/src/dtls/dtls_endpoint.cc
index b1c91d4f221b8e..9433241a2d1433 100644
--- a/src/dtls/dtls_endpoint.cc
+++ b/src/dtls/dtls_endpoint.cc
@@ -50,10 +50,12 @@ DTLSEndpoint::DTLSEndpoint(Environment* env, Local<Object> wrap)
                  wrap,
                  reinterpret_cast<uv_handle_t*>(&handle_),
                  PROVIDER_DTLS_ENDPOINT),
-      state_(env->isolate()) {
+      state_(env->isolate()),
+      stats_(env->isolate()) {
   CHECK_EQ(uv_udp_init(env->event_loop(), &handle_), 0);
   handle_.data = this;
   MakeWeak();
+  DTLS_STAT_RECORD_TIMESTAMP(DTLSEndpointStats, created_at);
 }
 
 Local<FunctionTemplate> DTLSEndpoint::GetConstructorTemplate(Environment* env) {
@@ -71,6 +73,7 @@ Local<FunctionTemplate> DTLSEndpoint::GetConstructorTemplate(Environment* env) {
     SetProtoMethod(isolate, tmpl, "close", DoClose);
     SetProtoMethod(isolate, tmpl, "destroy", DoDestroy);
     SetProtoMethod(isolate, tmpl, "getState", GetState);
+    SetProtoMethod(isolate, tmpl, "getStats", GetStats);
     SetProtoMethod(isolate, tmpl, "getAddress", GetAddress);
     SetProtoMethod(isolate, tmpl, "setMTU", SetMTU);
     SetProtoMethod(isolate, tmpl, "setCallbacks", DoSetCallbacks);
@@ -96,6 +99,7 @@ void DTLSEndpoint::RegisterExternalReferences(
   registry->Register(DoClose);
   registry->Register(DoDestroy);
   registry->Register(GetState);
+  registry->Register(GetStats);
   registry->Register(GetAddress);
   registry->Register(SetMTU);
   registry->Register(DoSetCallbacks);
@@ -171,6 +175,7 @@ BaseObjectPtr<DTLSSession> DTLSEndpoint::Connect(DTLSContext* context,
 
   sessions_[remote] = session;
   state_->session_count = sessions_.size();
+  DTLS_STAT_INCREMENT(DTLSEndpointStats, client_sessions);
 
   // Ref the handle while we have sessions.
   uv_ref(reinterpret_cast<uv_handle_t*>(&handle_));
@@ -197,6 +202,8 @@ int DTLSEndpoint::SendTo(const SocketAddress& dest,
   int err = uv_udp_try_send(&handle_, &buf, 1, dest.data());
 
   if (err == static_cast<int>(len)) {
+    DTLS_STAT_INCREMENT_N(DTLSEndpointStats, bytes_sent, len);
+    DTLS_STAT_INCREMENT(DTLSEndpointStats, packets_sent);
     return 0;  // Sent successfully.
   }
 
@@ -215,6 +222,8 @@ int DTLSEndpoint::SendTo(const SocketAddress& dest,
     return err;
   }
 
+  DTLS_STAT_INCREMENT_N(DTLSEndpointStats, bytes_sent, len);
+  DTLS_STAT_INCREMENT(DTLSEndpointStats, packets_sent);
   return 0;
 }
 
@@ -358,6 +367,11 @@ void DTLSEndpoint::OnRecv(uv_udp_t* handle,
     return;
   }
 
+  IncrementStat<DTLSEndpointStats, &DTLSEndpointStats::bytes_received>(
+      endpoint->stats_.Data(), nread);
+  IncrementStat<DTLSEndpointStats, &DTLSEndpointStats::packets_received>(
+      endpoint->stats_.Data());
+
   SocketAddress remote(addr);
   endpoint->ProcessDatagram(
       reinterpret_cast<const uint8_t*>(buf->base), nread, remote);
@@ -373,6 +387,7 @@ void DTLSEndpoint::OnSend(uv_udp_send_t* req, int status) {
 void DTLSEndpoint::OnClose() {
   state_->closing = 0;
   state_->destroyed = 1;
+  DTLS_STAT_RECORD_TIMESTAMP(DTLSEndpointStats, destroyed_at);
 
   Local<Function> cb = GetCallback(DTLS_CB_ENDPOINT_CLOSE);
   if (!cb.IsEmpty()) {
@@ -402,7 +417,10 @@ void DTLSEndpoint::ProcessDatagram(const uint8_t* data,
 void DTLSEndpoint::AcceptConnection(const uint8_t* data,
                                     size_t len,
                                     const SocketAddress& remote) {
-  if (state_->busy) return;
+  if (state_->busy) {
+    DTLS_STAT_INCREMENT(DTLSEndpointStats, server_busy_count);
+    return;
+  }
 
   HandleScope handle_scope(env()->isolate());
   Context::Scope context_scope(env()->context());
@@ -481,6 +499,7 @@ void DTLSEndpoint::AcceptConnection(const uint8_t* data,
 
   sessions_[remote] = session;
   state_->session_count = sessions_.size();
+  DTLS_STAT_INCREMENT(DTLSEndpointStats, server_sessions);
 
   uv_ref(reinterpret_cast<uv_handle_t*>(&handle_));
 
@@ -581,6 +600,12 @@ void DTLSEndpoint::GetState(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(endpoint->state_.GetArrayBuffer());
 }
 
+void DTLSEndpoint::GetStats(const FunctionCallbackInfo<Value>& args) {
+  DTLSEndpoint* endpoint;
+  ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
+  args.GetReturnValue().Set(endpoint->stats_.GetArrayBuffer());
+}
+
 void DTLSEndpoint::GetAddress(const FunctionCallbackInfo<Value>& args) {
   DTLSEndpoint* endpoint;
   ASSIGN_OR_RETURN_UNWRAP(&endpoint, args.This());
diff --git a/src/dtls/dtls_endpoint.h b/src/dtls/dtls_endpoint.h
index 06ffe4bcc39ed2..a6fe94fff5b8cc 100644
--- a/src/dtls/dtls_endpoint.h
+++ b/src/dtls/dtls_endpoint.h
@@ -31,6 +31,11 @@ struct DTLSEndpointStateData {
   uint8_t busy = 0;
 };
 
+// Stats collected for a DTLS endpoint, backed by a BigUint64Array.
+struct DTLSEndpointStats {
+  DTLS_ENDPOINT_STATS(DTLS_STAT_FIELD)
+};
+
 // DTLSEndpoint manages a single UDP socket and dispatches incoming
 // datagrams to the appropriate DTLSSession based on the remote address.
 // For server mode, it handles stateless cookie exchange via DTLSv1_listen()
@@ -93,6 +98,7 @@ class DTLSEndpoint final : public HandleWrap {
   static void DoClose(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoDestroy(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStats(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetMTU(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoSetCallbacks(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -136,6 +142,7 @@ class DTLSEndpoint final : public HandleWrap {
   v8::Global<v8::Function> callbacks_[DTLS_CB_COUNT];
 
   AliasedStruct<DTLSEndpointStateData> state_;
+  AliasedStruct<DTLSEndpointStats> stats_;
 
   bool listening_ = false;
   uint32_t mtu_ = 1200;  // Conservative default MTU for data payload
diff --git a/src/dtls/dtls_session.cc b/src/dtls/dtls_session.cc
index f423451a5302b9..8bcd06a4ae71d9 100644
--- a/src/dtls/dtls_session.cc
+++ b/src/dtls/dtls_session.cc
@@ -53,6 +53,8 @@ DTLSSession::DTLSSession(Environment* env,
       retransmit_timer_(env,
                         [this] {
                           if (destroyed_) return;
+                          DTLS_STAT_INCREMENT(DTLSSessionStats,
+                                              retransmit_count);
                           int ret = DTLSv1_handle_timeout(ssl_.get());
                           if (ret < 0) {
                             // Handshake timeout expired.
@@ -70,8 +72,10 @@ DTLSSession::DTLSSession(Environment* env,
                         }),
       remote_address_(remote),
       is_server_(is_server),
-      state_(env->isolate()) {
+      state_(env->isolate()),
+      stats_(env->isolate()) {
   MakeWeak();
+  DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, created_at);
   retransmit_timer_.Unref();
 
   // Update shared state.
@@ -103,6 +107,7 @@ Local<FunctionTemplate> DTLSSession::GetConstructorTemplate(Environment* env) {
     SetProtoMethod(isolate, tmpl, "close", DoClose);
     SetProtoMethod(isolate, tmpl, "destroy", DoDestroy);
     SetProtoMethod(isolate, tmpl, "getState", GetState);
+    SetProtoMethod(isolate, tmpl, "getStats", GetStats);
     SetProtoMethod(isolate, tmpl, "getRemoteAddress", GetRemoteAddress);
     SetProtoMethod(isolate, tmpl, "getProtocol", GetProtocol);
     SetProtoMethod(isolate, tmpl, "getCipher", GetCipher);
@@ -132,6 +137,7 @@ void DTLSSession::RegisterExternalReferences(
   registry->Register(DoClose);
   registry->Register(DoDestroy);
   registry->Register(GetState);
+  registry->Register(GetStats);
   registry->Register(GetRemoteAddress);
   registry->Register(GetProtocol);
   registry->Register(GetCipher);
@@ -275,6 +281,7 @@ void DTLSSession::Cycle() {
       handshake_complete_ = true;
       state_->handshaking = 0;
       state_->open = 1;
+      DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, handshake_completed_at);
 
       Local<Value> argv[] = {
           String::NewFromUtf8(env()->isolate(), SSL_get_version(ssl_.get()))
@@ -301,6 +308,8 @@ void DTLSSession::ClearOut() {
   int read;
 
   while ((read = SSL_read(ssl_.get(), buf, sizeof(buf))) > 0) {
+    DTLS_STAT_INCREMENT_N(DTLSSessionStats, bytes_received, read);
+    DTLS_STAT_INCREMENT(DTLSSessionStats, messages_received);
     // Emit the data to JS via callback.
     Local<Value> argv[] = {
         Buffer::Copy(env(), reinterpret_cast<const char*>(buf), read)
@@ -385,6 +394,8 @@ int DTLSSession::Send(const uint8_t* data, size_t len) {
 
   int written = SSL_write(ssl_.get(), data, len);
   if (written > 0) {
+    DTLS_STAT_INCREMENT_N(DTLSSessionStats, bytes_sent, written);
+    DTLS_STAT_INCREMENT(DTLSSessionStats, messages_sent);
     EncOut();
   }
   return written;
@@ -395,6 +406,7 @@ void DTLSSession::Close() {
 
   closed_ = true;
   state_->closing = 1;
+  DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, closing_at);
 
   // Send close_notify.
   int ret = SSL_shutdown(ssl_.get());
@@ -421,6 +433,7 @@ void DTLSSession::Destroy() {
   closed_ = true;
 
   state_->destroyed = 1;
+  DTLS_STAT_RECORD_TIMESTAMP(DTLSSessionStats, destroyed_at);
   state_->open = 0;
   state_->handshaking = 0;
 
@@ -492,6 +505,12 @@ void DTLSSession::GetState(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(session->state_.GetArrayBuffer());
 }
 
+void DTLSSession::GetStats(const FunctionCallbackInfo<Value>& args) {
+  DTLSSession* session;
+  ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+  args.GetReturnValue().Set(session->stats_.GetArrayBuffer());
+}
+
 void DTLSSession::GetRemoteAddress(const FunctionCallbackInfo<Value>& args) {
   DTLSSession* session;
   ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
diff --git a/src/dtls/dtls_session.h b/src/dtls/dtls_session.h
index c4dee0c36d53dd..d64d0e4d48736a 100644
--- a/src/dtls/dtls_session.h
+++ b/src/dtls/dtls_session.h
@@ -17,6 +17,8 @@
 #include <openssl/bio.h>
 #include <openssl/ssl.h>
 
+#include "dtls.h"
+
 namespace node::dtls {
 
 class DTLSEndpoint;
@@ -30,6 +32,11 @@ struct DTLSSessionStateData {
   uint8_t has_message_listener = 0;
 };
 
+// Stats collected for a DTLS session, backed by a BigUint64Array.
+struct DTLSSessionStats {
+  DTLS_SESSION_STATS(DTLS_STAT_FIELD)
+};
+
 // DTLSSession represents a single DTLS association with a remote peer.
 // It wraps an OpenSSL SSL* object configured for DTLS, using memory BIOs
 // to interface with the endpoint's UDP socket.
@@ -102,6 +109,7 @@ class DTLSSession final : public AsyncWrap {
   static void DoClose(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void DoDestroy(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetState(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStats(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetRemoteAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetCipher(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -159,6 +167,7 @@ class DTLSSession final : public AsyncWrap {
   int cycle_depth_ = 0;
 
   AliasedStruct<DTLSSessionStateData> state_;
+  AliasedStruct<DTLSSessionStats> stats_;
 };
 
 }  // namespace node::dtls
diff --git a/test/parallel/test-dtls-stats.mjs b/test/parallel/test-dtls-stats.mjs
new file mode 100644
index 00000000000000..32c17c90cee746
--- /dev/null
+++ b/test/parallel/test-dtls-stats.mjs
@@ -0,0 +1,154 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: DTLS endpoint and session stats increment with data transfer.
+
+import { hasCrypto, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { ok, strictEqual, notStrictEqual } = assert;
+const { readKey } = fixtures;
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const { listen, connect } = await import('node:dtls');
+
+const serverCert = readKey('agent1-cert.pem');
+const serverKey = readKey('agent1-key.pem');
+const ca = readKey('ca1-cert.pem');
+
+const serverReceivedData = Promise.withResolvers();
+const clientReceivedData = Promise.withResolvers();
+
+let serverSession;
+
+// Start server.
+const endpoint = listen(mustCall((session) => {
+  serverSession = session;
+
+  session.onmessage = mustCall((data) => {
+    strictEqual(data.toString(), 'hello from client');
+    session.send('hello from server');
+    serverReceivedData.resolve();
+  });
+
+  session.onhandshake = mustCall();
+}), {
+  cert: serverCert.toString(),
+  key: serverKey.toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+// --- Endpoint stats should be available immediately ---
+
+const epStats = endpoint.stats;
+ok(epStats, 'endpoint.stats should be defined');
+ok(epStats.isConnected, 'stats should be connected');
+ok(epStats.createdAt > 0n, 'createdAt should be set');
+strictEqual(epStats.destroyedAt, 0n);
+strictEqual(epStats.clientSessions, 0n);
+strictEqual(epStats.serverSessions, 0n);
+strictEqual(epStats.serverBusyCount, 0n);
+
+// Connect client.
+const clientSession = connect('127.0.0.1', endpoint.address.port, {
+  ca: [ca.toString()],
+  rejectUnauthorized: false,
+});
+
+clientSession.onmessage = mustCall((data) => {
+  strictEqual(data.toString(), 'hello from server');
+  clientReceivedData.resolve();
+});
+
+clientSession.onhandshake = mustCall();
+
+// Wait for handshake.
+await clientSession.opened;
+
+// --- Client session stats after handshake ---
+
+const csStats = clientSession.stats;
+ok(csStats, 'session.stats should be defined');
+ok(csStats.isConnected, 'session stats should be connected');
+ok(csStats.createdAt > 0n, 'createdAt should be set');
+ok(csStats.handshakeCompletedAt > 0n, 'handshake timestamp should be set');
+ok(csStats.handshakeCompletedAt >= csStats.createdAt,
+   'handshake should complete after creation');
+strictEqual(csStats.closingAt, 0n);
+strictEqual(csStats.destroyedAt, 0n);
+
+// Record bytes before sending application data.
+const csBytesSentBefore = csStats.bytesSent;
+const csMessagesSentBefore = csStats.messagesSent;
+
+// Send data.
+clientSession.send('hello from client');
+
+// Wait for bidirectional exchange.
+await Promise.all([serverReceivedData.promise, clientReceivedData.promise]);
+
+// --- Client session stats after data exchange ---
+
+ok(csStats.bytesSent > csBytesSentBefore,
+   'bytesSent should increase after send');
+ok(csStats.messagesSent > csMessagesSentBefore,
+   'messagesSent should increase after send');
+ok(csStats.bytesReceived > 0n, 'bytesReceived should be non-zero');
+ok(csStats.messagesReceived > 0n, 'messagesReceived should be non-zero');
+
+// --- Server session stats after data exchange ---
+
+ok(serverSession, 'server session should exist');
+const ssStats = serverSession.stats;
+ok(ssStats.bytesReceived > 0n, 'server bytesReceived should be non-zero');
+ok(ssStats.messagesReceived > 0n, 'server messagesReceived should be non-zero');
+ok(ssStats.bytesSent > 0n, 'server bytesSent should be non-zero');
+ok(ssStats.messagesSent > 0n, 'server messagesSent should be non-zero');
+ok(ssStats.handshakeCompletedAt > 0n, 'server handshake timestamp should be set');
+
+// --- Endpoint stats after data exchange ---
+
+ok(epStats.bytesReceived > 0n, 'endpoint bytesReceived should be non-zero');
+ok(epStats.bytesSent > 0n, 'endpoint bytesSent should be non-zero');
+ok(epStats.packetsReceived > 0n, 'endpoint packetsReceived should be non-zero');
+ok(epStats.packetsSent > 0n, 'endpoint packetsSent should be non-zero');
+strictEqual(epStats.serverSessions, 1n);
+
+// The client's own endpoint should track the client session.
+const clientEpStats = clientSession.endpoint.stats;
+strictEqual(clientEpStats.clientSessions, 1n);
+ok(clientEpStats.bytesSent > 0n);
+ok(clientEpStats.bytesReceived > 0n);
+
+// --- toJSON / toString ---
+
+const epJson = epStats.toJSON();
+ok(epJson);
+strictEqual(typeof epJson.bytesReceived, 'string');
+strictEqual(typeof epJson.bytesSent, 'string');
+strictEqual(typeof epJson.connected, 'boolean');
+
+const ssJson = csStats.toJSON();
+ok(ssJson);
+strictEqual(typeof ssJson.handshakeCompletedAt, 'string');
+strictEqual(typeof ssJson.messagesReceived, 'string');
+
+const epStr = epStats.toString();
+ok(typeof epStr === 'string');
+ok(epStr.includes('bytesReceived'));
+
+// Clean up.
+await clientSession.close();
+
+// After close, session closing timestamp should be set.
+notStrictEqual(csStats.closingAt, 0n);
+
+await endpoint.close();

From f835cc42da4e60ec66b484edb51a46efe8ebe479 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sun, 10 May 2026 11:44:34 -0700
Subject: [PATCH 44/83] src,lib: add dtls interop tests

PR-URL: https://github.com/nodejs/node/pull/63182
Fixes: https://github.com/nodejs/node/issues/61630
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 lib/internal/dtls/dtls.js                     |   6 +
 lib/internal/dtls/state.js                    |   6 +
 lib/internal/dtls/stats.js                    |   6 +
 lib/internal/dtls/symbols.js                  |   6 +
 test/doctool/test-make-doc.mjs                |   3 +-
 .../test-dtls-interop-openssl-client.mjs      | 103 ++++++++++++++++++
 .../test-dtls-interop-openssl-server.mjs      |  95 ++++++++++++++++
 7 files changed, 224 insertions(+), 1 deletion(-)
 create mode 100644 test/sequential/test-dtls-interop-openssl-client.mjs
 create mode 100644 test/sequential/test-dtls-interop-openssl-server.mjs

diff --git a/lib/internal/dtls/dtls.js b/lib/internal/dtls/dtls.js
index aa4018239d911a..c4aab52e6e76f3 100644
--- a/lib/internal/dtls/dtls.js
+++ b/lib/internal/dtls/dtls.js
@@ -1,5 +1,9 @@
 'use strict';
 
+// TODO(@jasnell) Temporarily ignoring c8 coverage for this file while tests
+// are still being developed.
+/* c8 ignore start */
+
 const {
   ArrayIsArray,
   FunctionPrototypeBind,
@@ -648,3 +652,5 @@ module.exports = {
   DTLSEndpoint,
   DTLSSession,
 };
+
+/* c8 ignore stop */
diff --git a/lib/internal/dtls/state.js b/lib/internal/dtls/state.js
index be8272661740fe..5d86b556f1ada8 100644
--- a/lib/internal/dtls/state.js
+++ b/lib/internal/dtls/state.js
@@ -1,5 +1,9 @@
 'use strict';
 
+// TODO(@jasnell) Temporarily ignoring c8 coverage for this file while tests
+// are still being developed.
+/* c8 ignore start */
+
 const {
   DataView,
   DataViewPrototypeGetByteLength,
@@ -166,3 +170,5 @@ module.exports = {
   DTLSEndpointState,
   DTLSSessionState,
 };
+
+/* c8 ignore stop */
diff --git a/lib/internal/dtls/stats.js b/lib/internal/dtls/stats.js
index c1fbd7dc16f73a..b3393fe6b76d44 100644
--- a/lib/internal/dtls/stats.js
+++ b/lib/internal/dtls/stats.js
@@ -1,5 +1,9 @@
 'use strict';
 
+// TODO(@jasnell) Temporarily ignoring c8 coverage for this file while tests
+// are still being developed.
+/* c8 ignore start */
+
 const {
   BigUint64Array,
   JSONStringify,
@@ -333,3 +337,5 @@ module.exports = {
   DTLSEndpointStats,
   DTLSSessionStats,
 };
+
+/* c8 ignore stop */
diff --git a/lib/internal/dtls/symbols.js b/lib/internal/dtls/symbols.js
index 0fe418d023d4de..fbeeadc562a0b0 100644
--- a/lib/internal/dtls/symbols.js
+++ b/lib/internal/dtls/symbols.js
@@ -1,5 +1,9 @@
 'use strict';
 
+// TODO(@jasnell) Temporarily ignoring c8 coverage for this file while tests
+// are still being developed.
+/* c8 ignore start */
+
 const {
   Symbol,
 } = primordials;
@@ -35,3 +39,5 @@ module.exports = {
   kSessionClose: Symbol('dtls.session.close'),
   kSessionKeylog: Symbol('dtls.session.keylog'),
 };
+
+/* c8 ignore stop */
diff --git a/test/doctool/test-make-doc.mjs b/test/doctool/test-make-doc.mjs
index 555193227672cc..59e681707dd473 100644
--- a/test/doctool/test-make-doc.mjs
+++ b/test/doctool/test-make-doc.mjs
@@ -61,7 +61,8 @@ for (const actualDoc of actualDocs) {
   // Unless the old file is still available pointing to the correct location
   // 301 redirects are not yet automated. So keeping the old URL is a
   // reasonable workaround.
-  if (renamedDocs.includes(actualDoc) || actualDoc === 'apilinks.json') continue;
+  if (renamedDocs.includes(actualDoc) || skipedDocs.includes(actualDoc) ||
+      actualDoc === 'apilinks.json') continue;
   assert.ok(
     expectedDocs.includes(actualDoc), `${actualDoc} does not match TOC`);
 
diff --git a/test/sequential/test-dtls-interop-openssl-client.mjs b/test/sequential/test-dtls-interop-openssl-client.mjs
new file mode 100644
index 00000000000000..683d725e76698c
--- /dev/null
+++ b/test/sequential/test-dtls-interop-openssl-client.mjs
@@ -0,0 +1,103 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: DTLS interop -- Node.js DTLS server with OpenSSL s_client.
+// Verifies that an external DTLS client (OpenSSL CLI) can complete a
+// handshake with Node's DTLS server and exchange application data.
+
+import { hasCrypto, skip, mustCall } from '../common/index.mjs';
+import { createRequire } from 'module';
+import assert from 'node:assert';
+import { spawn } from 'node:child_process';
+import { setTimeout } from 'node:timers/promises';
+import * as fixtures from '../common/fixtures.mjs';
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const require = createRequire(import.meta.url);
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
+  skip('missing openssl-cli');
+}
+
+const { listen } = await import('node:dtls');
+
+const reply = 'I AM THE WALRUS'; // Something recognizable
+const serverReceivedData = Promise.withResolvers();
+
+// Start Node.js DTLS server.
+const endpoint = listen(mustCall((session) => {
+  session.onmessage = mustCall((data) => {
+    assert.strictEqual(data.toString().trim(), 'hello from openssl');
+    session.send(reply);
+    serverReceivedData.resolve();
+  });
+  session.onhandshake = mustCall();
+}), {
+  cert: fixtures.readKey('agent1-cert.pem').toString(),
+  key: fixtures.readKey('agent1-key.pem').toString(),
+  port: 0,
+  host: '127.0.0.1',
+});
+
+const { port } = endpoint.address;
+
+// Spawn OpenSSL s_client to connect to the Node.js server.
+const args = [
+  's_client',
+  '-dtls',
+  '-connect', `127.0.0.1:${port}`,
+  '-CAfile', fixtures.path('keys/ca1-cert.pem'),
+];
+
+const client = spawn(opensslCli, args, { stdio: 'pipe' });
+
+let stdout = '';
+client.stdout.on('data', (data) => { stdout += data; });
+
+let stderr = '';
+client.stderr.on('data', (data) => { stderr += data; });
+
+const timeout = setTimeout(() => {
+  client.kill();
+  endpoint.close();
+  assert.fail('Test timed out');
+}, 10000);
+
+// Wait for the handshake to start (s_client writes TLS info to stdout),
+// then send data.
+await new Promise((resolve) => client.stdout.once('data', resolve));
+await setTimeout(500);
+
+client.stdin.write('hello from openssl\n');
+
+// Wait for the server to receive and reply.
+await serverReceivedData.promise;
+await setTimeout(500);
+
+// Close stdin so s_client exits.
+client.stdin.end();
+
+// Wait for s_client to exit.
+const code = await new Promise((resolve) => client.on('close', resolve));
+clearTimeout(timeout);
+
+// s_client should exit cleanly.
+assert.strictEqual(code, 0,
+                   `openssl s_client exited with code ${code}\n${stderr}`);
+
+// Verify the reply from Node's server appeared in s_client's stdout.
+assert(stdout.includes(reply),
+       `Expected stdout to include "${reply}"\n${stdout}`);
+
+// Verify it was a DTLS connection.
+assert(stdout.includes('DTLS'),
+       `Expected stdout to include "DTLS"\n${stdout}`);
+
+await endpoint.close();
diff --git a/test/sequential/test-dtls-interop-openssl-server.mjs b/test/sequential/test-dtls-interop-openssl-server.mjs
new file mode 100644
index 00000000000000..26e66710611fcf
--- /dev/null
+++ b/test/sequential/test-dtls-interop-openssl-server.mjs
@@ -0,0 +1,95 @@
+// Flags: --experimental-dtls --no-warnings
+
+// Test: DTLS interop -- OpenSSL s_server with Node.js DTLS client.
+// Verifies that Node's DTLS client can complete a handshake with an
+// external DTLS server (OpenSSL CLI) and exchange application data.
+
+import { hasCrypto, skip, mustCall, mustNotCall } from '../common/index.mjs';
+import { createRequire } from 'module';
+import assert from 'node:assert';
+import { spawn } from 'node:child_process';
+import * as fixtures from '../common/fixtures.mjs';
+
+if (!hasCrypto) {
+  skip('missing crypto');
+}
+
+if (!process.features.dtls) {
+  skip('DTLS is not enabled');
+}
+
+const require = createRequire(import.meta.url);
+const common = require('../common');
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
+  skip('missing openssl-cli');
+}
+
+const { connect } = await import('node:dtls');
+
+const reply = 'I AM THE WALRUS'; // Something recognizable
+
+// Start OpenSSL DTLS server.
+const server = spawn(opensslCli, [
+  's_server',
+  '-dtls1_2',
+  '-accept', String(common.PORT),
+  '-cert', fixtures.path('keys/agent1-cert.pem'),
+  '-key', fixtures.path('keys/agent1-key.pem'),
+  '-listen',
+], { stdio: 'pipe' });
+
+let serverOut = '';
+server.stdout.on('data', (data) => { serverOut += data; });
+let serverErr = '';
+server.stderr.on('data', (data) => { serverErr += data; });
+server.on('error', mustNotCall());
+
+const timeout = setTimeout(() => {
+  server.kill();
+  assert.fail(`Test timed out\nstdout: ${serverOut}\nstderr: ${serverErr}`);
+}, 10000);
+
+// Wait for "ACCEPT" on stdout -- this means s_server is ready.
+await new Promise((resolve) => {
+  server.stdout.on('data', function onReady() {
+    if (!serverOut.includes('ACCEPT')) return;
+    server.stdout.removeListener('data', onReady);
+    resolve();
+  });
+});
+
+// Connect Node.js DTLS client.
+const session = connect('127.0.0.1', common.PORT, {
+  ca: [fixtures.readKey('ca1-cert.pem').toString()],
+  rejectUnauthorized: false,
+});
+
+const { protocol } = await session.opened;
+assert.match(protocol, /DTLS/i);
+
+// Send data from Node to OpenSSL server.
+session.send('hello from node');
+
+// Send data from OpenSSL server to Node client via s_server stdin.
+// s_server forwards its stdin to the connected client.
+server.stdin.write(reply + '\n');
+
+// Wait for Node client to receive the message.
+const data = await new Promise((resolve) => {
+  session.onmessage = mustCall(resolve);
+});
+assert.strictEqual(data.toString().trim(), reply);
+
+// Clean up.
+await session.close();
+await session.endpoint.close();
+clearTimeout(timeout);
+server.kill();
+
+// Wait for server to exit.
+const [, signal] = await new Promise((resolve) => {
+  server.on('exit', mustCall((...args) => resolve(args)));
+});
+assert.strictEqual(signal, 'SIGTERM');

From 22b987c4c09021aa270560bd56a692b4e636e30a Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 09:13:12 -0700
Subject: [PATCH 45/83] meta: add additional gitignore entries

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 0b8f1a405bda3a..69c1dd205316fa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,7 @@
 /tags
 /tags.*
 /doc/api.xml
+/docs/
 /node
 /node_g
 /gon-config.json

From ff8aa78d799c1d4522f1f52181a43087fc090a4f Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 09:13:44 -0700
Subject: [PATCH 46/83] quic: improve backend quic packet processing

Use a uv_check_t on BindingData to process outbound
pending packet send, and use TrySend for actually sending
packets when possible. Results in an 8% improvement in
req/s and ~24% improvement in p95 latency.

Also sets us up better for future improvements in
libuv if the changes proposed in https://github.com/libuv/libuv/pull/5116
are accepted.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/bindingdata.cc | 55 +++++++++++++++++++++++++++++++++++++
 src/quic/bindingdata.h  | 20 ++++++++++++++
 src/quic/endpoint.cc    | 61 ++++++++++++++++++++++++++++++++++++++++-
 src/quic/endpoint.h     | 13 +++++++++
 src/quic/session.cc     | 45 +++++++++++++++++++++++++-----
 src/quic/session.h      | 28 +++++++++++++++++++
 6 files changed, 214 insertions(+), 8 deletions(-)

diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index 4a3b3dba11f196..a2719d683c6e92 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -22,6 +22,7 @@ namespace node {
 using mem::kReserveSizeAndAlign;
 using v8::Function;
 using v8::FunctionTemplate;
+using v8::HandleScope;
 using v8::Local;
 using v8::Object;
 using v8::String;
@@ -154,6 +155,16 @@ BindingData& BindingData::Get(Environment* env) {
 
 BindingData::~BindingData() {
   quic_alloc_state.binding = nullptr;
+  if (flush_check_initialized_) {
+    uv_check_stop(&flush_check_);
+    flush_check_started_ = false;
+    // The check handle is closed inline here. Because BindingData destruction
+    // happens during Environment cleanup, the handle will be finalized by
+    // libuv's close phase.
+    uv_close(reinterpret_cast<uv_handle_t*>(&flush_check_), nullptr);
+    flush_check_initialized_ = false;
+  }
+  pending_flush_sessions_.clear();
 }
 
 ngtcp2_mem* BindingData::ngtcp2_allocator() {
@@ -221,6 +232,11 @@ void BindingData::RegisterExternalReferences(
 BindingData::BindingData(Realm* realm, Local<Object> object)
     : BaseObject(realm, object) {
   MakeWeak();
+  CHECK_EQ(uv_check_init(env()->event_loop(), &flush_check_), 0);
+  flush_check_.data = this;
+  // Unref so the check handle doesn't keep the event loop alive on its own.
+  uv_unref(reinterpret_cast<uv_handle_t*>(&flush_check_));
+  flush_check_initialized_ = true;
 }
 
 SessionManager& BindingData::session_manager() {
@@ -230,6 +246,45 @@ SessionManager& BindingData::session_manager() {
   return *session_manager_;
 }
 
+void BindingData::ScheduleSessionFlush(const BaseObjectPtr<Session>& session) {
+  pending_flush_sessions_.push_back(session);
+  if (!flush_check_started_) {
+    uv_check_start(&flush_check_, OnFlushCheck);
+    flush_check_started_ = true;
+  }
+}
+
+void BindingData::OnFlushCheck(uv_check_t* handle) {
+  auto* binding = static_cast<BindingData*>(handle->data);
+  if (binding->pending_flush_sessions_.empty()) {
+    uv_check_stop(&binding->flush_check_);
+    binding->flush_check_started_ = false;
+    return;
+  }
+
+  HandleScope scope(binding->env()->isolate());
+
+  // Swap to a local vector before iterating. SendPendingData may trigger
+  // MakeCallback which runs JS that could cause more packet receives via
+  // re-entry (e.g., a stream data callback that synchronously writes to
+  // another session). Any sessions added during the flush remain in
+  // pending_flush_sessions_ and are picked up on the next check tick.
+  auto sessions = std::move(binding->pending_flush_sessions_);
+  for (auto& session : sessions) {
+    session->pending_flush_ = false;
+    if (!session->is_destroyed()) {
+      session->FlushPendingData();
+    }
+  }
+
+  // If no new sessions were added during the flush, stop the check
+  // to avoid per-tick callback overhead when idle.
+  if (binding->pending_flush_sessions_.empty()) {
+    uv_check_stop(&binding->flush_check_);
+    binding->flush_check_started_ = false;
+  }
+}
+
 void BindingData::MemoryInfo(MemoryTracker* tracker) const {
 #define V(name, _) tracker->TrackField(#name, name##_callback());
 
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index cc3c3a49f5647a..b3965529a6c1de 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -10,9 +10,11 @@
 #include <ngtcp2/ngtcp2_crypto.h>
 #include <node.h>
 #include <node_mem.h>
+#include <uv.h>
 #include <v8.h>
 #include <memory>
 #include <unordered_map>
+#include <vector>
 #include "defs.h"
 
 namespace node::quic {
@@ -201,6 +203,13 @@ class BindingData final
   // routing so that any endpoint can route packets to any session.
   SessionManager& session_manager();
 
+  // Schedule a session for deferred SendPendingData. Sessions are accumulated
+  // during the I/O poll phase (via Endpoint::Receive -> Session::ReadPacket)
+  // and flushed in a uv_check callback immediately after poll completes.
+  // This batches multiple received packets before generating responses,
+  // allowing ngtcp2 to make better ACK coalescing decisions.
+  void ScheduleSessionFlush(const BaseObjectPtr<Session>& session);
+
   std::unordered_map<Endpoint*, BaseObjectPtr<BaseObject>> listening_endpoints;
 
   size_t current_ngtcp2_memory_ = 0;
@@ -247,6 +256,17 @@ class BindingData final
 #undef V
 
   std::unique_ptr<SessionManager> session_manager_;
+
+  // Deferred send flush state. The uv_check_t fires immediately after
+  // the I/O poll phase in the same event loop tick, allowing batched
+  // receive processing: all packets are read during poll, then
+  // SendPendingData is called once per dirty session in the check callback.
+  uv_check_t flush_check_;
+  std::vector<BaseObjectPtr<Session>> pending_flush_sessions_;
+  bool flush_check_started_ = false;
+  bool flush_check_initialized_ = false;
+
+  static void OnFlushCheck(uv_check_t* handle);
 };
 
 JS_METHOD_IMPL(IllegalConstructor);
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 66413f66cafee2..38792a64932070 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -492,6 +492,14 @@ int Endpoint::UDP::Send(Packet::Ptr packet) {
   return err;
 }
 
+int Endpoint::UDP::TrySend(Packet* packet) {
+  DCHECK_NOT_NULL(packet);
+  if (is_closed_or_closing()) return UV_EBADF;
+  uv_buf_t buf = *packet;
+  return uv_udp_try_send(
+      &impl_->handle_, &buf, 1, packet->destination().data());
+}
+
 void Endpoint::UDP::MemoryInfo(MemoryTracker* tracker) const {
   if (impl_) tracker->TrackField("impl", impl_);
 }
@@ -812,6 +820,45 @@ void Endpoint::Send(Packet::Ptr packet) {
   STAT_INCREMENT(Stats, packets_sent);
 }
 
+void Endpoint::SendOrTrySend(Packet::Ptr packet) {
+#ifdef DEBUG
+  if (is_diagnostic_packet_loss(options_.tx_loss)) [[unlikely]] {
+    return;
+  }
+#endif
+
+  if (is_closed() || is_closing() || packet->length() == 0) {
+    return;
+  }
+
+  Debug(this, "TrySend %s", packet->ToString());
+  size_t packet_length = packet->length();
+
+  // Attempt synchronous send. On success (returns number of bytes sent),
+  // the packet is delivered immediately — no callback overhead, no
+  // waiting for the next poll cycle.
+  int err = udp_.TrySend(packet.get());
+  if (err >= 0) {
+    // Synchronous send succeeded. Release the packet immediately.
+    STAT_INCREMENT_N(Stats, bytes_sent, packet_length);
+    STAT_INCREMENT(Stats, packets_sent);
+    // Ptr destructor releases back to arena pool.
+    return;
+  }
+
+  if (err == UV_EAGAIN) {
+    // Socket not writable or async sends are queued. Fall back to the
+    // async path — the packet will be queued and flushed on the next
+    // POLLOUT cycle.
+    Debug(this, "TrySend got EAGAIN, falling back to async Send");
+    return Send(std::move(packet));
+  }
+
+  // Other errors are fatal.
+  Debug(this, "TrySend failed with error %d", err);
+  Destroy(CloseContext::SEND_FAILURE, err);
+}
+
 void Endpoint::SendRetry(const PathDescriptor& options) {
   // Generating and sending retry packets does consume some system resources,
   // and it is possible for a malicious peer to trigger sending a large number
@@ -1128,10 +1175,22 @@ void Endpoint::Receive(const uv_buf_t& buf,
     DCHECK_NOT_NULL(session);
     if (session->is_destroyed()) return;
     size_t len = store.length();
-    if (session->Receive(std::move(store), local_address, remote_address)) {
+    // Use ReadPacket (no SendPendingDataScope) so that multiple packets
+    // received in the same I/O burst are processed before any responses
+    // are generated. The deferred flush via BindingData's uv_check
+    // callback calls SendPendingData once per dirty session after all
+    // packets in the burst have been read.
+    if (session->ReadPacket(std::move(store), local_address, remote_address)) {
       STAT_INCREMENT_N(Stats, bytes_received, len);
       STAT_INCREMENT(Stats, packets_received);
     }
+    // Schedule the session for deferred SendPendingData if it hasn't
+    // been scheduled already in this burst.
+    if (!session->is_destroyed() && !session->pending_flush_) {
+      session->pending_flush_ = true;
+      BindingData::Get(env()).ScheduleSessionFlush(
+          BaseObjectPtr<Session>(session));
+    }
   };
 
   const auto accept = [&](const Session::Config& config, Store&& store) {
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index b9f20f8659dfa6..a198a5c315af50 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -208,6 +208,13 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
 
   void Send(Packet::Ptr packet);
 
+  // Attempt synchronous send via uv_udp_try_send. If the socket is
+  // writable, the packet is sent immediately and the Ptr is released.
+  // If the socket is not writable (UV_EAGAIN), falls back to the
+  // async Send path. Used by the deferred flush callback to avoid
+  // the one-tick latency of async uv_udp_send.
+  void SendOrTrySend(Packet::Ptr packet);
+
   // Acquire a Packet from the pool. length sets the initial working
   // size (must be <= pool capacity). The slot is always allocated at
   // full capacity to avoid fragmentation.
@@ -281,6 +288,12 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
     void Close();
     int Send(Packet::Ptr packet);
 
+    // Synchronous send using uv_udp_try_send. Returns 0 on success,
+    // UV_EAGAIN if the socket is not writable or the send queue is
+    // non-empty, or another negative error code on failure.
+    // On success, the caller is responsible for releasing the packet.
+    int TrySend(Packet* packet);
+
     // Returns the local UDP socket address to which we are bound,
     // or fail with an assert if we are not bound.
     SocketAddress local_address() const;
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 4af903e0c2a0af..e959e1a9194bd7 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2104,13 +2104,21 @@ void Session::SetLastError(QuicError&& error) {
 bool Session::Receive(Store&& store,
                       const SocketAddress& local_address,
                       const SocketAddress& remote_address) {
+  // Convenience wrapper: reads the packet and immediately triggers
+  // SendPendingData. Used by paths that need an immediate response
+  // (e.g., Endpoint::Connect for client Initial packets).
+  // The hot receive path uses ReadPacket() directly with deferred
+  // flush via BindingData's uv_check callback.
+  SendPendingDataScope send_scope(this);
+  return ReadPacket(std::move(store), local_address, remote_address);
+}
+
+bool Session::ReadPacket(Store&& store,
+                         const SocketAddress& local_address,
+                         const SocketAddress& remote_address) {
   DCHECK(!is_destroyed());
   impl_->remote_address_ = remote_address;
 
-  // When we are done processing this packet, we arrange to send any
-  // pending data for this session.
-  SendPendingDataScope send_scope(this);
-
   ngtcp2_vec vec = store;
   Path path(local_address, remote_address);
 
@@ -2125,14 +2133,16 @@ bool Session::Receive(Store&& store,
   // ensures that any deferred destroy waits until all callbacks for this
   // packet have completed. After calling ngtcp2_conn_read_pkt here, we
   // will need to double check that the session is not destroyed before
-  // we try doing anything with it (like updating stats, sending pending
-  // data, etc).
+  // we try doing anything with it (like updating stats, etc).
   int err;
   {
     NgTcp2CallbackScope callback_scope(this);
+    // ECN codepoint (ngtcp2_pkt_info.ecn) is not yet populated because
+    // libuv does not currently deliver per-packet ECN metadata. When
+    // libuv gains ECN receive reporting, the pkt_info should be
+    // populated from the per-packet metadata and passed through here.
     err = ngtcp2_conn_read_pkt(*this,
                                &path,
-                               // TODO(@jasnell): ECN pkt_info blocked on libuv
                                nullptr,
                                vec.base,
                                vec.len,
@@ -2245,6 +2255,17 @@ bool Session::Receive(Store&& store,
   return false;
 }
 
+void Session::FlushPendingData() {
+  DCHECK(!is_destroyed());
+  if (impl_->application_) {
+    // Prefer synchronous sends during the deferred flush to avoid the
+    // one-tick latency of async uv_udp_send from the uv_check callback.
+    prefer_try_send_ = true;
+    application().SendPendingData();
+    prefer_try_send_ = false;
+  }
+}
+
 void Session::Send(Packet::Ptr packet) {
   // Sending a Packet is generally best effort. If we're not in a state
   // where we can send a packet, it's ok to drop it on the floor. The
@@ -2261,6 +2282,16 @@ void Session::Send(Packet::Ptr packet) {
     return;
   }
 
+  // When called from the deferred flush path (uv_check callback),
+  // prefer synchronous send to avoid the one-tick latency of async
+  // uv_udp_send. SendOrTrySend uses uv_udp_try_send first, falling
+  // back to uv_udp_send on EAGAIN.
+  if (prefer_try_send_) {
+    Debug(this, "Session is sending (try_send) %s", packet->ToString());
+    endpoint().SendOrTrySend(std::move(packet));
+    return;
+  }
+
   Debug(this, "Session is sending %s", packet->ToString());
   endpoint().Send(std::move(packet));
 }
diff --git a/src/quic/session.h b/src/quic/session.h
index 650e8f79ba1428..04c059b1225575 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -357,6 +357,23 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
                const SocketAddress& local_address,
                const SocketAddress& remote_address);
 
+  // ReadPacket processes a single inbound packet through ngtcp2 without
+  // triggering SendPendingData. This is the building block for batched
+  // receive processing: the caller (Endpoint::Receive) accumulates
+  // dirty sessions and a uv_check callback flushes them after all
+  // packets in the I/O burst have been read.
+  // Receive() is kept as a convenience wrapper that calls ReadPacket()
+  // then triggers SendPendingData (for paths like Connect that need
+  // immediate response).
+  bool ReadPacket(Store&& store,
+                  const SocketAddress& local_address,
+                  const SocketAddress& remote_address);
+
+  // Called by BindingData's flush callback to trigger SendPendingData
+  // on this session. Encapsulates the application() access so that
+  // bindingdata.cc doesn't need the full Application type definition.
+  void FlushPendingData();
+
   void Send(Packet::Ptr packet);
   void Send(Packet::Ptr packet, const PathStorage& path);
   datagram_id SendDatagram(Store&& data);
@@ -572,11 +589,22 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   bool in_ngtcp2_callback_scope_ = false;
   bool in_nghttp3_callback_scope_ = false;
   bool destroy_deferred_ = false;
+  // Set when this session is in BindingData's pending_flush_sessions_ vector.
+  // Cleared by the flush callback before calling SendPendingData.
+  // Provides O(1) dedup so a session receiving multiple packets in one I/O
+  // burst is only scheduled for flush once.
+  bool pending_flush_ = false;
+  // When true, Session::Send prefers synchronous delivery via
+  // Endpoint::SendOrTrySend (uv_udp_try_send with async fallback).
+  // Set during FlushPendingData to avoid the one-tick latency of
+  // async-only sends from the uv_check callback.
+  bool prefer_try_send_ = false;
   QuicConnectionPointer connection_;
   std::unique_ptr<TLSSession> tls_session_;
   friend struct NgTcp2CallbackScope;
   friend struct NgHttp3CallbackScope;
   friend class Application;
+  friend class BindingData;
   friend class DefaultApplication;
   friend class Http3ApplicationImpl;
   friend class Endpoint;

From 60ba1b30566b1b8efa3b232f841c88455d7e2ddf Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 09:16:32 -0700
Subject: [PATCH 47/83] test: fixup quic tests

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/parallel/test-quic-callback-error-ondatagram-async.mjs | 5 +----
 test/parallel/test-quic-callback-error-ondatagram.mjs       | 5 +----
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/test/parallel/test-quic-callback-error-ondatagram-async.mjs b/test/parallel/test-quic-callback-error-ondatagram-async.mjs
index 4e6f814906fb40..eebe2e0629522c 100644
--- a/test/parallel/test-quic-callback-error-ondatagram-async.mjs
+++ b/test/parallel/test-quic-callback-error-ondatagram-async.mjs
@@ -38,9 +38,6 @@ await clientSession.opened;
 await clientSession.sendDatagram(new Uint8Array([1, 2, 3]));
 
 await serverDone.promise;
-// The server session was destroyed abruptly (no CONNECTION_CLOSE sent).
-// The client may receive a stateless reset if it sends any packet
-// before its idle timeout fires, so closed may reject.
-await assert.rejects(clientSession.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' });
+await clientSession.closed;
 serverEndpoint.close();
 await serverEndpoint.closed;
diff --git a/test/parallel/test-quic-callback-error-ondatagram.mjs b/test/parallel/test-quic-callback-error-ondatagram.mjs
index f0253f22768380..69d1440ed49da6 100644
--- a/test/parallel/test-quic-callback-error-ondatagram.mjs
+++ b/test/parallel/test-quic-callback-error-ondatagram.mjs
@@ -41,8 +41,5 @@ await clientSession.opened;
 await clientSession.sendDatagram(new Uint8Array([1, 2, 3]));
 
 await serverDone.promise;
-// The server session was destroyed abruptly (no CONNECTION_CLOSE sent).
-// The client may receive a stateless reset if it sends any packet
-// before its idle timeout fires, so closed may reject.
-await rejects(clientSession.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' });
+await clientSession.closed;
 await serverEndpoint.close();

From 996867984fada3d849af930bacb376c711a9b40c Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 09:34:41 -0700
Subject: [PATCH 48/83] quic: improve batching of packet sending

Improves overall performance and sets us up for eventual
support for GRO/GSO batching in libuv in the future.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc | 42 +++++++++++++++----
 src/quic/endpoint.cc    | 90 +++++++++++++++++++++++++++++++++++++----
 src/quic/endpoint.h     | 25 +++++++++---
 src/quic/session.cc     | 63 ++++++++++++++++++++++++++---
 src/quic/session.h      |  7 ++++
 5 files changed, 201 insertions(+), 26 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index b5d8c8609fa3dc..499d80a2de3260 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -329,14 +329,35 @@ void Session::Application::SendPendingData() {
   if (!session().can_send_packets()) [[unlikely]] {
     return;
   }
-  static constexpr size_t kMaxPackets = 32;
+  // Upper bound on packets per SendPendingData call. ngtcp2's send quantum
+  // is typically 64 KB, which at 1200-byte minimum packet size is ~53
+  // packets. 64 covers the worst case with headroom. The actual count per
+  // call is dynamically capped by ngtcp2_conn_get_send_quantum().
+  static constexpr size_t kMaxPackets = 64;
   Debug(session_, "Application sending pending data");
   PathStorage path;
   StreamData stream_data;
 
   bool closed = false;
+
+  // Batch accumulation: packets are collected here and flushed via
+  // Session::SendBatch when the loop exits, the batch is full, or
+  // on early return. This enables synchronous batched delivery via
+  // uv_udp_try_send2 (sendmmsg) from the deferred flush path.
+  Packet::Ptr batch[kMaxPackets];
+  PathStorage batch_paths[kMaxPackets];
+  size_t batch_count = 0;
+
+  auto flush_batch = [&] {
+    if (batch_count == 0) return;
+    session_->SendBatch(batch, batch_paths, batch_count);
+    batch_count = 0;
+  };
+
   auto update_stats = OnScopeLeave([&] {
     if (closed) return;
+    // Flush any remaining accumulated packets before updating stats.
+    flush_batch();
     auto& s = session();
     if (!s.is_destroyed()) [[likely]] {
       s.UpdatePacketTxTime();
@@ -353,7 +374,7 @@ void Session::Application::SendPendingData() {
       kMaxPackets, ngtcp2_conn_get_send_quantum(*session_) / max_packet_size);
   if (max_packet_count == 0) return;
 
-  // The number of packets that have been sent in this call to SendPendingData.
+  // The number of packets that have been prepared in this call.
   size_t packet_send_count = 0;
 
   Packet::Ptr packet;
@@ -368,6 +389,14 @@ void Session::Application::SendPendingData() {
     return true;
   };
 
+  // Accumulate a completed packet into the batch.
+  auto enqueue_packet = [&](Packet::Ptr& pkt, size_t len) {
+    Debug(session_, "Enqueuing packet with %zu bytes into batch", len);
+    pkt->Truncate(len);
+    path.CopyTo(&batch_paths[batch_count]);
+    batch[batch_count++] = std::move(pkt);
+  };
+
   // We're going to enter a loop here to prepare and send no more than
   // max_packet_count packets.
   for (;;) {
@@ -502,8 +531,7 @@ void Session::Application::SendPendingData() {
             if (result > 0) {
               size_t len = result;
               Debug(session_, "Sending packet with %zu bytes", len);
-              packet->Truncate(len);
-              session_->Send(std::move(packet), path);
+              enqueue_packet(packet, len);
               if (++packet_send_count == max_packet_count) return;
             } else if (result < 0) {
               // Any negative result other than NGTCP2_ERR_WRITE_MORE
@@ -540,8 +568,7 @@ void Session::Application::SendPendingData() {
     // is the size of the packet we are sending.
     size_t len = nwrite;
     Debug(session_, "Sending packet with %zu bytes", len);
-    packet->Truncate(len);
-    session_->Send(std::move(packet), path);
+    enqueue_packet(packet, len);
     if (++packet_send_count == max_packet_count) return;
 
     // If there are pending datagrams, try sending them in a fresh packet.
@@ -560,8 +587,7 @@ void Session::Application::SendPendingData() {
           TryWritePendingDatagram(&path, packet->data(), packet->length());
       if (result > 0) {
         Debug(session_, "Sending datagram packet with %zd bytes", result);
-        packet->Truncate(static_cast<size_t>(result));
-        session_->Send(std::move(packet), path);
+        enqueue_packet(packet, static_cast<size_t>(result));
         if (++packet_send_count == max_packet_count) return;
       } else if (result < 0 && result != NGTCP2_ERR_WRITE_MORE) {
         // Fatal error — session already closed by TryWritePendingDatagram.
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 38792a64932070..5c7657b4d86029 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -492,14 +492,24 @@ int Endpoint::UDP::Send(Packet::Ptr packet) {
   return err;
 }
 
-int Endpoint::UDP::TrySend(Packet* packet) {
-  DCHECK_NOT_NULL(packet);
+int Endpoint::UDP::TrySend(const Packet::Ptr& packet) {
+  DCHECK(packet);
   if (is_closed_or_closing()) return UV_EBADF;
   uv_buf_t buf = *packet;
   return uv_udp_try_send(
       &impl_->handle_, &buf, 1, packet->destination().data());
 }
 
+int Endpoint::UDP::TrySendBatch(uv_buf_t* bufs[],
+                                unsigned int nbufs[],
+                                struct sockaddr* addrs[],
+                                size_t count) {
+  DCHECK_GT(count, 0);
+  if (is_closed_or_closing()) return UV_EBADF;
+  return uv_udp_try_send2(
+      &impl_->handle_, static_cast<unsigned int>(count), bufs, nbufs, addrs, 0);
+}
+
 void Endpoint::UDP::MemoryInfo(MemoryTracker* tracker) const {
   if (impl_) tracker->TrackField("impl", impl_);
 }
@@ -827,20 +837,19 @@ void Endpoint::SendOrTrySend(Packet::Ptr packet) {
   }
 #endif
 
-  if (is_closed() || is_closing() || packet->length() == 0) {
+  if (is_closed() || is_closing() || !packet || packet->length() == 0) {
     return;
   }
 
   Debug(this, "TrySend %s", packet->ToString());
-  size_t packet_length = packet->length();
 
   // Attempt synchronous send. On success (returns number of bytes sent),
   // the packet is delivered immediately — no callback overhead, no
   // waiting for the next poll cycle.
-  int err = udp_.TrySend(packet.get());
+  int err = udp_.TrySend(packet);
   if (err >= 0) {
-    // Synchronous send succeeded. Release the packet immediately.
-    STAT_INCREMENT_N(Stats, bytes_sent, packet_length);
+    // Synchronous send succeeded.
+    STAT_INCREMENT_N(Stats, bytes_sent, packet->length());
     STAT_INCREMENT(Stats, packets_sent);
     // Ptr destructor releases back to arena pool.
     return;
@@ -859,6 +868,73 @@ void Endpoint::SendOrTrySend(Packet::Ptr packet) {
   Destroy(CloseContext::SEND_FAILURE, err);
 }
 
+void Endpoint::SendBatch(Packet::Ptr* packets, size_t count) {
+  if (count == 0) return;
+
+#ifdef DEBUG
+  if (is_diagnostic_packet_loss(options_.tx_loss)) [[unlikely]] {
+    for (size_t i = 0; i < count; i++) packets[i].reset();
+    return;
+  }
+#endif
+
+  if (is_closed() || is_closing()) {
+    for (size_t i = 0; i < count; i++) packets[i].reset();
+    return;
+  }
+
+  static constexpr size_t kMaxBatch = 64;
+  DCHECK_LE(count, kMaxBatch);
+
+  // Build libuv argument arrays directly from the Ptr array.
+  // Packets with zero length are released and skipped.
+  uv_buf_t bufs[kMaxBatch];
+  uv_buf_t* buf_ptrs[kMaxBatch];
+  unsigned int nbufs[kMaxBatch];
+  struct sockaddr* addrs[kMaxBatch];
+  // Map from valid-index back to the original packets[] index.
+  size_t index_map[kMaxBatch];
+  size_t valid_count = 0;
+
+  for (size_t i = 0; i < count; i++) {
+    if (!packets[i] || packets[i]->length() == 0) {
+      packets[i].reset();
+      continue;
+    }
+    bufs[valid_count] = *packets[i];
+    buf_ptrs[valid_count] = &bufs[valid_count];
+    nbufs[valid_count] = 1;
+    addrs[valid_count] =
+        const_cast<struct sockaddr*>(packets[i]->destination().data());
+    index_map[valid_count] = i;
+    valid_count++;
+  }
+
+  if (valid_count == 0) return;
+
+  // Attempt synchronous batched send via sendmmsg.
+  int sent = udp_.TrySendBatch(buf_ptrs, nbufs, addrs, valid_count);
+
+  if (sent > 0) {
+    // Packets [0, sent) were delivered synchronously.
+    // Release them immediately — no async callback needed.
+    for (size_t i = 0; i < static_cast<size_t>(sent); i++) {
+      size_t idx = index_map[i];
+      STAT_INCREMENT_N(Stats, bytes_sent, packets[idx]->length());
+      STAT_INCREMENT(Stats, packets_sent);
+      packets[idx].reset();
+    }
+  }
+
+  // Any unsent packets (EAGAIN, partial send, or total failure) fall
+  // back to async uv_udp_send.
+  size_t start = (sent > 0) ? static_cast<size_t>(sent) : 0;
+  for (size_t i = start; i < valid_count; i++) {
+    size_t idx = index_map[i];
+    Send(std::move(packets[idx]));
+  }
+}
+
 void Endpoint::SendRetry(const PathDescriptor& options) {
   // Generating and sending retry packets does consume some system resources,
   // and it is possible for a malicious peer to trigger sending a large number
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index a198a5c315af50..43760702ca7bf9 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -215,6 +215,13 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
   // the one-tick latency of async uv_udp_send.
   void SendOrTrySend(Packet::Ptr packet);
 
+  // Send a batch of packets using uv_udp_try_send2 (sendmmsg) for
+  // synchronous batched delivery. Packets successfully sent are released
+  // immediately. On EAGAIN or partial send, remaining packets fall back
+  // to async uv_udp_send. The Packet::Ptr array is consumed: all entries
+  // will be empty (released or moved) on return.
+  void SendBatch(Packet::Ptr* packets, size_t count);
+
   // Acquire a Packet from the pool. length sets the initial working
   // size (must be <= pool capacity). The slot is always allocated at
   // full capacity to avoid fragmentation.
@@ -288,11 +295,19 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
     void Close();
     int Send(Packet::Ptr packet);
 
-    // Synchronous send using uv_udp_try_send. Returns 0 on success,
-    // UV_EAGAIN if the socket is not writable or the send queue is
-    // non-empty, or another negative error code on failure.
-    // On success, the caller is responsible for releasing the packet.
-    int TrySend(Packet* packet);
+    // Synchronous send using uv_udp_try_send. Returns the number of
+    // bytes sent on success, UV_EAGAIN if the socket is not writable
+    // or the send queue is non-empty, or another negative error code.
+    // The Ptr is not consumed — the caller manages the lifecycle.
+    int TrySend(const Packet::Ptr& packet);
+
+    // Synchronous batched send using uv_udp_try_send2 (sendmmsg).
+    // Takes pre-built libuv argument arrays. Returns the number of
+    // messages successfully sent (>= 0), or a negative error code.
+    int TrySendBatch(uv_buf_t* bufs[],
+                     unsigned int nbufs[],
+                     struct sockaddr* addrs[],
+                     size_t count);
 
     // Returns the local UDP socket address to which we are bound,
     // or fail with an assert if we are not bound.
diff --git a/src/quic/session.cc b/src/quic/session.cc
index e959e1a9194bd7..e69188d5edb370 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2141,12 +2141,8 @@ bool Session::ReadPacket(Store&& store,
     // libuv does not currently deliver per-packet ECN metadata. When
     // libuv gains ECN receive reporting, the pkt_info should be
     // populated from the per-packet metadata and passed through here.
-    err = ngtcp2_conn_read_pkt(*this,
-                               &path,
-                               nullptr,
-                               vec.base,
-                               vec.len,
-                               uv_hrtime());
+    err = ngtcp2_conn_read_pkt(
+        *this, &path, nullptr, vec.base, vec.len, uv_hrtime());
   }
   if (is_destroyed()) return false;
 
@@ -2255,6 +2251,61 @@ bool Session::ReadPacket(Store&& store,
   return false;
 }
 
+void Session::SendBatch(Packet::Ptr* packets,
+                        PathStorage* paths,
+                        size_t count) {
+  DCHECK(!is_destroyed());
+  if (count == 0) return;
+
+  // Separate packets into those going to the primary endpoint and those
+  // redirected to other endpoints (rare: path validation, preferred address).
+  // Redirected packets are sent individually via the target endpoint.
+  static constexpr size_t kMaxBatch = 64;
+  DCHECK_LE(count, kMaxBatch);
+  Packet::Ptr primary_packets[kMaxBatch];
+  size_t primary_count = 0;
+
+  for (size_t i = 0; i < count; i++) {
+    if (!packets[i] || !can_send_packets()) {
+      packets[i].reset();
+      continue;
+    }
+
+    UpdatePath(paths[i]);
+
+    // Check for cross-endpoint redirect.
+    bool redirected = false;
+    if (paths[i].path.local.addrlen > 0) {
+      SocketAddress local_addr(paths[i].path.local.addr);
+      auto& mgr = BindingData::Get(env()).session_manager();
+      Endpoint* target = mgr.FindEndpointForAddress(local_addr);
+      if (target != nullptr && target != &endpoint()) {
+        SocketAddress remote_addr(paths[i].path.remote.addr);
+        packets[i]->Redirect(static_cast<Packet::Listener*>(target),
+                             remote_addr);
+        target->Send(std::move(packets[i]));
+        redirected = true;
+      }
+    }
+
+    if (!redirected) {
+      primary_packets[primary_count++] = std::move(packets[i]);
+    }
+  }
+
+  if (primary_count == 0) return;
+
+  // Use batched send for the primary endpoint.
+  if (prefer_try_send_) {
+    endpoint().SendBatch(primary_packets, primary_count);
+  } else {
+    // Non-flush path: send individually via async uv_udp_send.
+    for (size_t i = 0; i < primary_count; i++) {
+      Send(std::move(primary_packets[i]));
+    }
+  }
+}
+
 void Session::FlushPendingData() {
   DCHECK(!is_destroyed());
   if (impl_->application_) {
diff --git a/src/quic/session.h b/src/quic/session.h
index 04c059b1225575..cddc6d070106b9 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -374,6 +374,13 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // bindingdata.cc doesn't need the full Application type definition.
   void FlushPendingData();
 
+  // Send a batch of packets accumulated by SendPendingData. Uses
+  // Endpoint::SendBatch (uv_udp_try_send2 / sendmmsg) for synchronous
+  // batched delivery when called from the deferred flush path.
+  // Handles per-packet path updates and cross-endpoint redirects.
+  // All Ptr entries are consumed (released or moved) on return.
+  void SendBatch(Packet::Ptr* packets, PathStorage* paths, size_t count);
+
   void Send(Packet::Ptr packet);
   void Send(Packet::Ptr packet, const PathStorage& path);
   datagram_id SendDatagram(Store&& data);

From 567ac2d505c8b16fd69a0414bd926b69eb9c1a76 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 10:00:17 -0700
Subject: [PATCH 49/83] quic: add support for future ECN marking

Set up for when libuv eventually supports ECN marking.
Pass the ECN marking stuff into ngtcp2.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc | 35 ++++++++++++++++++++++-------------
 src/quic/application.h  |  5 ++++-
 src/quic/data.h         | 34 ++++++++++++++++++++++++++++++++++
 src/quic/packet.h       |  3 +++
 src/quic/session.cc     | 18 ++++++++++--------
 src/quic/session.h      |  6 ++++--
 6 files changed, 77 insertions(+), 24 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index 499d80a2de3260..5f57b2ce1647fd 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -262,9 +262,12 @@ ssize_t Session::Application::TryWritePendingDatagram(PathStorage* path,
   int accepted = 0;
   int dg_flags = NGTCP2_WRITE_DATAGRAM_FLAG_MORE;
 
+  // PacketInfo for the datagram path. When libuv gains per-socket ECN
+  // marking, the value from ngtcp2 should be forwarded to the send path.
+  PacketInfo dg_pi;
   ssize_t dg_nwrite = ngtcp2_conn_writev_datagram(*session_,
                                                   &path->path,
-                                                  nullptr,
+                                                  dg_pi,
                                                   dest,
                                                   destlen,
                                                   &accepted,
@@ -390,12 +393,14 @@ void Session::Application::SendPendingData() {
   };
 
   // Accumulate a completed packet into the batch.
-  auto enqueue_packet = [&](Packet::Ptr& pkt, size_t len) {
-    Debug(session_, "Enqueuing packet with %zu bytes into batch", len);
-    pkt->Truncate(len);
-    path.CopyTo(&batch_paths[batch_count]);
-    batch[batch_count++] = std::move(pkt);
-  };
+  auto enqueue_packet =
+      [&](Packet::Ptr& pkt, size_t len, const PacketInfo& pi) {
+        Debug(session_, "Enqueuing packet with %zu bytes into batch", len);
+        pkt->Truncate(len);
+        pkt->set_pkt_info(pi);
+        path.CopyTo(&batch_paths[batch_count]);
+        batch[batch_count++] = std::move(pkt);
+      };
 
   // We're going to enter a loop here to prepare and send no more than
   // max_packet_count packets.
@@ -434,8 +439,9 @@ void Session::Application::SendPendingData() {
     }
 
     // Awesome, let's write our packet!
+    PacketInfo pi;
     ssize_t nwrite = WriteVStream(
-        &path, packet->data(), &ndatalen, packet->length(), stream_data);
+        &path, &pi, packet->data(), &ndatalen, packet->length(), stream_data);
 
     // When ndatalen is > 0, that's our indication that stream data was accepted
     // in to the packet. Yay!
@@ -531,7 +537,7 @@ void Session::Application::SendPendingData() {
             if (result > 0) {
               size_t len = result;
               Debug(session_, "Sending packet with %zu bytes", len);
-              enqueue_packet(packet, len);
+              enqueue_packet(packet, len, pi);
               if (++packet_send_count == max_packet_count) return;
             } else if (result < 0) {
               // Any negative result other than NGTCP2_ERR_WRITE_MORE
@@ -568,7 +574,7 @@ void Session::Application::SendPendingData() {
     // is the size of the packet we are sending.
     size_t len = nwrite;
     Debug(session_, "Sending packet with %zu bytes", len);
-    enqueue_packet(packet, len);
+    enqueue_packet(packet, len, pi);
     if (++packet_send_count == max_packet_count) return;
 
     // If there are pending datagrams, try sending them in a fresh packet.
@@ -587,7 +593,7 @@ void Session::Application::SendPendingData() {
           TryWritePendingDatagram(&path, packet->data(), packet->length());
       if (result > 0) {
         Debug(session_, "Sending datagram packet with %zd bytes", result);
-        enqueue_packet(packet, static_cast<size_t>(result));
+        enqueue_packet(packet, static_cast<size_t>(result), PacketInfo());
         if (++packet_send_count == max_packet_count) return;
       } else if (result < 0 && result != NGTCP2_ERR_WRITE_MORE) {
         // Fatal error — session already closed by TryWritePendingDatagram.
@@ -600,6 +606,7 @@ void Session::Application::SendPendingData() {
 }
 
 ssize_t Session::Application::WriteVStream(PathStorage* path,
+                                           PacketInfo* pi,
                                            uint8_t* dest,
                                            ssize_t* ndatalen,
                                            size_t max_packet_size,
@@ -607,10 +614,12 @@ ssize_t Session::Application::WriteVStream(PathStorage* path,
   DCHECK_LE(stream_data.count, kMaxVectorCount);
   uint32_t flags = NGTCP2_WRITE_STREAM_FLAG_MORE;
   if (stream_data.fin) flags |= NGTCP2_WRITE_STREAM_FLAG_FIN;
+  // The PacketInfo out-param is populated by ngtcp2 with the ECN codepoint
+  // to apply when sending this packet. When libuv gains per-socket ECN
+  // marking, the value should be forwarded to the send path.
   return ngtcp2_conn_writev_stream(*session_,
                                    &path->path,
-                                   // TODO(@jasnell): ECN blocked on libuv
-                                   nullptr,
+                                   *pi,
                                    dest,
                                    max_packet_size,
                                    ndatalen,
diff --git a/src/quic/application.h b/src/quic/application.h
index 673a4000e4ba2d..efce8c81ea60dd 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -269,8 +269,11 @@ class Session::Application : public MemoryRetainer {
                                   uint8_t* dest,
                                   size_t destlen);
 
-  // Write the given stream_data into the buffer.
+  // Write the given stream_data into the buffer. The PacketInfo out-param
+  // is populated by ngtcp2 with per-packet metadata (e.g., ECN codepoint)
+  // that should be applied when sending the packet.
   ssize_t WriteVStream(PathStorage* path,
+                       PacketInfo* pi,
                        uint8_t* buf,
                        ssize_t* ndatalen,
                        size_t max_packet_size,
diff --git a/src/quic/data.h b/src/quic/data.h
index 2b6d777caf7b81..ec8d40cbc4c7a0 100644
--- a/src/quic/data.h
+++ b/src/quic/data.h
@@ -19,6 +19,40 @@ namespace node::quic {
 template <typename T>
 concept OneByteType = sizeof(T) == 1;
 
+// Lightweight wrapper around ngtcp2_pkt_info. Insulates the Node.js QUIC
+// code from the ngtcp2 struct layout and provides a clean API boundary
+// for per-packet metadata (currently ECN codepoint; may grow as ngtcp2
+// and libuv evolve).
+//
+// Default-constructed PacketInfo is zero-initialized, which ngtcp2 treats
+// as ECN Not-ECT — identical to passing nullptr for the pkt_info parameter.
+class PacketInfo final {
+ public:
+  // ECN codepoints as defined by RFC 3168.
+  enum class Ecn : uint32_t {
+    NOT_ECT = 0,  // Not ECN-Capable Transport
+    ECT_1 = 1,    // ECN-Capable Transport(1)
+    ECT_0 = 2,    // ECN-Capable Transport(0)
+    CE = 3,       // Congestion Experienced
+  };
+
+  PacketInfo() : info_{} {}
+  explicit PacketInfo(const ngtcp2_pkt_info& info) : info_(info) {}
+
+  // ECN codepoint for this packet. When libuv gains per-packet ECN
+  // reporting, populate via set_ecn() from the receive metadata
+  // before passing to ReadPacket().
+  Ecn ecn() const { return static_cast<Ecn>(info_.ecn); }
+  void set_ecn(Ecn ecn) { info_.ecn = static_cast<uint32_t>(ecn); }
+
+  // Conversion operators for ngtcp2 API calls.
+  operator const ngtcp2_pkt_info*() const { return &info_; }
+  operator ngtcp2_pkt_info*() { return &info_; }
+
+ private:
+  ngtcp2_pkt_info info_;
+};
+
 struct Path final : public ngtcp2_path {
   explicit Path(const SocketAddress& local, const SocketAddress& remote);
   Path(Path&& other) noexcept = default;
diff --git a/src/quic/packet.h b/src/quic/packet.h
index ffeb582471333f..a94ee1264c2a6a 100644
--- a/src/quic/packet.h
+++ b/src/quic/packet.h
@@ -68,6 +68,8 @@ class Packet final {
   size_t length() const { return length_; }
   size_t capacity() const { return capacity_; }
   const SocketAddress& destination() const { return destination_; }
+  const PacketInfo& pkt_info() const { return pkt_info_; }
+  void set_pkt_info(const PacketInfo& pi) { pkt_info_ = pi; }
   Listener* listener() const { return listener_; }
 
   // Redirect the packet to a different endpoint for cross-endpoint sends
@@ -148,6 +150,7 @@ class Packet final {
   Listener* listener_;
 
   // Touched at send time.
+  PacketInfo pkt_info_;
   SocketAddress destination_;
 
   // Only touched by libuv during uv_udp_send and in the send callback.
diff --git a/src/quic/session.cc b/src/quic/session.cc
index e69188d5edb370..59df31ffad2a09 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2103,19 +2103,21 @@ void Session::SetLastError(QuicError&& error) {
 
 bool Session::Receive(Store&& store,
                       const SocketAddress& local_address,
-                      const SocketAddress& remote_address) {
+                      const SocketAddress& remote_address,
+                      const PacketInfo& pkt_info) {
   // Convenience wrapper: reads the packet and immediately triggers
   // SendPendingData. Used by paths that need an immediate response
   // (e.g., Endpoint::Connect for client Initial packets).
   // The hot receive path uses ReadPacket() directly with deferred
   // flush via BindingData's uv_check callback.
   SendPendingDataScope send_scope(this);
-  return ReadPacket(std::move(store), local_address, remote_address);
+  return ReadPacket(std::move(store), local_address, remote_address, pkt_info);
 }
 
 bool Session::ReadPacket(Store&& store,
                          const SocketAddress& local_address,
-                         const SocketAddress& remote_address) {
+                         const SocketAddress& remote_address,
+                         const PacketInfo& pkt_info) {
   DCHECK(!is_destroyed());
   impl_->remote_address_ = remote_address;
 
@@ -2137,12 +2139,12 @@ bool Session::ReadPacket(Store&& store,
   int err;
   {
     NgTcp2CallbackScope callback_scope(this);
-    // ECN codepoint (ngtcp2_pkt_info.ecn) is not yet populated because
-    // libuv does not currently deliver per-packet ECN metadata. When
-    // libuv gains ECN receive reporting, the pkt_info should be
-    // populated from the per-packet metadata and passed through here.
+    // The PacketInfo carries per-packet metadata (currently ECN codepoint).
+    // When libuv gains per-packet ECN reporting, the caller should
+    // populate pkt_info from the receive metadata before calling
+    // ReadPacket().
     err = ngtcp2_conn_read_pkt(
-        *this, &path, nullptr, vec.base, vec.len, uv_hrtime());
+        *this, &path, pkt_info, vec.base, vec.len, uv_hrtime());
   }
   if (is_destroyed()) return false;
 
diff --git a/src/quic/session.h b/src/quic/session.h
index cddc6d070106b9..d15cf00e8f8ca2 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -355,7 +355,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
 
   bool Receive(Store&& store,
                const SocketAddress& local_address,
-               const SocketAddress& remote_address);
+               const SocketAddress& remote_address,
+               const PacketInfo& pkt_info = PacketInfo());
 
   // ReadPacket processes a single inbound packet through ngtcp2 without
   // triggering SendPendingData. This is the building block for batched
@@ -367,7 +368,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // immediate response).
   bool ReadPacket(Store&& store,
                   const SocketAddress& local_address,
-                  const SocketAddress& remote_address);
+                  const SocketAddress& remote_address,
+                  const PacketInfo& pkt_info = PacketInfo());
 
   // Called by BindingData's flush callback to trigger SendPendingData
   // on this session. Encapsulates the application() access so that

From f341ad7abb0c24f57a4f86b661b9a52fed521e7b Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 10:13:55 -0700
Subject: [PATCH 50/83] quic: cache the timestamp on send and receive

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc | 24 +++++++++++++++++-------
 src/quic/application.h  |  6 ++++--
 src/quic/session.cc     | 15 +++++++++++----
 src/quic/session.h      |  9 +++++++--
 4 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index 5f57b2ce1647fd..21475df68e4d1a 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -239,7 +239,8 @@ void Session::Application::ReceiveStreamReset(Stream* stream,
 //   < 0 (other): fatal error, session already closed
 ssize_t Session::Application::TryWritePendingDatagram(PathStorage* path,
                                                       uint8_t* dest,
-                                                      size_t destlen) {
+                                                      size_t destlen,
+                                                      uint64_t ts) {
   CHECK(session_->HasPendingDatagrams());
   auto max_attempts = session_->config().options.max_datagram_send_attempts;
 
@@ -275,7 +276,7 @@ ssize_t Session::Application::TryWritePendingDatagram(PathStorage* path,
                                                   dg.id,
                                                   &dgvec,
                                                   1,
-                                                  uv_hrtime());
+                                                  ts);
 
   if (accepted) {
     // Nice, the datagram was accepted!
@@ -338,6 +339,13 @@ void Session::Application::SendPendingData() {
   // call is dynamically capped by ngtcp2_conn_get_send_quantum().
   static constexpr size_t kMaxPackets = 64;
   Debug(session_, "Application sending pending data");
+  // Cache the timestamp once for the entire send loop. ngtcp2 does not
+  // require nanosecond-accurate monotonicity within a single burst —
+  // a single timestamp per SendPendingData call is what other QUIC
+  // implementations use (e.g., quiche, msquic). When kernel-level
+  // packet pacing becomes available via libuv, this timestamp becomes
+  // the base for computing per-packet transmit timestamps.
+  const uint64_t ts = uv_hrtime();
   PathStorage path;
   StreamData stream_data;
 
@@ -441,7 +449,8 @@ void Session::Application::SendPendingData() {
     // Awesome, let's write our packet!
     PacketInfo pi;
     ssize_t nwrite = WriteVStream(
-        &path, &pi, packet->data(), &ndatalen, packet->length(), stream_data);
+        &path, &pi, packet->data(), &ndatalen, packet->length(),
+        stream_data, ts);
 
     // When ndatalen is > 0, that's our indication that stream data was accepted
     // in to the packet. Yay!
@@ -528,7 +537,7 @@ void Session::Application::SendPendingData() {
           // if there is one. Otherwise just loop around and keep going.
           if (session_->HasPendingDatagrams()) {
             auto result = TryWritePendingDatagram(
-                &path, packet->data(), packet->length());
+                &path, packet->data(), packet->length(), ts);
             // When result is 0, either the datagram was congestion controlled,
             // didn't fit in the packet, or was abandoned. Skip and continue.
 
@@ -590,7 +599,7 @@ void Session::Application::SendPendingData() {
         return session_->Close(CloseMethod::SILENT);
       }
       auto result =
-          TryWritePendingDatagram(&path, packet->data(), packet->length());
+          TryWritePendingDatagram(&path, packet->data(), packet->length(), ts);
       if (result > 0) {
         Debug(session_, "Sending datagram packet with %zd bytes", result);
         enqueue_packet(packet, static_cast<size_t>(result), PacketInfo());
@@ -610,7 +619,8 @@ ssize_t Session::Application::WriteVStream(PathStorage* path,
                                            uint8_t* dest,
                                            ssize_t* ndatalen,
                                            size_t max_packet_size,
-                                           const StreamData& stream_data) {
+                                           const StreamData& stream_data,
+                                           uint64_t ts) {
   DCHECK_LE(stream_data.count, kMaxVectorCount);
   uint32_t flags = NGTCP2_WRITE_STREAM_FLAG_MORE;
   if (stream_data.fin) flags |= NGTCP2_WRITE_STREAM_FLAG_FIN;
@@ -627,7 +637,7 @@ ssize_t Session::Application::WriteVStream(PathStorage* path,
                                    stream_data.id,
                                    stream_data,
                                    stream_data.count,
-                                   uv_hrtime());
+                                   ts);
 }
 
 // ============================================================================
diff --git a/src/quic/application.h b/src/quic/application.h
index efce8c81ea60dd..59583b941b95b4 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -267,7 +267,8 @@ class Session::Application : public MemoryRetainer {
   // the datagram is either congestion limited or was abandoned
   ssize_t TryWritePendingDatagram(PathStorage* path,
                                   uint8_t* dest,
-                                  size_t destlen);
+                                  size_t destlen,
+                                  uint64_t ts);
 
   // Write the given stream_data into the buffer. The PacketInfo out-param
   // is populated by ngtcp2 with per-packet metadata (e.g., ECN codepoint)
@@ -277,7 +278,8 @@ class Session::Application : public MemoryRetainer {
                        uint8_t* buf,
                        ssize_t* ndatalen,
                        size_t max_packet_size,
-                       const StreamData& stream_data);
+                       const StreamData& stream_data,
+                       uint64_t ts);
 
   Session* session_ = nullptr;
 };
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 59df31ffad2a09..a911ad5acd079c 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2104,20 +2104,23 @@ void Session::SetLastError(QuicError&& error) {
 bool Session::Receive(Store&& store,
                       const SocketAddress& local_address,
                       const SocketAddress& remote_address,
-                      const PacketInfo& pkt_info) {
+                      const PacketInfo& pkt_info,
+                      uint64_t ts) {
   // Convenience wrapper: reads the packet and immediately triggers
   // SendPendingData. Used by paths that need an immediate response
   // (e.g., Endpoint::Connect for client Initial packets).
   // The hot receive path uses ReadPacket() directly with deferred
   // flush via BindingData's uv_check callback.
   SendPendingDataScope send_scope(this);
-  return ReadPacket(std::move(store), local_address, remote_address, pkt_info);
+  return ReadPacket(
+      std::move(store), local_address, remote_address, pkt_info, ts);
 }
 
 bool Session::ReadPacket(Store&& store,
                          const SocketAddress& local_address,
                          const SocketAddress& remote_address,
-                         const PacketInfo& pkt_info) {
+                         const PacketInfo& pkt_info,
+                         uint64_t ts) {
   DCHECK(!is_destroyed());
   impl_->remote_address_ = remote_address;
 
@@ -2143,8 +2146,12 @@ bool Session::ReadPacket(Store&& store,
     // When libuv gains per-packet ECN reporting, the caller should
     // populate pkt_info from the receive metadata before calling
     // ReadPacket().
+    // When ts is 0 (the default), call uv_hrtime() here. The batched
+    // receive path caches a timestamp and passes it to all ReadPacket()
+    // calls in the same I/O burst.
+    if (ts == 0) ts = uv_hrtime();
     err = ngtcp2_conn_read_pkt(
-        *this, &path, pkt_info, vec.base, vec.len, uv_hrtime());
+        *this, &path, pkt_info, vec.base, vec.len, ts);
   }
   if (is_destroyed()) return false;
 
diff --git a/src/quic/session.h b/src/quic/session.h
index d15cf00e8f8ca2..c93c604dc33e6b 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -356,7 +356,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   bool Receive(Store&& store,
                const SocketAddress& local_address,
                const SocketAddress& remote_address,
-               const PacketInfo& pkt_info = PacketInfo());
+               const PacketInfo& pkt_info = PacketInfo(),
+               uint64_t ts = 0);
 
   // ReadPacket processes a single inbound packet through ngtcp2 without
   // triggering SendPendingData. This is the building block for batched
@@ -366,10 +367,14 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // Receive() is kept as a convenience wrapper that calls ReadPacket()
   // then triggers SendPendingData (for paths like Connect that need
   // immediate response).
+  // When ts is 0 (the default), uv_hrtime() is called internally.
+  // The batched receive path caches a timestamp and passes it to all
+  // ReadPacket() calls in the same I/O burst.
   bool ReadPacket(Store&& store,
                   const SocketAddress& local_address,
                   const SocketAddress& remote_address,
-                  const PacketInfo& pkt_info = PacketInfo());
+                  const PacketInfo& pkt_info = PacketInfo(),
+                  uint64_t ts = 0);
 
   // Called by BindingData's flush callback to trigger SendPendingData
   // on this session. Encapsulates the application() access so that

From b6c6a83aa20a6c36cb48477de6d66d32f857d51f Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 10:55:55 -0700
Subject: [PATCH 51/83] quic: eliminate per-received datagram allocation

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc | 10 +++--
 src/quic/endpoint.cc    | 94 +++++++++++++++++++----------------------
 src/quic/endpoint.h     |  2 +-
 src/quic/session.cc     | 21 +++++----
 src/quic/session.h      |  9 +++-
 5 files changed, 68 insertions(+), 68 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index 21475df68e4d1a..a44a60f4b48cc8 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -448,9 +448,13 @@ void Session::Application::SendPendingData() {
 
     // Awesome, let's write our packet!
     PacketInfo pi;
-    ssize_t nwrite = WriteVStream(
-        &path, &pi, packet->data(), &ndatalen, packet->length(),
-        stream_data, ts);
+    ssize_t nwrite = WriteVStream(&path,
+                                  &pi,
+                                  packet->data(),
+                                  &ndatalen,
+                                  packet->length(),
+                                  stream_data,
+                                  ts);
 
     // When ndatalen is > 0, that's our indication that stream data was accepted
     // in to the packet. Yay!
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 5c7657b4d86029..083141642e5b38 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -312,10 +312,18 @@ class Endpoint::UDP::Impl final : public HandleWrap {
   SET_SELF_SIZE(Impl)
 
  private:
+  // Pre-allocated receive buffer. Reused across all datagrams because
+  // ngtcp2_conn_read_pkt is synchronous — it copies what it needs and
+  // does not retain a reference to the buffer after returning. This
+  // eliminates a malloc(64KB)/free(64KB) cycle per received datagram.
+  static constexpr size_t kRecvBufferSize = 65536;  // UV__UDP_DGRAM_MAXSIZE
+  char recv_buf_[kRecvBufferSize];
+
   static void OnAlloc(uv_handle_t* handle,
                       size_t suggested_size,
                       uv_buf_t* buf) {
-    *buf = From(handle)->env()->allocate_managed_buffer(suggested_size);
+    auto* impl = From(handle);
+    *buf = uv_buf_init(impl->recv_buf_, kRecvBufferSize);
   }
 
   static void OnReceive(uv_udp_t* handle,
@@ -327,26 +335,22 @@ class Endpoint::UDP::Impl final : public HandleWrap {
     DCHECK_NOT_NULL(impl);
     DCHECK_NOT_NULL(impl->endpoint_);
 
-    auto release_buf = [&]() {
-      if (buf->base != nullptr) impl->env()->release_managed_buffer(*buf);
-    };
-
     // Nothing to do in these cases. Specifically, if the nread
     // is zero or we have received a partial packet, we are just
-    // going to ignore it.
+    // going to ignore it. No buffer release needed — recv_buf_
+    // is pre-allocated and reused.
     if (nread == 0 || flags & UV_UDP_PARTIAL) {
-      release_buf();
       return;
     }
 
     if (nread < 0) {
-      release_buf();
       impl->endpoint_->Destroy(CloseContext::RECEIVE_FAILURE,
                                static_cast<int>(nread));
       return;
     }
 
-    impl->endpoint_->Receive(uv_buf_init(buf->base, static_cast<size_t>(nread)),
+    impl->endpoint_->Receive(reinterpret_cast<const uint8_t*>(buf->base),
+                             static_cast<size_t>(nread),
                              SocketAddress(addr));
   }
 
@@ -1240,24 +1244,25 @@ void Endpoint::CloseGracefully() {
   MaybeDestroy();
 }
 
-void Endpoint::Receive(const uv_buf_t& buf,
+void Endpoint::Receive(const uint8_t* data,
+                       size_t len,
                        const SocketAddress& remote_address) {
   const auto receive = [&](Session* session,
-                           Store&& store,
+                           const uint8_t* pkt_data,
+                           size_t pkt_len,
                            const SocketAddress& local_address,
                            const SocketAddress& remote_address,
                            const CID& dcid,
                            const CID& scid) {
     DCHECK_NOT_NULL(session);
     if (session->is_destroyed()) return;
-    size_t len = store.length();
     // Use ReadPacket (no SendPendingDataScope) so that multiple packets
     // received in the same I/O burst are processed before any responses
     // are generated. The deferred flush via BindingData's uv_check
     // callback calls SendPendingData once per dirty session after all
     // packets in the burst have been read.
-    if (session->ReadPacket(std::move(store), local_address, remote_address)) {
-      STAT_INCREMENT_N(Stats, bytes_received, len);
+    if (session->ReadPacket(pkt_data, pkt_len, local_address, remote_address)) {
+      STAT_INCREMENT_N(Stats, bytes_received, pkt_len);
       STAT_INCREMENT(Stats, packets_received);
     }
     // Schedule the session for deferred SendPendingData if it hasn't
@@ -1269,7 +1274,9 @@ void Endpoint::Receive(const uv_buf_t& buf,
     }
   };
 
-  const auto accept = [&](const Session::Config& config, Store&& store) {
+  const auto accept = [&](const Session::Config& config,
+                          const uint8_t* pkt_data,
+                          size_t pkt_len) {
     // One final check. If the endpoint is closed, closing, or is not listening
     // as a server, then we cannot accept the initial packet.
     if (is_closed() || is_closing() || !is_listening()) return;
@@ -1299,7 +1306,8 @@ void Endpoint::Receive(const uv_buf_t& buf,
       return;
 
     receive(session.get(),
-            std::move(store),
+            pkt_data,
+            pkt_len,
             config.local_address,
             config.remote_address,
             config.dcid,
@@ -1309,7 +1317,8 @@ void Endpoint::Receive(const uv_buf_t& buf,
   const auto acceptInitialPacket = [&](const uint32_t version,
                                        const CID& dcid,
                                        const CID& scid,
-                                       Store&& store,
+                                       const uint8_t* pkt_data,
+                                       size_t pkt_len,
                                        const SocketAddress& local_address,
                                        const SocketAddress& remote_address) {
     // If we're not listening as a server, do not accept an initial packet.
@@ -1319,8 +1328,7 @@ void Endpoint::Receive(const uv_buf_t& buf,
 
     // This is our first condition check... A minimal check to see if ngtcp2 can
     // even recognize this packet as a quic packet.
-    ngtcp2_vec vec = store;
-    if (ngtcp2_accept(&hd, vec.base, vec.len) != NGTCP2_SUCCESS) {
+    if (ngtcp2_accept(&hd, pkt_data, pkt_len) != NGTCP2_SUCCESS) {
       // Per the ngtcp2 docs, ngtcp2_accept returns 0 if the check was
       // successful, or an error code if it was not. Currently there's only one
       // documented error code (NGTCP2_ERR_INVALID_ARGUMENT) but we'll handle
@@ -1558,7 +1566,7 @@ void Endpoint::Receive(const uv_buf_t& buf,
       }
     }
 
-    accept(config, std::move(store));
+    accept(config, pkt_data, pkt_len);
   };
 
   // When a received packet contains a QUIC short header but cannot be matched
@@ -1574,14 +1582,15 @@ void Endpoint::Receive(const uv_buf_t& buf,
   // possible to avoid a DOS vector.
   const auto maybeStatelessReset = [&](const CID& dcid,
                                        const CID& scid,
-                                       Store& store,
+                                       const uint8_t* pkt_data,
+                                       size_t pkt_len,
                                        const SocketAddress& local_address,
                                        const SocketAddress& remote_address) {
     // Support for stateless resets can be disabled by the application. If that
     // case, or if the packet is too short to contain a reset token, then we
     // skip the remaining checks.
     if (options_.disable_stateless_reset ||
-        store.length() < NGTCP2_STATELESS_RESET_TOKENLEN) {
+        pkt_len < NGTCP2_STATELESS_RESET_TOKENLEN) {
       return false;
     }
 
@@ -1589,20 +1598,21 @@ void Endpoint::Receive(const uv_buf_t& buf,
     // NGTCP2_STATELESS_RESET_TOKENLEN bytes in the received packet. If it is a
     // stateless reset then then rest of the bytes in the packet are garbage
     // that we'll ignore.
-    ngtcp2_vec vec = store;
-    vec.base += (vec.len - NGTCP2_STATELESS_RESET_TOKENLEN);
+    const uint8_t* token_pos =
+        pkt_data + (pkt_len - NGTCP2_STATELESS_RESET_TOKENLEN);
 
     // If a Session has been associated with the token, then it is a valid
     // stateless reset token. We need to dispatch it to the session to be
     // processed.
     auto* session = session_manager().FindSessionByStatelessResetToken(
-        StatelessResetToken(vec.base));
+        StatelessResetToken(token_pos));
     if (session != nullptr) {
       // If the session happens to have been destroyed already, we'll
       // just ignore the packet.
       if (!session->is_destroyed()) [[likely]] {
         receive(session,
-                std::move(store),
+                pkt_data,
+                pkt_len,
                 local_address,
                 remote_address,
                 dcid,
@@ -1630,22 +1640,8 @@ void Endpoint::Receive(const uv_buf_t& buf,
   //   return;
   // }
 
-  Debug(this, "Received %zu-byte packet from %s", buf.len, remote_address);
-
-  // The managed buffer here contains the received packet. We do not yet know
-  // at this point if it is a valid QUIC packet. We need to do some basic
-  // checks. It is critical at this point that we do as little work as possible
-  // to avoid a DOS vector.
-  std::shared_ptr<BackingStore> backing = env()->release_managed_buffer(buf);
-  if (!backing) [[unlikely]] {
-    // At this point something bad happened and we need to treat this as a fatal
-    // case. There's likely no way to test this specific condition reliably.
-    return Destroy(CloseContext::RECEIVE_FAILURE, UV_ENOMEM);
-  }
-
-  Store store(std::move(backing), buf.len, 0);
+  Debug(this, "Received %zu-byte packet from %s", len, remote_address);
 
-  ngtcp2_vec vec = store;
   ngtcp2_version_cid pversion_cid;
 
   // This is our first check to see if the received data can be processed as a
@@ -1654,7 +1650,7 @@ void Endpoint::Receive(const uv_buf_t& buf,
   // valid QUIC header but there is still no guarantee that the packet can be
   // successfully processed.
   switch (ngtcp2_pkt_decode_version_cid(
-      &pversion_cid, vec.base, vec.len, NGTCP2_MAX_CIDLEN)) {
+      &pversion_cid, data, len, NGTCP2_MAX_CIDLEN)) {
     case 0:
       break;  // Supported version, continue processing.
     case NGTCP2_ERR_VERSION_NEGOTIATION: {
@@ -1732,7 +1728,7 @@ void Endpoint::Receive(const uv_buf_t& buf,
     // necessary here. We want to return immediately without committing any
     // further resources.
     if (pversion_cid.version == 0 &&
-        maybeStatelessReset(dcid, scid, store, addr, remote_address)) {
+        maybeStatelessReset(dcid, scid, data, len, addr, remote_address)) {
       Debug(this, "Packet was a stateless reset");
       return;  // Stateless reset! Don't do any further processing.
     }
@@ -1747,17 +1743,13 @@ void Endpoint::Receive(const uv_buf_t& buf,
       SendStatelessReset(
           PathDescriptor{
               pversion_cid.version, dcid, scid, addr, remote_address},
-          store.length());
+          len);
       return;
     }
 
     // Process the packet as an initial packet...
-    return acceptInitialPacket(pversion_cid.version,
-                               dcid,
-                               scid,
-                               std::move(store),
-                               addr,
-                               remote_address);
+    return acceptInitialPacket(
+        pversion_cid.version, dcid, scid, data, len, addr, remote_address);
   }
 
   if (session->is_destroyed()) [[unlikely]] {
@@ -1769,7 +1761,7 @@ void Endpoint::Receive(const uv_buf_t& buf,
   // If we got here, the dcid matched the scid of a known local session. Yay!
   // The session will take over any further processing of the packet.
   Debug(this, "Dispatching packet to known session");
-  receive(session.get(), std::move(store), addr, remote_address, dcid, scid);
+  receive(session.get(), data, len, addr, remote_address, dcid, scid);
 
   // It is important to note that the session may have been destroyed during
   // the call to receive(...). If that's the case, the session object still
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index 43760702ca7bf9..188246546b6906 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -409,7 +409,7 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
   // Ref() causes a listening Endpoint to keep the event loop active.
   JS_METHOD(Ref);
 
-  void Receive(const uv_buf_t& buf, const SocketAddress& from);
+  void Receive(const uint8_t* data, size_t len, const SocketAddress& from);
 
   AliasedStruct<Stats> stats_;
   AliasedStruct<State> state_;
diff --git a/src/quic/session.cc b/src/quic/session.cc
index a911ad5acd079c..4ec2b578519dd8 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2101,7 +2101,8 @@ void Session::SetLastError(QuicError&& error) {
   impl_->last_error_ = std::move(error);
 }
 
-bool Session::Receive(Store&& store,
+bool Session::Receive(const uint8_t* data,
+                      size_t len,
                       const SocketAddress& local_address,
                       const SocketAddress& remote_address,
                       const PacketInfo& pkt_info,
@@ -2112,11 +2113,11 @@ bool Session::Receive(Store&& store,
   // The hot receive path uses ReadPacket() directly with deferred
   // flush via BindingData's uv_check callback.
   SendPendingDataScope send_scope(this);
-  return ReadPacket(
-      std::move(store), local_address, remote_address, pkt_info, ts);
+  return ReadPacket(data, len, local_address, remote_address, pkt_info, ts);
 }
 
-bool Session::ReadPacket(Store&& store,
+bool Session::ReadPacket(const uint8_t* data,
+                         size_t len,
                          const SocketAddress& local_address,
                          const SocketAddress& remote_address,
                          const PacketInfo& pkt_info,
@@ -2124,12 +2125,11 @@ bool Session::ReadPacket(Store&& store,
   DCHECK(!is_destroyed());
   impl_->remote_address_ = remote_address;
 
-  ngtcp2_vec vec = store;
   Path path(local_address, remote_address);
 
   Debug(this,
         "Session is receiving %zu-byte packet received along path %s",
-        vec.len,
+        len,
         path);
 
   // It is important to understand that reading the packet will cause
@@ -2150,19 +2150,18 @@ bool Session::ReadPacket(Store&& store,
     // receive path caches a timestamp and passes it to all ReadPacket()
     // calls in the same I/O burst.
     if (ts == 0) ts = uv_hrtime();
-    err = ngtcp2_conn_read_pkt(
-        *this, &path, pkt_info, vec.base, vec.len, ts);
+    err = ngtcp2_conn_read_pkt(*this, &path, pkt_info, data, len, ts);
   }
   if (is_destroyed()) return false;
 
-  Debug(this, "Session receiving %zu-byte packet with result %d", vec.len, err);
+  Debug(this, "Session receiving %zu-byte packet with result %d", len, err);
 
   switch (err) {
     case 0: {
-      Debug(this, "Session successfully received %zu-byte packet", vec.len);
+      Debug(this, "Session successfully received %zu-byte packet", len);
       if (!is_destroyed()) [[likely]] {
         auto& stats_ = impl_->stats_;
-        STAT_INCREMENT_N(Stats, bytes_received, vec.len);
+        STAT_INCREMENT_N(Stats, bytes_received, len);
         // Process deferred operations that couldn't run inside callback
         // scopes (e.g., HTTP/3 GOAWAY handling that calls into JS).
         application().PostReceive();
diff --git a/src/quic/session.h b/src/quic/session.h
index c93c604dc33e6b..0ac183b3272258 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -353,7 +353,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     bool early = false;
   };
 
-  bool Receive(Store&& store,
+  bool Receive(const uint8_t* data,
+               size_t len,
                const SocketAddress& local_address,
                const SocketAddress& remote_address,
                const PacketInfo& pkt_info = PacketInfo(),
@@ -367,10 +368,14 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // Receive() is kept as a convenience wrapper that calls ReadPacket()
   // then triggers SendPendingData (for paths like Connect that need
   // immediate response).
+  // The data pointer is used synchronously — ngtcp2_conn_read_pkt does
+  // not retain a reference after returning, so the caller's buffer can
+  // be reused immediately.
   // When ts is 0 (the default), uv_hrtime() is called internally.
   // The batched receive path caches a timestamp and passes it to all
   // ReadPacket() calls in the same I/O burst.
-  bool ReadPacket(Store&& store,
+  bool ReadPacket(const uint8_t* data,
+                  size_t len,
                   const SocketAddress& local_address,
                   const SocketAddress& remote_address,
                   const PacketInfo& pkt_info = PacketInfo(),

From fcddd35095f8d754729527b2b7b300a549db2a20 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 11:36:40 -0700
Subject: [PATCH 52/83] quic: fix crash in early handshake failure

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/http3.cc                             | 10 +++-
 .../test-quic-h3-handshake-failure.mjs        | 56 +++++++++++++++++++
 2 files changed, 64 insertions(+), 2 deletions(-)
 create mode 100644 test/parallel/test-quic-h3-handshake-failure.mjs

diff --git a/src/quic/http3.cc b/src/quic/http3.cc
index ea07c0a5a596fb..6717ac064801cb 100644
--- a/src/quic/http3.cc
+++ b/src/quic/http3.cc
@@ -262,11 +262,17 @@ class Http3ApplicationImpl final : public Session::Application {
   }
 
   void BeginShutdown() override {
-    if (conn_) nghttp3_conn_submit_shutdown_notice(*this);
+    // Only submit a shutdown notice if the H3 connection was fully
+    // started (control streams bound). If the TLS handshake failed
+    // before Start() was called, conn_ exists but its control streams
+    // are unbound, and nghttp3_conn_submit_shutdown_notice would crash.
+    if (conn_ && started_) nghttp3_conn_submit_shutdown_notice(*this);
   }
 
   void CompleteShutdown() override {
-    if (conn_) nghttp3_conn_shutdown(*this);
+    // Same guard as BeginShutdown — nghttp3_conn_shutdown asserts
+    // that the control stream is bound (conn->tx.ctrl != NULL).
+    if (conn_ && started_) nghttp3_conn_shutdown(*this);
   }
 
   bool ReceiveStreamData(stream_id id,
diff --git a/test/parallel/test-quic-h3-handshake-failure.mjs b/test/parallel/test-quic-h3-handshake-failure.mjs
new file mode 100644
index 00000000000000..128acab8fffe3d
--- /dev/null
+++ b/test/parallel/test-quic-h3-handshake-failure.mjs
@@ -0,0 +1,56 @@
+// Flags: --experimental-quic --no-warnings
+
+// Regression test: HTTP/3 server must not crash when a session is closed
+// before the H3 application is fully started (control streams bound).
+// Previously, closing such a session would call nghttp3_conn_shutdown on
+// an H3 connection whose control streams were never bound, causing an
+// assertion failure in nghttp3 (conn->tx.ctrl != NULL).
+//
+// The test creates an H3 server and a client that immediately closes the
+// session before the handshake completes. The server creates the H3
+// application during ALPN negotiation, but Start() (which binds control
+// streams) hasn't been called yet when the session is torn down.
+// The server must handle this gracefully without crashing.
+
+import { hasQuic, skip, mustNotCall } from '../common/index.mjs';
+import { setTimeout } from 'node:timers/promises';
+import * as fixtures from '../common/fixtures.mjs';
+
+const { readKey } = fixtures;
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const key = createPrivateKey(readKey('agent1-key.pem'));
+const cert = readKey('agent1-cert.pem');
+
+const serverEndpoint = await listen(async (serverSession) => {
+  await serverSession.closed;
+}, {
+  sni: { '*': { keys: [key], certs: [cert] } },
+  onheaders: mustNotCall(),
+});
+
+// Connect then immediately close the session before the handshake completes.
+// This exercises the H3 shutdown path on the server while the H3 application
+// exists but hasn't started (control streams not yet bound).
+const clientSession = await connect(serverEndpoint.address, {
+  servername: 'localhost',
+  // h3 ALPN — must match the server so the H3 application is selected
+  // on the server side before we tear it down.
+});
+
+// Close immediately — don't wait for handshake.
+await clientSession.close();
+
+// Give the server time to process the close and tear down the session.
+await setTimeout(500);
+
+// The critical assertion: reaching this point without a crash means the
+// server correctly handled the H3 shutdown before control streams were
+// bound. Verify the endpoint is still alive by closing it gracefully.
+await serverEndpoint.close();

From 554b208aee12d582150e436f54b14403b0687095 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 12:09:28 -0700
Subject: [PATCH 53/83] quic: fixup linting issue after other changes

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/endpoint.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 083141642e5b38..e871d59545a6e8 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -29,7 +29,6 @@ namespace node {
 
 using v8::Array;
 using v8::ArrayBufferView;
-using v8::BackingStore;
 using v8::HandleScope;
 using v8::Integer;
 using v8::Just;

From befc5f934b69fe73b5fefafec1c93b6a0463b3ae Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 12:19:52 -0700
Subject: [PATCH 54/83] quic: implement rate limiting for version nego and
 immediate close

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/endpoint.cc | 50 ++++++++++++++++++++++++++++++++------------
 src/quic/endpoint.h  | 16 ++++++++++++++
 2 files changed, 53 insertions(+), 13 deletions(-)

diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index e871d59545a6e8..70ebecfacd3183 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -966,22 +966,30 @@ void Endpoint::SendRetry(const PathDescriptor& options) {
 
 void Endpoint::SendVersionNegotiation(const PathDescriptor& options) {
   Debug(this, "Sending version negotiation on path %s", options);
-  // While creating and sending a version negotiation packet does consume a
-  // small amount of system resources, and while it is fairly trivial for a
-  // malicious peer to force a version negotiation to be sent, these are more
-  // trivial to create than the cryptographically generated retry and stateless
-  // reset packets. If the packet is sent, then we'll at least increment the
-  // version_negotiation_count statistic so that application code can keep an
-  // eye on it.
+  // A malicious peer can trivially force version negotiation packets by
+  // sending packets with unsupported QUIC versions, potentially from
+  // spoofed source addresses. Rate-limit per remote host to prevent
+  // amplification attacks.
+  const auto exceeds_limits = [&] {
+    SocketAddressInfoTraits::Type* counts =
+        addr_validation_lru_.Peek(options.remote_address);
+    auto count = counts != nullptr ? counts->version_negotiation_count : 0;
+    return count >= kMaxVersionNegotiations;
+  };
+
+  if (exceeds_limits()) {
+    Debug(this, "Version negotiation rate limit exceeded for %s",
+          options.remote_address);
+    return;
+  }
+
   auto packet = Packet::CreateVersionNegotiationPacket(*this, options);
   if (packet) {
+    addr_validation_lru_.Upsert(options.remote_address)
+        ->version_negotiation_count++;
     STAT_INCREMENT(Stats, version_negotiation_count);
     Send(std::move(packet));
   }
-
-  // If creating the packet is unsuccessful, we just drop things on the floor.
-  // It's not worth committing any further resources to this one packet. We
-  // might want to log the failure at some point tho.
 }
 
 bool Endpoint::SendStatelessReset(const PathDescriptor& options,
@@ -1028,11 +1036,27 @@ void Endpoint::SendImmediateConnectionClose(const PathDescriptor& options,
         "Sending immediate connection close on path %s with reason %s",
         options,
         reason);
-  // While it is possible for a malicious peer to cause us to create a large
-  // number of these, generating them is fairly trivial.
+  // A malicious peer can trigger immediate connection close packets by
+  // sending Initial packets with invalid tokens or when the server is
+  // busy. Rate-limit per remote host to prevent amplification attacks.
+  const auto exceeds_limits = [&] {
+    SocketAddressInfoTraits::Type* counts =
+        addr_validation_lru_.Peek(options.remote_address);
+    auto count = counts != nullptr ? counts->immediate_close_count : 0;
+    return count >= kMaxImmediateCloses;
+  };
+
+  if (exceeds_limits()) {
+    Debug(this, "Immediate connection close rate limit exceeded for %s",
+          options.remote_address);
+    return;
+  }
+
   auto packet =
       Packet::CreateImmediateConnectionClosePacket(*this, options, reason);
   if (packet) {
+    addr_validation_lru_.Upsert(options.remote_address)
+        ->immediate_close_count++;
     STAT_INCREMENT(Stats, immediate_close_count);
     Send(std::move(packet));
   }
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index 188246546b6906..a9f020e0328eff 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -47,6 +47,20 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
   // intentionally triggering generation of a large number of retries.
   static constexpr uint64_t DEFAULT_MAX_RETRY_LIMIT = 10;
 
+  // Maximum number of version negotiation packets that will be sent to a
+  // given remote host within the LRU tracking window. Version negotiation
+  // packets are cheap to generate but can be used as an amplification
+  // vector with spoofed source addresses.
+  // TODO(@jasnell): Consider making this configurable via Endpoint::Options.
+  static constexpr uint64_t kMaxVersionNegotiations = 10;
+
+  // Maximum number of immediate connection close packets that will be sent
+  // to a given remote host within the LRU tracking window. These are sent
+  // when the server is busy or a token is invalid — a malicious peer could
+  // trigger a large number of them.
+  // TODO(@jasnell): Consider making this configurable via Endpoint::Options.
+  static constexpr uint64_t kMaxImmediateCloses = 10;
+
   // Endpoint configuration options
   struct Options final : public MemoryRetainer {
     // The local socket address to which the UDP port will be bound. The port
@@ -454,6 +468,8 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
     struct Type final {
       size_t reset_count;
       size_t retry_count;
+      size_t version_negotiation_count;
+      size_t immediate_close_count;
       uint64_t timestamp;
       bool validated;
     };

From 4eae6f10af51d824160542d7574eb72367ac2c33 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 12 May 2026 12:40:58 -0700
Subject: [PATCH 55/83] quic: add handshake timeout and default connection
 limits

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/quic/quic.js                             |  4 ++--
 src/quic/endpoint.cc                                  |  6 ++++--
 src/quic/session.cc                                   | 11 ++++++++++-
 src/quic/session.h                                    | 11 +++++++++--
 test/parallel/test-quic-connection-limits.mjs         |  6 ++++--
 .../test-quic-internal-endpoint-stats-state.mjs       |  4 ++--
 6 files changed, 31 insertions(+), 11 deletions(-)

diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index a5ce3d8c14fb23..37ad89cd684ab0 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -3943,8 +3943,8 @@ class QuicEndpoint {
     const {
       retryTokenExpiration,
       tokenExpiration,
-      maxConnectionsPerHost = 0,
-      maxConnectionsTotal = 0,
+      maxConnectionsPerHost = 100,
+      maxConnectionsTotal = 10_000,
       maxStatelessResetsPerHost,
       disableStatelessReset,
       addressLRUSize,
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 70ebecfacd3183..8a61f51b088750 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -978,7 +978,8 @@ void Endpoint::SendVersionNegotiation(const PathDescriptor& options) {
   };
 
   if (exceeds_limits()) {
-    Debug(this, "Version negotiation rate limit exceeded for %s",
+    Debug(this,
+          "Version negotiation rate limit exceeded for %s",
           options.remote_address);
     return;
   }
@@ -1047,7 +1048,8 @@ void Endpoint::SendImmediateConnectionClose(const PathDescriptor& options,
   };
 
   if (exceeds_limits()) {
-    Debug(this, "Immediate connection close rate limit exceeded for %s",
+    Debug(this,
+          "Immediate connection close rate limit exceeded for %s",
           options.remote_address);
     return;
   }
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 4ec2b578519dd8..abcf733d443cdd 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -464,7 +464,12 @@ Session::Config::Config(Environment* env,
     settings.log_printf = ngtcp2_debug_log;
   }
 
-  settings.handshake_timeout = options.handshake_timeout;
+  // The handshake_timeout option is in milliseconds; ngtcp2 expects
+  // nanoseconds (ngtcp2_duration). UINT64_MAX means no timeout.
+  settings.handshake_timeout =
+      options.handshake_timeout == UINT64_MAX
+          ? UINT64_MAX
+          : options.handshake_timeout * NGTCP2_MILLISECONDS;
   settings.max_stream_window = options.max_stream_window;
   settings.max_window = options.max_window;
   settings.ack_thresh = options.unacknowledged_packet_threshold;
@@ -3640,6 +3645,10 @@ void Session::InitPerContext(Realm* realm, Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, QUIC_PROTO_MAX);
   NODE_DEFINE_CONSTANT(target, QUIC_PROTO_MIN);
 
+  static constexpr auto DEFAULT_HANDSHAKE_TIMEOUT =
+      Session::Options::DEFAULT_HANDSHAKE_TIMEOUT;
+  NODE_DEFINE_CONSTANT(target, DEFAULT_HANDSHAKE_TIMEOUT);
+
   NODE_DEFINE_STRING_CONSTANT(
       target, "DEFAULT_CIPHERS", TLSContext::DEFAULT_CIPHERS);
   NODE_DEFINE_STRING_CONSTANT(
diff --git a/src/quic/session.h b/src/quic/session.h
index 0ac183b3272258..472079984f313a 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -153,8 +153,15 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     bool qlog = false;
 
     // The amount of time (in milliseconds) that the endpoint will wait for the
-    // completion of the tls handshake.
-    uint64_t handshake_timeout = UINT64_MAX;
+    // completion of the TLS handshake. If the handshake does not complete
+    // within this time, the session is closed. This prevents a peer from
+    // holding a session open indefinitely in the handshake state, consuming
+    // server resources (ngtcp2 connection, TLS state, JS objects) without
+    // ever completing the connection. The default of 10 seconds is generous
+    // enough to accommodate slow networks with retransmissions while still
+    // bounding resource exposure. Set to UINT64_MAX to disable.
+    static constexpr uint64_t DEFAULT_HANDSHAKE_TIMEOUT = 10'000;
+    uint64_t handshake_timeout = DEFAULT_HANDSHAKE_TIMEOUT;
 
     // The keep-alive timeout in milliseconds. When set to a non-zero value,
     // ngtcp2 will automatically send PING frames to keep the connection alive
diff --git a/test/parallel/test-quic-connection-limits.mjs b/test/parallel/test-quic-connection-limits.mjs
index acb0f8065d4c78..2f41c388805dc4 100644
--- a/test/parallel/test-quic-connection-limits.mjs
+++ b/test/parallel/test-quic-connection-limits.mjs
@@ -27,9 +27,11 @@ const endpoint = new QuicEndpoint({ maxConnectionsTotal: 1 });
 
 // Verify the limits are readable and mutable.
 strictEqual(endpoint.maxConnectionsTotal, 1);
-strictEqual(endpoint.maxConnectionsPerHost, 0);
-endpoint.maxConnectionsPerHost = 100;
+// The default maxConnectionsPerHost is 100 — a non-zero default that
+// prevents a single host from exhausting server resources.
 strictEqual(endpoint.maxConnectionsPerHost, 100);
+endpoint.maxConnectionsPerHost = 50;
+strictEqual(endpoint.maxConnectionsPerHost, 50);
 endpoint.maxConnectionsPerHost = 0;
 
 let sessionCount = 0;
diff --git a/test/parallel/test-quic-internal-endpoint-stats-state.mjs b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
index 015155344fde42..57044a773eb2d6 100644
--- a/test/parallel/test-quic-internal-endpoint-stats-state.mjs
+++ b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
@@ -43,8 +43,8 @@ const {
     isListening: false,
     isClosing: false,
     isBusy: false,
-    maxConnectionsPerHost: 0,
-    maxConnectionsTotal: 0,
+    maxConnectionsPerHost: 100,
+    maxConnectionsTotal: 10_000,
     pendingCallbacks: '0',
   });
 

From fdbfb68d4b868be2f470a9d8730621b2d8e71922 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 13 May 2026 06:12:08 -0700
Subject: [PATCH 56/83] quic: add aliased struct arenas

Every stream, session, and endpoint creates aliased
structs for stats and state. These were creating
v8::ArrayBuffer allocations and views for each instance,
which is expensive. This adds a new arena mechanism
for AliasedStructs that allocates in pages and allows
Streams and Sessions to share the same underlying
ArrayBuffer for their stats and state. Since these
are never exposed to users, this is safe and results
in a significant reduction in allocation counts.

Each arena maintains a freelist of pages, where each
page is a max of 16KB bytes. Pages are lazily allocated
and freed as needed. Each slot in the arena corresponds
to a single struct instance, and the slot index is
used to calculate the byte offset within the page for
that struct's view.

The perf improvement is modest but measurable. The
key benefit is in reduced memory fragmentation and GC
overhead.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/quic/quic.js  |  12 +-
 lib/internal/quic/state.js | 120 +++++++++++---------
 lib/internal/quic/stats.js | 135 +++++++++++++----------
 src/aliased_struct-inl.h   |  89 +++++++++++++++
 src/aliased_struct.h       | 187 ++++++++++++++++++++++++++++++-
 src/quic/bindingdata.h     |  13 +++
 src/quic/session.cc        | 200 ++++++++++++++++++++++------------
 src/quic/streams.cc        | 218 ++++++++++++++++++++++++++-----------
 src/quic/streams.h         |  15 ++-
 9 files changed, 744 insertions(+), 245 deletions(-)

diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 37ad89cd684ab0..34e3cbf10a1821 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -1472,8 +1472,10 @@ class QuicStream {
     this.#handle[kOwner] = this;
     this.#session = session;
     this.#direction = direction;
-    this.#stats = new QuicStreamStats(kPrivateConstructor, this.#handle.stats);
-    this.#state = new QuicStreamState(kPrivateConstructor, this.#handle.state);
+    this.#stats = new QuicStreamStats(
+      kPrivateConstructor, this.#handle.stats, this.#handle.statsByteOffset);
+    this.#state = new QuicStreamState(
+      kPrivateConstructor, this.#handle.state, this.#handle.stateByteOffset);
     this.#reader = this.#handle.getReader();
 
     if (hasObserver('quic')) {
@@ -2656,8 +2658,10 @@ class QuicSession {
       this.#pendingQlog = handle._pendingQlog;
       handle._pendingQlog = undefined;
     }
-    this.#stats = new QuicSessionStats(kPrivateConstructor, handle.stats);
-    this.#state = new QuicSessionState(kPrivateConstructor, handle.state);
+    this.#stats = new QuicSessionStats(
+      kPrivateConstructor, handle.stats, handle.statsByteOffset);
+    this.#state = new QuicSessionState(
+      kPrivateConstructor, handle.state, handle.stateByteOffset);
 
     if (hasObserver('quic')) {
       startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicSession' });
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index efaccb4aa00527..d32bbcce5c544a 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -294,19 +294,24 @@ class QuicEndpointState {
 class QuicSessionState {
   /** @type {DataView} */
   #handle;
+  /** @type {number} */
+  #offset = 0;
 
   /**
    * @param {symbol} privateSymbol
-   * @param {ArrayBuffer} buffer
+   * @param {DataView|ArrayBuffer} view
+   * @param {number} [byteOffset]
    */
-  constructor(privateSymbol, buffer) {
+  constructor(privateSymbol, view, byteOffset = 0) {
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
-    if (!isArrayBuffer(buffer)) {
-      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    if (isArrayBuffer(view)) {
+      this.#handle = new DataView(view);
+    } else {
+      this.#handle = view;
     }
-    this.#handle = new DataView(buffer);
+    this.#offset = byteOffset;
   }
 
   // Listener flags are packed into a single uint32_t bitfield. The bit
@@ -321,15 +326,15 @@ class QuicSessionState {
   #getListenerFlag(flag) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return !!(DataViewPrototypeGetUint32(
-      this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian) & flag);
+      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian) & flag);
   }
 
   #setListenerFlag(flag, val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
     const current = DataViewPrototypeGetUint32(
-      this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian);
     DataViewPrototypeSetUint32(
-      this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS,
+      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS,
       val ? (current | flag) : (current & ~flag), kIsLittleEndian);
   }
 
@@ -384,49 +389,49 @@ class QuicSessionState {
   /** @type {boolean} */
   get isClosing() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_CLOSING);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_CLOSING);
   }
 
   /** @type {boolean} */
   get isGracefulClose() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_GRACEFUL_CLOSE);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_GRACEFUL_CLOSE);
   }
 
   /** @type {boolean} */
   get isSilentClose() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_SILENT_CLOSE);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_SILENT_CLOSE);
   }
 
   /** @type {boolean} */
   get isStatelessReset() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_STATELESS_RESET);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_STATELESS_RESET);
   }
 
   /** @type {boolean} */
   get isHandshakeCompleted() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HANDSHAKE_COMPLETED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_COMPLETED);
   }
 
   /** @type {boolean} */
   get isHandshakeConfirmed() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HANDSHAKE_CONFIRMED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_CONFIRMED);
   }
 
   /** @type {boolean} */
   get isStreamOpenAllowed() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_STREAM_OPEN_ALLOWED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_STREAM_OPEN_ALLOWED);
   }
 
   /** @type {boolean} */
   get isPrioritySupported() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_PRIORITY_SUPPORTED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_PRIORITY_SUPPORTED);
   }
 
   /**
@@ -436,19 +441,19 @@ class QuicSessionState {
    */
   get headersSupported() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HEADERS_SUPPORTED);
+    return DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HEADERS_SUPPORTED);
   }
 
   /** @type {boolean} */
   get isWrapped() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_WRAPPED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_WRAPPED);
   }
 
   /** @type {number} */
   get applicationType() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_APPLICATION_TYPE);
+    return DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
   }
 
   /**
@@ -461,7 +466,7 @@ class QuicSessionState {
   get noErrorCode() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
   }
 
   /**
@@ -476,32 +481,36 @@ class QuicSessionState {
   get internalErrorCode() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
   }
 
   /** @type {number} */
   get maxDatagramSize() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetUint16(this.#handle, IDX_STATE_SESSION_MAX_DATAGRAM_SIZE, kIsLittleEndian);
+    return DataViewPrototypeGetUint16(
+      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_DATAGRAM_SIZE,
+      kIsLittleEndian);
   }
 
   /** @type {bigint} */
   get lastDatagramId() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_SESSION_LAST_DATAGRAM_ID, kIsLittleEndian);
+    return DataViewPrototypeGetBigUint64(
+      this.#handle, this.#offset + IDX_STATE_SESSION_LAST_DATAGRAM_ID,
+      kIsLittleEndian);
   }
 
   /** @type {number} */
   get maxPendingDatagrams() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetUint16(
-      this.#handle, IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, kIsLittleEndian);
   }
 
   set maxPendingDatagrams(val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
     DataViewPrototypeSetUint16(
-      this.#handle, IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, val, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, val, kIsLittleEndian);
   }
 
   toString() {
@@ -587,161 +596,166 @@ class QuicSessionState {
 class QuicStreamState {
   /** @type {DataView} */
   #handle;
+  /** @type {number} */
+  #offset = 0;
 
   /**
    * @param {symbol} privateSymbol
-   * @param {ArrayBuffer} buffer
+   * @param {DataView|ArrayBuffer} view
+   * @param {number} [byteOffset]
    */
-  constructor(privateSymbol, buffer) {
+  constructor(privateSymbol, view, byteOffset = 0) {
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
-    if (!isArrayBuffer(buffer)) {
-      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    if (isArrayBuffer(view)) {
+      this.#handle = new DataView(view);
+    } else {
+      this.#handle = view;
     }
-    this.#handle = new DataView(buffer);
+    this.#offset = byteOffset;
   }
 
   /** @type {bigint} */
   get id() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetBigInt64(this.#handle, IDX_STATE_STREAM_ID, kIsLittleEndian);
+    return DataViewPrototypeGetBigInt64(this.#handle, this.#offset + IDX_STATE_STREAM_ID, kIsLittleEndian);
   }
 
   /** @type {boolean} */
   get pending() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_PENDING);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_PENDING);
   }
 
   /** @type {boolean} */
   get finSent() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_FIN_SENT);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_FIN_SENT);
   }
 
   /** @type {boolean} */
   get finReceived() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_FIN_RECEIVED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_FIN_RECEIVED);
   }
 
   /** @type {boolean} */
   get readEnded() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_READ_ENDED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_READ_ENDED);
   }
 
   /** @type {boolean} */
   get writeEnded() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WRITE_ENDED);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_ENDED);
   }
 
 
   /** @type {boolean} */
   get reset() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_RESET);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_RESET);
   }
 
   /** @type {boolean} */
   get hasOutbound() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_HAS_OUTBOUND);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_HAS_OUTBOUND);
   }
 
   /** @type {boolean} */
   get hasReader() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_HAS_READER);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_HAS_READER);
   }
 
   /** @type {boolean} */
   get wantsBlock() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_BLOCK);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK);
   }
 
   /** @type {boolean} */
   set wantsBlock(val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0);
+    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get [kWantsHeaders]() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_HEADERS);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS);
   }
 
   /** @type {boolean} */
   set [kWantsHeaders](val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_HEADERS, val ? 1 : 0);
+    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get wantsReset() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_RESET);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET);
   }
 
   /** @type {boolean} */
   set wantsReset(val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_RESET, val ? 1 : 0);
+    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get [kWantsTrailers]() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_TRAILERS);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS);
   }
 
   /** @type {boolean} */
   set [kWantsTrailers](val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_TRAILERS, val ? 1 : 0);
+    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get early() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_RECEIVED_EARLY_DATA);
+    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_RECEIVED_EARLY_DATA);
   }
 
   /** @type {bigint} */
   get resetCode() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, IDX_STATE_STREAM_RESET_CODE, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_STREAM_RESET_CODE, kIsLittleEndian);
   }
 
   /** @type {bigint} */
   get writeDesiredSize() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetUint32(
-      this.#handle, IDX_STATE_STREAM_WRITE_DESIRED_SIZE, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, kIsLittleEndian);
   }
 
   set writeDesiredSize(val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
     DataViewPrototypeSetUint32(
-      this.#handle, IDX_STATE_STREAM_WRITE_DESIRED_SIZE, val, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, val, kIsLittleEndian);
   }
 
   /** @type {number} */
   get highWaterMark() {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
     return DataViewPrototypeGetUint32(
-      this.#handle, IDX_STATE_STREAM_HIGH_WATER_MARK, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, kIsLittleEndian);
   }
 
   set highWaterMark(val) {
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
     DataViewPrototypeSetUint32(
-      this.#handle, IDX_STATE_STREAM_HIGH_WATER_MARK, val, kIsLittleEndian);
+      this.#handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, val, kIsLittleEndian);
   }
 
   toString() {
diff --git a/lib/internal/quic/stats.js b/lib/internal/quic/stats.js
index 280cf5a26f419b..27a986f4d0549e 100644
--- a/lib/internal/quic/stats.js
+++ b/lib/internal/quic/stats.js
@@ -332,163 +332,168 @@ class QuicSessionStats {
    * @param {symbol} privateSymbol
    * @param {ArrayBuffer} buffer
    */
-  constructor(privateSymbol, buffer) {
+  /** @type {number} */
+  #offset = 0;
+
+  constructor(privateSymbol, view, byteOffset = 0) {
     // We use the kPrivateConstructor symbol to restrict the ability to
     // create new instances of QuicSessionStats to internal code.
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
-    if (!isArrayBuffer(buffer)) {
-      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    if (isArrayBuffer(view)) {
+      this.#handle = new BigUint64Array(view);
+    } else {
+      this.#handle = view;
     }
-    this.#handle = new BigUint64Array(buffer);
+    this.#offset = byteOffset / 8;
   }
 
   /** @type {bigint} */
   get createdAt() {
-    return this.#handle[IDX_STATS_SESSION_CREATED_AT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_CREATED_AT];
   }
 
   /** @type {bigint} */
   get destroyedAt() {
-    return this.#handle[IDX_STATS_SESSION_DESTROYED_AT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_DESTROYED_AT];
   }
 
   /** @type {bigint} */
   get closingAt() {
-    return this.#handle[IDX_STATS_SESSION_CLOSING_AT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_CLOSING_AT];
   }
 
   /** @type {bigint} */
   get handshakeCompletedAt() {
-    return this.#handle[IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
   }
 
   /** @type {bigint} */
   get handshakeConfirmedAt() {
-    return this.#handle[IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT];
   }
 
   /** @type {bigint} */
   get bytesReceived() {
-    return this.#handle[IDX_STATS_SESSION_BYTES_RECEIVED];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_RECEIVED];
   }
 
   /** @type {bigint} */
   get bidiInStreamCount() {
-    return this.#handle[IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get bidiOutStreamCount() {
-    return this.#handle[IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get uniInStreamCount() {
-    return this.#handle[IDX_STATS_SESSION_UNI_IN_STREAM_COUNT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_UNI_IN_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get uniOutStreamCount() {
-    return this.#handle[IDX_STATS_SESSION_UNI_OUT_STREAM_COUNT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_UNI_OUT_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get maxBytesInFlight() {
-    return this.#handle[IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT];
   }
 
   /** @type {bigint} */
   get bytesInFlight() {
-    return this.#handle[IDX_STATS_SESSION_BYTES_IN_FLIGHT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_IN_FLIGHT];
   }
 
   /** @type {bigint} */
   get blockCount() {
-    return this.#handle[IDX_STATS_SESSION_BLOCK_COUNT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BLOCK_COUNT];
   }
 
   /** @type {bigint} */
   get cwnd() {
-    return this.#handle[IDX_STATS_SESSION_CWND];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_CWND];
   }
 
   /** @type {bigint} */
   get latestRtt() {
-    return this.#handle[IDX_STATS_SESSION_LATEST_RTT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_LATEST_RTT];
   }
 
   /** @type {bigint} */
   get minRtt() {
-    return this.#handle[IDX_STATS_SESSION_MIN_RTT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_MIN_RTT];
   }
 
   /** @type {bigint} */
   get rttVar() {
-    return this.#handle[IDX_STATS_SESSION_RTTVAR];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_RTTVAR];
   }
 
   /** @type {bigint} */
   get smoothedRtt() {
-    return this.#handle[IDX_STATS_SESSION_SMOOTHED_RTT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_SMOOTHED_RTT];
   }
 
   /** @type {bigint} */
   get ssthresh() {
-    return this.#handle[IDX_STATS_SESSION_SSTHRESH];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_SSTHRESH];
   }
 
   get pktSent() {
-    return this.#handle[IDX_STATS_SESSION_PKT_SENT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_SENT];
   }
 
   get bytesSent() {
-    return this.#handle[IDX_STATS_SESSION_BYTES_SENT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_SENT];
   }
 
   get pktRecv() {
-    return this.#handle[IDX_STATS_SESSION_PKT_RECV];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_RECV];
   }
 
   get bytesRecv() {
-    return this.#handle[IDX_STATS_SESSION_BYTES_RECV];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_RECV];
   }
 
   get pktLost() {
-    return this.#handle[IDX_STATS_SESSION_PKT_LOST];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_LOST];
   }
 
   get bytesLost() {
-    return this.#handle[IDX_STATS_SESSION_BYTES_LOST];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_LOST];
   }
 
   get pingRecv() {
-    return this.#handle[IDX_STATS_SESSION_PING_RECV];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_PING_RECV];
   }
 
   get pktDiscarded() {
-    return this.#handle[IDX_STATS_SESSION_PKT_DISCARDED];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_DISCARDED];
   }
 
   /** @type {bigint} */
   get datagramsReceived() {
-    return this.#handle[IDX_STATS_SESSION_DATAGRAMS_RECEIVED];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_RECEIVED];
   }
 
   /** @type {bigint} */
   get datagramsSent() {
-    return this.#handle[IDX_STATS_SESSION_DATAGRAMS_SENT];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_SENT];
   }
 
   /** @type {bigint} */
   get datagramsAcknowledged() {
-    return this.#handle[IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED];
   }
 
   /** @type {bigint} */
   get datagramsLost() {
-    return this.#handle[IDX_STATS_SESSION_DATAGRAMS_LOST];
+    return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_LOST];
   }
 
   toString() {
@@ -590,9 +595,14 @@ class QuicSessionStats {
   }
 
   [kFinishClose]() {
-    // Snapshot the stats into a new BigUint64Array since the underlying
-    // buffer will be destroyed.
-    this.#handle = new BigUint64Array(this.#handle);
+    // Snapshot this session's stats slice into a standalone BigUint64Array.
+    const count = IDX_STATS_SESSION_DATAGRAMS_LOST + 1;
+    const snapshot = new BigUint64Array(count);
+    for (let i = 0; i < count; i++) {
+      snapshot[i] = this.#handle[this.#offset + i];
+    }
+    this.#handle = snapshot;
+    this.#offset = 0;
     this.#disconnected = true;
   }
 }
@@ -600,78 +610,84 @@ class QuicSessionStats {
 class QuicStreamStats {
   /** @type {BigUint64Array} */
   #handle;
+  /** @type {number} */
+  #offset = 0;
   /** type {boolean} */
   #disconnected = false;
 
   /**
    * @param {symbol} privateSymbol
-   * @param {ArrayBuffer} buffer
+   * @param {BigUint64Array|ArrayBuffer} view
+   * @param {number} [byteOffset] - byte offset into the shared page view
    */
-  constructor(privateSymbol, buffer) {
+  constructor(privateSymbol, view, byteOffset = 0) {
     // We use the kPrivateConstructor symbol to restrict the ability to
     // create new instances of QuicStreamStats to internal code.
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
-    if (!isArrayBuffer(buffer)) {
-      throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
+    if (isArrayBuffer(view)) {
+      this.#handle = new BigUint64Array(view);
+    } else {
+      this.#handle = view;
     }
-    this.#handle = new BigUint64Array(buffer);
+    // Convert byte offset to element offset (8 bytes per uint64).
+    this.#offset = byteOffset / 8;
   }
 
   /** @type {bigint} */
   get createdAt() {
-    return this.#handle[IDX_STATS_STREAM_CREATED_AT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_CREATED_AT];
   }
 
   /** @type {bigint} */
   get openedAt() {
-    return this.#handle[IDX_STATS_STREAM_OPENED_AT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_OPENED_AT];
   }
 
   /** @type {bigint} */
   get receivedAt() {
-    return this.#handle[IDX_STATS_STREAM_RECEIVED_AT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_RECEIVED_AT];
   }
 
   /** @type {bigint} */
   get ackedAt() {
-    return this.#handle[IDX_STATS_STREAM_ACKED_AT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_ACKED_AT];
   }
 
   /** @type {bigint} */
   get destroyedAt() {
-    return this.#handle[IDX_STATS_STREAM_DESTROYED_AT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_DESTROYED_AT];
   }
 
   /** @type {bigint} */
   get bytesReceived() {
-    return this.#handle[IDX_STATS_STREAM_BYTES_RECEIVED];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_BYTES_RECEIVED];
   }
 
   /** @type {bigint} */
   get bytesSent() {
-    return this.#handle[IDX_STATS_STREAM_BYTES_SENT];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_BYTES_SENT];
   }
 
   /** @type {bigint} */
   get maxOffset() {
-    return this.#handle[IDX_STATS_STREAM_MAX_OFFSET];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET];
   }
 
   /** @type {bigint} */
   get maxOffsetAcknowledged() {
-    return this.#handle[IDX_STATS_STREAM_MAX_OFFSET_ACK];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET_ACK];
   }
 
   /** @type {bigint} */
   get maxOffsetReceived() {
-    return this.#handle[IDX_STATS_STREAM_MAX_OFFSET_RECV];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET_RECV];
   }
 
   /** @type {bigint} */
   get finalSize() {
-    return this.#handle[IDX_STATS_STREAM_FINAL_SIZE];
+    return this.#handle[this.#offset + IDX_STATS_STREAM_FINAL_SIZE];
   }
 
   toString() {
@@ -735,9 +751,14 @@ class QuicStreamStats {
   }
 
   [kFinishClose]() {
-    // Snapshot the stats into a new BigUint64Array since the underlying
-    // buffer will be destroyed.
-    this.#handle = new BigUint64Array(this.#handle);
+    // Snapshot this stream's stats slice into a standalone BigUint64Array.
+    const count = IDX_STATS_STREAM_FINAL_SIZE + 1;
+    const snapshot = new BigUint64Array(count);
+    for (let i = 0; i < count; i++) {
+      snapshot[i] = this.#handle[this.#offset + i];
+    }
+    this.#handle = snapshot;
+    this.#offset = 0;
     this.#disconnected = true;
   }
 }
diff --git a/src/aliased_struct-inl.h b/src/aliased_struct-inl.h
index 17d5ff58097e22..ff70f423eb1bd1 100644
--- a/src/aliased_struct-inl.h
+++ b/src/aliased_struct-inl.h
@@ -47,6 +47,95 @@ AliasedStruct<T>::~AliasedStruct() {
   if (ptr_ != nullptr) ptr_->~T();
 }
 
+// ---------------------------------------------------------------------------
+// AliasedStructArena implementation
+// ---------------------------------------------------------------------------
+
+template <typename T, size_t kPageBytes>
+typename AliasedStructArena<T, kPageBytes>::Page*
+AliasedStructArena<T, kPageBytes>::FindOrCreatePage(v8::Isolate* isolate) {
+  for (auto& p : pages_) {
+    if (p->HasFreeSlots()) return p.get();
+  }
+  auto p = std::make_unique<Page>();
+  p->Init(isolate);
+  Page* raw = p.get();
+  pages_.push_back(std::move(p));
+  return raw;
+}
+
+template <typename T, size_t kPageBytes>
+template <typename... Args>
+typename AliasedStructArena<T, kPageBytes>::Slot
+AliasedStructArena<T, kPageBytes>::Allocate(v8::Isolate* isolate,
+                                            Args&&... args) {
+  Page* page = FindOrCreatePage(isolate);
+  DCHECK(page->HasFreeSlots());
+
+  uint32_t idx = page->free_head;
+  T* raw = &page->base[idx];
+
+  // Advance freelist before placement new overwrites the linkage.
+  page->free_head = *reinterpret_cast<uint32_t*>(raw);
+  page->used_count++;
+
+  // Placement-construct T in the slot.
+  T* ptr = new (raw) T(std::forward<Args>(args)...);
+
+  Slot slot;
+  slot.page = static_cast<void*>(page);
+  slot.ptr = static_cast<void*>(ptr);
+  slot.index = idx;
+  slot.byte_offset = reinterpret_cast<const uint8_t*>(ptr) -
+                     static_cast<const uint8_t*>(page->store->Data());
+  return slot;
+}
+
+template <typename T, size_t kPageBytes>
+void AliasedStructArena<T, kPageBytes>::Release(
+    typename AliasedStructArena<T, kPageBytes>::Slot&& slot) {
+  if (!slot) return;
+  auto* page = static_cast<Page*>(slot.page);
+  auto* ptr = static_cast<T*>(slot.ptr);
+  uint32_t idx = slot.index;
+
+  // Destruct and zero so JS views see clean data.
+  ptr->~T();
+  memset(ptr, 0, sizeof(T));
+
+  // Push onto page freelist.
+  *reinterpret_cast<uint32_t*>(ptr) = page->free_head;
+  page->free_head = idx;
+  page->used_count--;
+
+  slot.page = nullptr;
+  slot.ptr = nullptr;
+
+  // Drop empty pages. The shared_ptr<BackingStore> ensures the
+  // underlying memory stays alive until V8 GCs any remaining JS
+  // references to the page's ArrayBuffer/views.
+  if (page->used_count == 0) {
+    for (auto it = pages_.begin(); it != pages_.end(); ++it) {
+      if (it->get() == page) {
+        pages_.erase(it);
+        break;
+      }
+    }
+  }
+}
+
+template <typename T, size_t kPageBytes>
+void AliasedStructArena<T, kPageBytes>::ReleaseSlot(ArenaSlotBase& base) {
+  Slot slot;
+  slot.page = base.page;
+  slot.ptr = base.ptr;
+  slot.index = base.index;
+  slot.byte_offset = base.byte_offset;
+  Release(std::move(slot));
+  base.page = nullptr;
+  base.ptr = nullptr;
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/aliased_struct.h b/src/aliased_struct.h
index e4df393f4985a3..97753192723feb 100644
--- a/src/aliased_struct.h
+++ b/src/aliased_struct.h
@@ -3,9 +3,10 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <memory>
+#include <vector>
 #include "node_internals.h"
 #include "v8.h"
-#include <memory>
 
 namespace node {
 
@@ -56,6 +57,190 @@ class AliasedStruct final {
   v8::Global<v8::ArrayBuffer> buffer_;
 };
 
+// ---------------------------------------------------------------------------
+// ArenaSlot — type-erased handle to a slot in an AliasedStructArena page.
+// This can be stored in headers where T is incomplete. The typed accessors
+// are provided via a thin typed wrapper (AliasedStructArena<T>::Slot).
+struct ArenaSlotBase {
+  // Opaque page pointer — only the arena knows the concrete type.
+  void* page = nullptr;
+  void* ptr = nullptr;
+  uint32_t index = 0;
+  size_t byte_offset = 0;
+
+  explicit operator bool() const { return ptr != nullptr; }
+
+  // Returns the page's ArrayBuffer. Implemented below after ArenaPageHeader.
+  v8::Local<v8::ArrayBuffer> GetArrayBuffer(v8::Isolate* isolate) const;
+
+  size_t GetByteOffset() const { return byte_offset; }
+
+  // Returns the page's cached DataView over the full page.
+  // Callers use byte_offset to index into the correct slot region.
+  v8::Local<v8::DataView> GetPageDataView(v8::Isolate* isolate) const;
+
+  // Returns the page's cached BigUint64Array over the full page.
+  // Callers use byte_offset / sizeof(uint64_t) to index into the
+  // correct slot region.
+  v8::Local<v8::BigUint64Array> GetPageBigUint64Array(
+      v8::Isolate* isolate) const;
+};
+
+// ---------------------------------------------------------------------------
+// AliasedStructArena<T> — pool allocator for AliasedStruct-style shared
+// memory.  Instead of creating a separate ArrayBuffer + BackingStore per
+// instance, the arena pre-allocates pages of N slots backed by a single
+// ArrayBuffer each.  Callers receive a Slot handle that provides the same
+// T*/operator-> interface as AliasedStruct, plus the ability to create a
+// JS typed-array view over just that slot's region of the page buffer.
+//
+// Pages target kPageBytes (default 16 KB) for L1 cache residency during
+// sequential access patterns.  Slots are recycled via an intrusive
+// freelist, and empty pages are dropped when their last slot is released.
+//
+// Usage:
+//   AliasedStructArena<MyState> arena;
+//   auto slot = arena.Allocate(isolate);
+//   slot->some_field = 42;
+//   auto view = slot.GetArrayBuffer(isolate);  // JS-visible view
+//   ...
+//   arena.Release(std::move(slot));             // return to freelist
+//
+template <typename T, size_t kPageBytes = 16384>
+class AliasedStructArena final {
+ public:
+  static constexpr size_t kSlotsPerPage = kPageBytes / sizeof(T);
+  static_assert(kSlotsPerPage >= 4, "Page too small for type T");
+  static_assert(sizeof(T) >= sizeof(uint32_t),
+                "T must be at least 4 bytes for freelist linkage");
+
+  AliasedStructArena() = default;
+  ~AliasedStructArena() = default;
+
+  AliasedStructArena(const AliasedStructArena&) = delete;
+  AliasedStructArena& operator=(const AliasedStructArena&) = delete;
+
+  struct Page {
+    std::shared_ptr<v8::BackingStore> store;
+    v8::Global<v8::ArrayBuffer> buffer;
+    // Lazily created full-page views shared by all slots in
+    // this page. Typically only one is used per arena.
+    v8::Global<v8::DataView> data_view;
+    v8::Global<v8::BigUint64Array> big_uint64_array;
+    size_t page_byte_length = 0;
+    T* base = nullptr;
+    uint32_t free_head = 0;
+    uint32_t used_count = 0;
+    static constexpr uint32_t kNoFreeSlot = UINT32_MAX;
+
+    void Init(v8::Isolate* isolate) {
+      const v8::HandleScope handle_scope(isolate);
+      const size_t total_bytes = kSlotsPerPage * sizeof(T);
+      store = v8::ArrayBuffer::NewBackingStore(isolate, total_bytes);
+      memset(store->Data(), 0, total_bytes);
+      base = static_cast<T*>(store->Data());
+      page_byte_length = total_bytes;
+      v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, store);
+      buffer = v8::Global<v8::ArrayBuffer>(isolate, ab);
+
+      // Build freelist: each slot points to the next.
+      for (uint32_t i = 0; i < kSlotsPerPage - 1; i++) {
+        *reinterpret_cast<uint32_t*>(&base[i]) = i + 1;
+      }
+      *reinterpret_cast<uint32_t*>(&base[kSlotsPerPage - 1]) = kNoFreeSlot;
+      free_head = 0;
+      used_count = 0;
+    }
+
+    bool HasFreeSlots() const { return free_head != kNoFreeSlot; }
+  };
+
+  // Typed slot handle — wraps ArenaSlotBase with T* accessors.
+  class Slot : public ArenaSlotBase {
+   public:
+    Slot() = default;
+
+    const T& operator*() const { return *static_cast<T*>(ptr); }
+    T& operator*() { return *static_cast<T*>(ptr); }
+    const T* operator->() const { return static_cast<T*>(ptr); }
+    T* operator->() { return static_cast<T*>(ptr); }
+    T* Data() { return static_cast<T*>(ptr); }
+    const T* Data() const { return static_cast<T*>(ptr); }
+  };
+
+  // Allocate a slot, placement-constructing T with the given args.
+  // Creates a new page if all existing pages are full.
+  template <typename... Args>
+  Slot Allocate(v8::Isolate* isolate, Args&&... args);
+
+  // Release a slot back to the arena freelist.  Calls ~T() and zeros
+  // the memory so that any JS views see clean data.
+  void Release(Slot&& slot);
+
+  // Release a slot given a type-erased ArenaSlotBase reference.
+  // Convenience for callers that store ArenaSlotBase in headers where
+  // T is incomplete.
+  void ReleaseSlot(ArenaSlotBase& base);
+
+ private:
+  Page* FindOrCreatePage(v8::Isolate* isolate);
+
+  std::vector<std::unique_ptr<Page>> pages_;
+};
+
+// ArenaSlotBase accessors need to reach the v8::Globals inside a Page.
+// All AliasedStructArena<T>::Page types share the same leading layout.
+// The page_byte_length field allows lazy view creation without knowing T.
+namespace detail {
+struct ArenaPageHeader {
+  std::shared_ptr<v8::BackingStore> store;
+  v8::Global<v8::ArrayBuffer> buffer;
+  v8::Global<v8::DataView> data_view;
+  v8::Global<v8::BigUint64Array> big_uint64_array;
+  size_t page_byte_length = 0;
+
+  v8::Local<v8::DataView> GetDataView(v8::Isolate* isolate) {
+    if (data_view.IsEmpty()) {
+      const v8::HandleScope handle_scope(isolate);
+      auto dv = v8::DataView::New(buffer.Get(isolate), 0, page_byte_length);
+      data_view = v8::Global<v8::DataView>(isolate, dv);
+    }
+    return data_view.Get(isolate);
+  }
+
+  v8::Local<v8::BigUint64Array> GetBigUint64Array(v8::Isolate* isolate) {
+    if (big_uint64_array.IsEmpty()) {
+      const v8::HandleScope handle_scope(isolate);
+      auto bu = v8::BigUint64Array::New(
+          buffer.Get(isolate), 0, page_byte_length / sizeof(uint64_t));
+      big_uint64_array = v8::Global<v8::BigUint64Array>(isolate, bu);
+    }
+    return big_uint64_array.Get(isolate);
+  }
+};
+}  // namespace detail
+
+inline v8::Local<v8::ArrayBuffer> ArenaSlotBase::GetArrayBuffer(
+    v8::Isolate* isolate) const {
+  DCHECK_NOT_NULL(page);
+  auto* header = static_cast<detail::ArenaPageHeader*>(page);
+  return header->buffer.Get(isolate);
+}
+
+inline v8::Local<v8::DataView> ArenaSlotBase::GetPageDataView(
+    v8::Isolate* isolate) const {
+  DCHECK_NOT_NULL(page);
+  auto* header = static_cast<detail::ArenaPageHeader*>(page);
+  return header->GetDataView(isolate);
+}
+
+inline v8::Local<v8::BigUint64Array> ArenaSlotBase::GetPageBigUint64Array(
+    v8::Isolate* isolate) const {
+  DCHECK_NOT_NULL(page);
+  auto* header = static_cast<detail::ArenaPageHeader*>(page);
+  return header->GetBigUint64Array(isolate);
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index b3965529a6c1de..a83c2a55c19d38 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -257,6 +257,19 @@ class BindingData final
 
   std::unique_ptr<SessionManager> session_manager_;
 
+  // Type-erased arena storage. The concrete AliasedStructArena<T> types
+  // are only complete in the .cc files where Stream::State etc. are defined.
+  // Each .cc file provides typed accessor methods. The deleters are set
+  // when the arenas are created so that ~BindingData destroys them correctly.
+  using ArenaDeleter = void (*)(void*);
+  using ArenaPtr = std::unique_ptr<void, ArenaDeleter>;
+  ArenaPtr stream_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr stream_stats_arena_{nullptr, +[](void*) {}};
+  ArenaPtr session_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr session_stats_arena_{nullptr, +[](void*) {}};
+  ArenaPtr endpoint_state_arena_{nullptr, +[](void*) {}};
+  ArenaPtr endpoint_stats_arena_{nullptr, +[](void*) {}};
+
   // Deferred send flush state. The uv_check_t fires immediately after
   // the I/O poll phase in the same event loop tick, allowing batched
   // receive processing: all packets are read during poll, then
diff --git a/src/quic/session.cc b/src/quic/session.cc
index abcf733d443cdd..1cc4b8b23b510b 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -197,6 +197,46 @@ struct Session::State final {
 
 STAT_STRUCT(Session, SESSION)
 
+using SessionStateArena = AliasedStructArena<Session::State>;
+using SessionStatsArena = AliasedStructArena<Session::Stats>;
+
+// Session uses arena-allocated stats, not AliasedStruct, so override the
+// STAT_* macros to use impl_->stats() instead of stats_.Data().
+#undef STAT_INCREMENT
+#undef STAT_INCREMENT_N
+#undef STAT_RECORD_TIMESTAMP
+#undef STAT_SET
+#undef STAT_GET
+#define STAT_INCREMENT(Type, name)                                             \
+  IncrementStat<Type, &Type::name>(impl_->stats());
+#define STAT_INCREMENT_N(Type, name, amt)                                      \
+  IncrementStat<Type, &Type::name>(impl_->stats(), amt);
+#define STAT_RECORD_TIMESTAMP(Type, name)                                      \
+  RecordTimestampStat<Type, &Type::name>(impl_->stats());
+#define STAT_SET(Type, name, val)                                              \
+  SetStat<Type, &Type::name>(impl_->stats(), val)
+#define STAT_GET(Type, name) GetStat<Type, &Type::name>(impl_->stats())
+
+namespace {
+SessionStateArena& GetSessionStateArena(BindingData& binding) {
+  if (!binding.session_state_arena_) {
+    auto* arena = new SessionStateArena();
+    binding.session_state_arena_ = BindingData::ArenaPtr(
+        arena, +[](void* p) { delete static_cast<SessionStateArena*>(p); });
+  }
+  return *static_cast<SessionStateArena*>(binding.session_state_arena_.get());
+}
+
+SessionStatsArena& GetSessionStatsArena(BindingData& binding) {
+  if (!binding.session_stats_arena_) {
+    auto* arena = new SessionStatsArena();
+    binding.session_stats_arena_ = BindingData::ArenaPtr(
+        arena, +[](void* p) { delete static_cast<SessionStatsArena*>(p); });
+  }
+  return *static_cast<SessionStatsArena*>(binding.session_stats_arena_.get());
+}
+}  // namespace
+
 // ============================================================================
 
 class Http3Application;
@@ -712,8 +752,8 @@ std::string Session::Options::ToString() const {
 // Session::Impl maintains most of the internal state of an active Session.
 struct Session::Impl final : public MemoryRetainer {
   Session* session_;
-  AliasedStruct<Stats> stats_;
-  AliasedStruct<State> state_;
+  ArenaSlotBase stats_slot_;
+  ArenaSlotBase state_slot_;
   BaseObjectWeakPtr<Endpoint> endpoint_;
   Config config_;
   SocketAddress local_address_;
@@ -741,20 +781,30 @@ struct Session::Impl final : public MemoryRetainer {
   // and the stream/datagram data is included in the 0-RTT flight.
   bool handshake_deferred_ = false;
 
+  Stats* stats() { return static_cast<Stats*>(stats_slot_.ptr); }
+  const Stats* stats() const {
+    return static_cast<const Stats*>(stats_slot_.ptr);
+  }
+  State* state() { return static_cast<State*>(state_slot_.ptr); }
+  const State* state() const {
+    return static_cast<const State*>(state_slot_.ptr);
+  }
+
   Impl(Session* session, Endpoint* endpoint, const Config& config)
       : session_(session),
-        stats_(env()->isolate()),
-        state_(env()->isolate()),
         endpoint_(endpoint),
         config_(config),
         local_address_(config.local_address),
         remote_address_(config.remote_address),
         timer_(session_->env(), [this] { session_->OnTimeout(); }) {
+    auto& binding = BindingData::Get(env());
+    stats_slot_ = GetSessionStatsArena(binding).Allocate(env()->isolate());
+    state_slot_ = GetSessionStateArena(binding).Allocate(env()->isolate());
     timer_.Unref();
   }
   DISALLOW_COPY_AND_MOVE(Impl)
 
-  inline bool is_closing() const { return state_->closing; }
+  inline bool is_closing() const { return state()->closing; }
 
   ~Impl() {
     // Ensure that Close() was called before dropping
@@ -790,6 +840,10 @@ struct Session::Impl final : public MemoryRetainer {
     }
 
     endpoint->RemoveSession(config_.scid, remote_address_);
+
+    auto& binding = BindingData::Get(env());
+    if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
+    if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
   }
 
   void MemoryInfo(MemoryTracker* tracker) const override {
@@ -1309,7 +1363,7 @@ struct Session::Impl final : public MemoryRetainer {
     // NGTCP2_ERR_DRAINING. The actual close handling happens in
     // Session::Receive when it processes that return value and
     // checks this flag.
-    session->impl_->state_->stateless_reset = 1;
+    session->impl_->state()->stateless_reset = 1;
     return NGTCP2_SUCCESS;
   }
 
@@ -1634,10 +1688,7 @@ Session::Session(Endpoint* endpoint,
       connection_(InitConnection()),
       tls_session_(tls_context->NewSession(this, session_ticket)) {
   DCHECK(impl_);
-  {
-    auto& stats_ = impl_->stats_;
-    STAT_RECORD_TIMESTAMP(Stats, created_at);
-  }
+  STAT_RECORD_TIMESTAMP(Stats, created_at);
 
   // For clients, select the Application immediately — the ALPN is
   // known upfront from the options. For servers, application_ stays
@@ -1666,10 +1717,33 @@ Session::Session(Endpoint* endpoint,
   MakeWeak();
   Debug(this, "Session created.");
 
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->stats_string(), impl_->stats_.GetArrayBuffer());
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->state_string(), impl_->state_.GetArrayBuffer());
+  {
+    const v8::HandleScope handle_scope(env()->isolate());
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        env()->state_string(),
+        impl_->state_slot_.GetPageDataView(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(impl_->state_slot_.GetByteOffset())));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        env()->stats_string(),
+        impl_->stats_slot_.GetPageBigUint64Array(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(impl_->stats_slot_.GetByteOffset())));
+  }
 
   UpdateDataStats();
 }
@@ -1737,12 +1811,11 @@ bool Session::is_destroyed() const {
 }
 
 bool Session::is_destroyed_or_closing() const {
-  return !impl_ || impl_->state_->closing;
+  return !impl_ || impl_->state()->closing;
 }
 
 void Session::Close(CloseMethod method) {
   if (is_destroyed()) return;
-  auto& stats_ = impl_->stats_;
 
   // If the handshake was deferred (0-RTT client that never sent),
   // no packets were ever transmitted. Close silently since there is
@@ -1757,7 +1830,7 @@ void Session::Close(CloseMethod method) {
   }
 
   STAT_RECORD_TIMESTAMP(Stats, closing_at);
-  impl_->state_->closing = 1;
+  impl_->state()->closing = 1;
 
   // With both the DEFAULT and SILENT options, we will proceed to closing
   // the session immediately. All open streams will be immediately destroyed
@@ -1773,27 +1846,27 @@ void Session::Close(CloseMethod method) {
   switch (method) {
     case CloseMethod::DEFAULT: {
       Debug(this, "Immediately closing session");
-      impl_->state_->silent_close = 0;
+      impl_->state()->silent_close = 0;
       return FinishClose();
     }
     case CloseMethod::SILENT: {
       Debug(this, "Immediately closing session silently");
-      impl_->state_->silent_close = 1;
+      impl_->state()->silent_close = 1;
       return FinishClose();
     }
     case CloseMethod::GRACEFUL: {
       // If we are already closing gracefully, do nothing.
-      if (impl_->state_->graceful_close) [[unlikely]] {
+      if (impl_->state()->graceful_close) [[unlikely]] {
         return;
       }
-      impl_->state_->graceful_close = 1;
+      impl_->state()->graceful_close = 1;
 
       // application_ may be null for server sessions if close() is called
       // before the TLS handshake selects the ALPN. Without an application
       // we cannot do a graceful shutdown (GOAWAY, CONNECTION_CLOSE etc.),
       // so fall through to a silent close.
       if (!impl_->application_) {
-        impl_->state_->silent_close = 1;
+        impl_->state()->silent_close = 1;
         return FinishClose();
       }
 
@@ -1811,7 +1884,7 @@ void Session::Close(CloseMethod method) {
       // If there are no open streams, then we can close immediately and
       // not worry about waiting around.
       if (impl_->streams_.empty()) {
-        impl_->state_->silent_close = 0;
+        impl_->state()->silent_close = 0;
         return FinishClose();
       }
 
@@ -1855,11 +1928,11 @@ void Session::FinishClose() {
   // trigger MakeCallback (stream destruction, pending queue rejection,
   // SendConnectionClose, EmitClose).
   if (is_destroyed()) return;
-  DCHECK(impl_->state_->closing);
+  DCHECK(impl_->state()->closing);
 
   // Clear the graceful_close flag to prevent RemoveStream() from
   // re-entering FinishClose() when we destroy streams below.
-  impl_->state_->graceful_close = 0;
+  impl_->state()->graceful_close = 0;
 
   // Destroy all open streams immediately. We copy the map because
   // streams remove themselves during destruction. Each Destroy() call
@@ -1881,7 +1954,7 @@ void Session::FinishClose() {
 
   // Send final application-level shutdown and CONNECTION_CLOSE
   // unless this is a silent close.
-  if (!impl_->state_->silent_close) {
+  if (!impl_->state()->silent_close) {
     if (impl_->application_) {
       application().CompleteShutdown();
     }
@@ -1894,7 +1967,7 @@ void Session::FinishClose() {
   // If the session was passed to JavaScript, we need to round-trip
   // through JS so it can clean up before we destroy. The JS side
   // will synchronously call destroy(), which calls Session::Destroy().
-  if (impl_->state_->wrapped) {
+  if (impl_->state()->wrapped) {
     EmitClose(impl_->last_error_);
   } else {
     Destroy();
@@ -1906,7 +1979,7 @@ void Session::Destroy() {
   // Ensure the closing flag is set for the ~Impl() DCHECK. Normally
   // this is set by Session::Close(), but JS destroy() can be called
   // directly without going through Close() first.
-  impl_->state_->closing = 1;
+  impl_->state()->closing = 1;
 
   // If we're inside a ngtcp2 or nghttp3 callback scope, we cannot
   // destroy impl_ now because the callback is executing methods on
@@ -1919,10 +1992,7 @@ void Session::Destroy() {
   }
 
   Debug(this, "Session destroyed");
-  {
-    auto& stats_ = impl_->stats_;
-    STAT_RECORD_TIMESTAMP(Stats, destroyed_at);
-  }
+  STAT_RECORD_TIMESTAMP(Stats, destroyed_at);
   impl_.reset();
 }
 
@@ -1998,16 +2068,16 @@ void Session::SetApplication(std::unique_ptr<Application> app) {
       return;
     }
   }
-  impl_->state_->application_type = static_cast<uint8_t>(app->type());
-  impl_->state_->headers_supported = static_cast<uint8_t>(
+  impl_->state()->application_type = static_cast<uint8_t>(app->type());
+  impl_->state()->headers_supported = static_cast<uint8_t>(
       app->SupportsHeaders() ? HeadersSupportState::SUPPORTED
                              : HeadersSupportState::UNSUPPORTED);
   // Surface the application's "no error" and "internal error" codes via
   // session state so that JS-side code (e.g. the stream writer's fail()
   // path) can resolve the right wire code for the negotiated ALPN
   // without duplicating the per-application table.
-  impl_->state_->no_error_code = app->GetNoErrorCode();
-  impl_->state_->internal_error_code = app->GetInternalErrorCode();
+  impl_->state()->no_error_code = app->GetNoErrorCode();
+  impl_->state()->internal_error_code = app->GetInternalErrorCode();
   impl_->application_ = std::move(app);
 }
 
@@ -2165,7 +2235,6 @@ bool Session::ReadPacket(const uint8_t* data,
     case 0: {
       Debug(this, "Session successfully received %zu-byte packet", len);
       if (!is_destroyed()) [[likely]] {
-        auto& stats_ = impl_->stats_;
         STAT_INCREMENT_N(Stats, bytes_received, len);
         // Process deferred operations that couldn't run inside callback
         // scopes (e.g., HTTP/3 GOAWAY handling that calls into JS).
@@ -2197,7 +2266,7 @@ bool Session::ReadPacket(const uint8_t* data,
       //    There is no point in waiting for a draining period — the
       //    peer has no state. Close immediately with an error.
       if (!is_destroyed()) [[likely]] {
-        if (impl_->state_->stateless_reset) {
+        if (impl_->state()->stateless_reset) {
           Debug(this, "Session received stateless reset, closing");
           SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_DRAINING));
           Close(CloseMethod::SILENT);
@@ -2428,10 +2497,10 @@ datagram_id Session::SendDatagram(Store&& data) {
   }
 
   // Assign the datagram ID.
-  datagram_id did = ++impl_->state_->last_datagram_id;
+  datagram_id did = ++impl_->state()->last_datagram_id;
 
   // Check queue capacity. Apply the drop policy when full.
-  auto max_pending = impl_->state_->max_pending_datagrams;
+  auto max_pending = impl_->state()->max_pending_datagrams;
   if (max_pending > 0 && impl_->pending_datagrams_.size() >= max_pending) {
     auto drop_policy = impl_->config_.options.datagram_drop_policy;
     if (drop_policy == DatagramDropPolicy::DROP_OLDEST) {
@@ -2602,7 +2671,6 @@ void Session::AddStream(BaseObjectPtr<Stream> stream,
 
   // Update tracking statistics for the number of streams associated with this
   // session.
-  auto& stats_ = impl_->stats_;
   if (ngtcp2_conn_is_local_stream(*this, id)) {
     switch (direction) {
       case Direction::BIDIRECTIONAL: {
@@ -2654,7 +2722,7 @@ void Session::RemoveStream(stream_id id) {
   // then we can proceed to finishing the close now. Note that the
   // expectation is that the session will be destroyed once FinishClose
   // returns.
-  if (impl_->state_->closing && impl_->state_->graceful_close) {
+  if (impl_->state()->closing && impl_->state()->graceful_close) {
     FinishClose();
     CHECK(is_destroyed());
   }
@@ -2692,7 +2760,6 @@ void Session::ShutdownStreamWrite(stream_id id, QuicError code) {
 
 void Session::StreamDataBlocked(stream_id id) {
   DCHECK(!is_destroyed());
-  auto& stats_ = impl_->stats_;
   STAT_INCREMENT(Stats, block_count);
   application().BlockStream(id);
 }
@@ -2763,20 +2830,20 @@ bool Session::is_in_draining_period() const {
 
 bool Session::wants_session_ticket() const {
   return !is_destroyed() &&
-         HasListenerFlag(impl_->state_->listener_flags,
+         HasListenerFlag(impl_->state()->listener_flags,
                          SessionListenerFlags::SESSION_TICKET);
 }
 
 void Session::SetStreamOpenAllowed() {
   DCHECK(!is_destroyed());
-  impl_->state_->stream_open_allowed = 1;
+  impl_->state()->stream_open_allowed = 1;
 }
 
 void Session::PopulateEarlyTransportParamsState() {
   DCHECK(!is_destroyed());
   const ngtcp2_transport_params* tp = remote_transport_params();
   if (tp != nullptr) {
-    impl_->state_->max_datagram_size =
+    impl_->state()->max_datagram_size =
         MaxDatagramPayload(tp->max_datagram_frame_size);
   }
 }
@@ -2797,7 +2864,7 @@ bool Session::can_create_streams() const {
 }
 
 bool Session::can_open_streams() const {
-  return !is_destroyed() && impl_->state_->stream_open_allowed;
+  return !is_destroyed() && impl_->state()->stream_open_allowed;
 }
 
 uint64_t Session::max_data_left() const {
@@ -2818,12 +2885,12 @@ uint64_t Session::max_local_streams_bidi() const {
 
 void Session::set_wrapped() {
   DCHECK(!is_destroyed());
-  impl_->state_->wrapped = 1;
+  impl_->state()->wrapped = 1;
 }
 
 void Session::set_priority_supported(bool on) {
   DCHECK(!is_destroyed());
-  impl_->state_->priority_supported = on ? 1 : 0;
+  impl_->state()->priority_supported = on ? 1 : 0;
 }
 
 void Session::ExtendStreamOffset(stream_id id, size_t amount) {
@@ -2856,14 +2923,13 @@ size_t Session::PendingDatagramCount() const {
 
 void Session::DatagramSent(datagram_id id) {
   Debug(this, "Datagram %" PRIu64 " sent", id);
-  auto& stats_ = impl_->stats_;
   STAT_INCREMENT(Stats, datagrams_sent);
 }
 
 void Session::UpdateDataStats() {
   if (is_destroyed()) return;
   Debug(this, "Updating data stats");
-  auto& stats_ = impl_->stats_;
+
   ngtcp2_conn_info info;
   ngtcp2_conn_get_conn_info(*this, &info);
   STAT_SET(Stats, bytes_in_flight, info.bytes_in_flight);
@@ -3017,7 +3083,7 @@ void Session::UpdateTimer() {
 void Session::DatagramStatus(datagram_id datagramId,
                              quic::DatagramStatus status) {
   DCHECK(!is_destroyed());
-  auto& stats_ = impl_->stats_;
+
   switch (status) {
     case DatagramStatus::ACKNOWLEDGED: {
       Debug(this, "Datagram %" PRIu64 " was acknowledged", datagramId);
@@ -3035,7 +3101,7 @@ void Session::DatagramStatus(datagram_id datagramId,
       break;
     }
   }
-  if (HasListenerFlag(impl_->state_->listener_flags,
+  if (HasListenerFlag(impl_->state()->listener_flags,
                       SessionListenerFlags::DATAGRAM_STATUS)) {
     EmitDatagramStatus(datagramId, status);
   }
@@ -3047,13 +3113,13 @@ void Session::DatagramReceived(const uint8_t* data,
   DCHECK(!is_destroyed());
   // If there is nothing watching for the datagram on the JavaScript side,
   // or if the datagram is zero-length, we just drop it on the floor.
-  if (!HasListenerFlag(impl_->state_->listener_flags,
+  if (!HasListenerFlag(impl_->state()->listener_flags,
                        SessionListenerFlags::DATAGRAM) ||
       datalen == 0)
     return;
 
   Debug(this, "Session is receiving datagram of size %zu", datalen);
-  auto& stats_ = impl_->stats_;
+
   STAT_INCREMENT(Stats, datagrams_received);
   JS_TRY_ALLOCATE_BACKING(env(), backing, datalen)
   memcpy(backing->Data(), data, datalen);
@@ -3074,18 +3140,18 @@ void Session::GenerateNewConnectionId(ngtcp2_cid* cid,
 
 bool Session::HandshakeCompleted() {
   DCHECK(!is_destroyed());
-  DCHECK(!impl_->state_->handshake_completed);
+  DCHECK(!impl_->state()->handshake_completed);
 
   Debug(this, "Session handshake completed");
-  impl_->state_->handshake_completed = 1;
-  auto& stats_ = impl_->stats_;
+  impl_->state()->handshake_completed = 1;
+
   STAT_RECORD_TIMESTAMP(Stats, handshake_completed_at);
   SetStreamOpenAllowed();
 
   // Capture the peer's max datagram frame size from the remote transport
   // parameters so JavaScript can check it without a C++ round-trip.
   const ngtcp2_transport_params* tp = remote_transport_params();
-  impl_->state_->max_datagram_size =
+  impl_->state()->max_datagram_size =
       MaxDatagramPayload(tp->max_datagram_frame_size);
 
   // If early data was attempted but rejected by the server,
@@ -3120,10 +3186,10 @@ bool Session::HandshakeCompleted() {
 
 void Session::HandshakeConfirmed() {
   DCHECK(!is_destroyed());
-  DCHECK(!impl_->state_->handshake_confirmed);
+  DCHECK(!impl_->state()->handshake_confirmed);
   Debug(this, "Session handshake confirmed");
-  impl_->state_->handshake_confirmed = 1;
-  auto& stats_ = impl_->stats_;
+  impl_->state()->handshake_confirmed = 1;
+
   STAT_RECORD_TIMESTAMP(Stats, handshake_confirmed_at);
 }
 
@@ -3261,7 +3327,7 @@ void Session::EmitClose(const QuicError& error) {
 
 void Session::set_max_datagram_size(uint16_t size) {
   if (!is_destroyed()) {
-    impl_->state_->max_datagram_size = size;
+    impl_->state()->max_datagram_size = size;
   }
 }
 
@@ -3376,7 +3442,7 @@ void Session::EmitPathValidation(PathValidationResult result,
 
   if (!env()->can_call_into_js()) return;
 
-  if (!HasListenerFlag(impl_->state_->listener_flags,
+  if (!HasListenerFlag(impl_->state()->listener_flags,
                        SessionListenerFlags::PATH_VALIDATION)) [[likely]] {
     return;
   }
@@ -3422,7 +3488,7 @@ void Session::EmitSessionTicket(Store&& ticket) {
 
   // If there is nothing listening for the session ticket, don't bother
   // emitting.
-  if (!HasListenerFlag(impl_->state_->listener_flags,
+  if (!HasListenerFlag(impl_->state()->listener_flags,
                        SessionListenerFlags::SESSION_TICKET)) [[likely]] {
     Debug(this, "Session ticket was discarded");
     return;
@@ -3479,7 +3545,7 @@ void Session::EmitEarlyDataRejected() {
 
 void Session::EmitNewToken(const uint8_t* token, size_t len) {
   DCHECK(!is_destroyed());
-  if (!HasListenerFlag(impl_->state_->listener_flags,
+  if (!HasListenerFlag(impl_->state()->listener_flags,
                        SessionListenerFlags::NEW_TOKEN))
     return;
   if (!env()->can_call_into_js()) return;
@@ -3555,7 +3621,7 @@ void Session::EmitVersionNegotiation(const ngtcp2_pkt_hd& hd,
 
 void Session::EmitOrigins(std::vector<std::string>&& origins) {
   DCHECK(!is_destroyed());
-  if (!HasListenerFlag(impl_->state_->listener_flags,
+  if (!HasListenerFlag(impl_->state()->listener_flags,
                        SessionListenerFlags::ORIGIN))
     return;
   if (!env()->can_call_into_js()) return;
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 81e619e28d3720..abd14300487f30 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -151,6 +151,44 @@ struct Stream::State {
 
 STAT_STRUCT(Stream, STREAM)
 
+// Stream uses arena-allocated stats, not AliasedStruct, so override the
+// STAT_* macros to use the stats() accessor instead of stats_.Data().
+#undef STAT_INCREMENT
+#undef STAT_INCREMENT_N
+#undef STAT_RECORD_TIMESTAMP
+#undef STAT_SET
+#undef STAT_GET
+#define STAT_INCREMENT(Type, name) IncrementStat<Type, &Type::name>(stats());
+#define STAT_INCREMENT_N(Type, name, amt)                                      \
+  IncrementStat<Type, &Type::name>(stats(), amt);
+#define STAT_RECORD_TIMESTAMP(Type, name)                                      \
+  RecordTimestampStat<Type, &Type::name>(stats());
+#define STAT_SET(Type, name, val) SetStat<Type, &Type::name>(stats(), val)
+#define STAT_GET(Type, name) GetStat<Type, &Type::name>(stats())
+
+using StreamStateArena = AliasedStructArena<Stream::State>;
+using StreamStatsArena = AliasedStructArena<Stream::Stats>;
+
+namespace {
+StreamStateArena& GetStreamStateArena(BindingData& binding) {
+  if (!binding.stream_state_arena_) {
+    auto* arena = new StreamStateArena();
+    binding.stream_state_arena_ = BindingData::ArenaPtr(
+        arena, +[](void* p) { delete static_cast<StreamStateArena*>(p); });
+  }
+  return *static_cast<StreamStateArena*>(binding.stream_state_arena_.get());
+}
+
+StreamStatsArena& GetStreamStatsArena(BindingData& binding) {
+  if (!binding.stream_stats_arena_) {
+    auto* arena = new StreamStatsArena();
+    binding.stream_stats_arena_ = BindingData::ArenaPtr(
+        arena, +[](void* p) { delete static_cast<StreamStatsArena*>(p); });
+  }
+  return *static_cast<StreamStatsArena*>(binding.stream_stats_arena_.get());
+}
+}  // namespace
+
 // ============================================================================
 
 namespace {
@@ -382,14 +420,14 @@ struct Stream::Impl {
       code = args[0].As<BigInt>()->Uint64Value(&lossless);
     }
 
-    if (stream->state_->reset == 1) return;
+    if (stream->state()->reset == 1) return;
 
     stream->EndWritable();
     // We can release our outbound here now. Since the stream is being reset
     // on the ngtcp2 side, we do not need to keep any of the data around
     // waiting for acknowledgement that will never come.
     stream->outbound_.reset();
-    stream->state_->reset = 1;
+    stream->state()->reset = 1;
 
     if (!stream->is_pending()) {
       if (stream->is_remote_unidirectional()) return;
@@ -993,30 +1031,56 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
                stream_id id,
                std::shared_ptr<DataQueue> source)
     : AsyncWrap(session->env(), object, PROVIDER_QUIC_STREAM),
-      stats_(env()->isolate()),
-      state_(env()->isolate()),
       session_(std::move(session)),
       inbound_(DataQueue::Create()),
       headers_(env()->isolate()) {
+  auto& binding = BindingData::Get(env());
+  stats_slot_ = GetStreamStatsArena(binding).Allocate(env()->isolate());
+  state_slot_ = GetStreamStateArena(binding).Allocate(env()->isolate());
   MakeWeak();
   DCHECK(id < kMaxStreamId);
-  state_->id = id;
-  state_->pending = 0;
+  state()->id = id;
+  state()->pending = 0;
   // Allows us to be notified when data is actually read from the
   // inbound queue so that we can update the stream flow control.
   inbound_->addBackpressureListener(this);
 
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->state_string(), state_.GetArrayBuffer());
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->stats_string(), stats_.GetArrayBuffer());
+  {
+    const v8::HandleScope handle_scope(env()->isolate());
+    // Pass the page's shared views and this slot's byte offset. JS uses
+    // the offset to index into the shared view — no per-stream V8 object
+    // creation.
+    JS_DEFINE_READONLY_PROPERTY(env(),
+                                object,
+                                env()->state_string(),
+                                state_slot_.GetPageDataView(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(state_slot_.GetByteOffset())));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        env()->stats_string(),
+        stats_slot_.GetPageBigUint64Array(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(stats_slot_.GetByteOffset())));
+  }
 
   set_outbound(std::move(source));
 
   STAT_RECORD_TIMESTAMP(Stats, created_at);
   auto params = ngtcp2_conn_get_local_transport_params(this->session());
   STAT_SET(Stats, max_offset, params->initial_max_data);
-  STAT_SET(Stats, opened_at, stats_->created_at);
+  STAT_SET(Stats, opened_at, stats()->created_at);
 }
 
 Stream::Stream(BaseObjectWeakPtr<Session> session,
@@ -1024,25 +1088,48 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
                Direction direction,
                std::shared_ptr<DataQueue> source)
     : AsyncWrap(session->env(), object, PROVIDER_QUIC_STREAM),
-      stats_(env()->isolate()),
-      state_(env()->isolate()),
       session_(std::move(session)),
       inbound_(DataQueue::Create()),
       maybe_pending_stream_(
           std::make_unique<PendingStream>(direction, this, session_)),
       headers_(env()->isolate()) {
+  auto& binding = BindingData::Get(env());
+  stats_slot_ = GetStreamStatsArena(binding).Allocate(env()->isolate());
+  state_slot_ = GetStreamStateArena(binding).Allocate(env()->isolate());
   MakeWeak();
-  state_->id = kMaxStreamId;
-  state_->pending = 1;
+  state()->id = kMaxStreamId;
+  state()->pending = 1;
 
   // Allows us to be notified when data is actually read from the
   // inbound queue so that we can update the stream flow control.
   inbound_->addBackpressureListener(this);
 
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->state_string(), state_.GetArrayBuffer());
-  JS_DEFINE_READONLY_PROPERTY(
-      env(), object, env()->stats_string(), stats_.GetArrayBuffer());
+  {
+    const v8::HandleScope handle_scope(env()->isolate());
+    JS_DEFINE_READONLY_PROPERTY(env(),
+                                object,
+                                env()->state_string(),
+                                state_slot_.GetPageDataView(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(state_slot_.GetByteOffset())));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        env()->stats_string(),
+        stats_slot_.GetPageBigUint64Array(env()->isolate()));
+    JS_DEFINE_READONLY_PROPERTY(
+        env(),
+        object,
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
+        v8::Integer::NewFromUnsigned(
+            env()->isolate(),
+            static_cast<uint32_t>(stats_slot_.GetByteOffset())));
+  }
 
   set_outbound(std::move(source));
 
@@ -1053,15 +1140,24 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
 
 Stream::~Stream() {
   // Make sure that Destroy() was called before Stream is actually destructed.
-  DCHECK_NE(stats_->destroyed_at, 0);
+  DCHECK_NE(stats()->destroyed_at, 0);
+
+  // Release arena slots back to the freelist.
+  auto& binding = BindingData::Get(env());
+  if (stats_slot_) {
+    GetStreamStatsArena(binding).ReleaseSlot(stats_slot_);
+  }
+  if (state_slot_) {
+    GetStreamStateArena(binding).ReleaseSlot(state_slot_);
+  }
 }
 
 void Stream::NotifyStreamOpened(stream_id id) {
   CHECK(is_pending());
   DCHECK(id < kMaxStreamId);
   Debug(this, "Pending stream opened with id %" PRIi64, id);
-  state_->pending = 0;
-  state_->id = id;
+  state()->pending = 0;
+  state()->id = id;
   STAT_RECORD_TIMESTAMP(Stats, opened_at);
   // Now that the stream is actually opened, add it to the sessions
   // list of known open streams.
@@ -1132,26 +1228,26 @@ void Stream::EnqueuePendingHeaders(HeadersKind kind,
 }
 
 bool Stream::is_pending() const {
-  return state_->pending;
+  return state()->pending;
 }
 
 stream_id Stream::id() const {
-  return state_->id;
+  return state()->id;
 }
 
 Side Stream::origin() const {
   CHECK(!is_pending());
-  return (state_->id & 0b01) ? Side::SERVER : Side::CLIENT;
+  return (state()->id & 0b01) ? Side::SERVER : Side::CLIENT;
 }
 
 Direction Stream::direction() const {
-  if (state_->pending) {
+  if (state()->pending) {
     CHECK(maybe_pending_stream_.has_value());
     auto& val = maybe_pending_stream_.value();
     return val->direction();
   }
-  return (state_->id & 0b10) ? Direction::UNIDIRECTIONAL
-                             : Direction::BIDIRECTIONAL;
+  return (state()->id & 0b10) ? Direction::UNIDIRECTIONAL
+                              : Direction::BIDIRECTIONAL;
 }
 
 Session& Stream::session() const {
@@ -1169,15 +1265,15 @@ bool Stream::is_remote_unidirectional() const {
 }
 
 bool Stream::is_eos() const {
-  return state_->fin_sent;
+  return state()->fin_sent;
 }
 
 bool Stream::wants_trailers() const {
-  return state_->wants_trailers;
+  return state()->wants_trailers;
 }
 
 void Stream::set_early() {
-  state_->received_early_data = 1;
+  state()->received_early_data = 1;
 }
 
 bool Stream::is_writable() const {
@@ -1187,7 +1283,7 @@ bool Stream::is_writable() const {
       !ngtcp2_conn_is_local_stream(session(), id())) {
     return false;
   }
-  return state_->write_ended == 0;
+  return state()->write_ended == 0;
 }
 
 bool Stream::has_outbound() const {
@@ -1209,21 +1305,21 @@ bool Stream::is_readable() const {
       ngtcp2_conn_is_local_stream(session(), id())) {
     return false;
   }
-  return state_->read_ended == 0;
+  return state()->read_ended == 0;
 }
 
 BaseObjectPtr<Blob::Reader> Stream::get_reader() {
-  if (!is_readable() || state_->has_reader) return {};
-  state_->has_reader = 1;
+  if (!is_readable() || state()->has_reader) return {};
+  state()->has_reader = 1;
   auto reader = Blob::Reader::Create(env(), Blob::Create(env(), inbound_));
   reader_ = reader;
   return reader;
 }
 
 void Stream::set_final_size(uint64_t final_size) {
-  DCHECK_IMPLIES(state_->fin_received == 1,
+  DCHECK_IMPLIES(state()->fin_received == 1,
                  final_size <= STAT_GET(Stats, final_size));
-  state_->fin_received = 1;
+  state()->fin_received = 1;
   STAT_SET(Stats, final_size, final_size);
 }
 
@@ -1232,7 +1328,7 @@ void Stream::set_outbound(std::shared_ptr<DataQueue> source) {
   Debug(this, "Setting the outbound data source");
   DCHECK_NULL(outbound_);
   outbound_ = std::make_unique<Outbound>(this, std::move(source));
-  state_->has_outbound = 1;
+  state()->has_outbound = 1;
   // Note: We intentionally do NOT call ResumeStream here. During
   // construction, the stream has not yet been added to the session's
   // streams map, so FindStream would fail. The caller (CreateStream /
@@ -1251,7 +1347,7 @@ void Stream::InitStreaming() {
   }
   Debug(this, "Initializing streaming outbound source");
   outbound_ = std::make_unique<Outbound>(this);
-  state_->has_outbound = 1;
+  state()->has_outbound = 1;
   if (!is_pending()) session_->ResumeStream(id());
 }
 
@@ -1397,7 +1493,7 @@ void Stream::Commit(size_t datalen, bool fin) {
   Debug(this, "Committing %zu bytes", datalen);
   STAT_INCREMENT_N(Stats, bytes_sent, datalen);
   if (outbound_) outbound_->Commit(datalen);
-  if (fin) state_->fin_sent = 1;
+  if (fin) state()->fin_sent = 1;
 }
 
 void Stream::EndWritable() {
@@ -1407,12 +1503,12 @@ void Stream::EndWritable() {
   // will be a non-op since we're not going to be writing any more data
   // into it anyway.
   if (outbound_) outbound_->Cap();
-  state_->write_ended = 1;
+  state()->write_ended = 1;
 }
 
 void Stream::EndReadable(std::optional<uint64_t> maybe_final_size) {
   if (!is_readable()) return;
-  state_->read_ended = 1;
+  state()->read_ended = 1;
   set_final_size(maybe_final_size.value_or(STAT_GET(Stats, bytes_received)));
   inbound_->cap(STAT_GET(Stats, final_size));
   // Notify the JS reader so it can see EOS. Pass fin=true so the
@@ -1422,20 +1518,20 @@ void Stream::EndReadable(std::optional<uint64_t> maybe_final_size) {
 }
 
 void Stream::Destroy(QuicError error) {
-  if (stats_->destroyed_at != 0) return;
+  if (stats()->destroyed_at != 0) return;
   // Record the destroyed at timestamp before notifying the JavaScript side
   // that the stream is being destroyed.
   STAT_RECORD_TIMESTAMP(Stats, destroyed_at);
 
   DCHECK_NOT_NULL(session_.get());
 
-  if (!state_->pending) {
+  if (!state()->pending) {
     Debug(
         this, "Stream %" PRIi64 " being destroyed with error %s", id(), error);
   } else {
     Debug(this, "Pending stream being destroyed with error %s", error);
   }
-  state_->pending = 0;
+  state()->pending = 0;
 
   maybe_pending_stream_.reset();
 
@@ -1482,12 +1578,12 @@ void Stream::ReceiveData(const uint8_t* data,
   // If reading has ended, or there is no data, there's nothing to do but maybe
   // end the readable side if this is the last bit of data we've received.
   Debug(this, "Receiving %zu bytes of data", len);
-  if (state_->read_ended == 1 || len == 0) {
+  if (state()->read_ended == 1 || len == 0) {
     if (flags.fin) EndReadable();
     return;
   }
 
-  if (flags.early) state_->received_early_data = 1;
+  if (flags.early) state()->received_early_data = 1;
   STAT_INCREMENT_N(Stats, bytes_received, len);
   STAT_SET(Stats, max_offset_received, STAT_GET(Stats, bytes_received));
   STAT_RECORD_TIMESTAMP(Stats, received_at);
@@ -1509,10 +1605,10 @@ void Stream::ReceiveStopSending(QuicError error) {
   // writable side has already been shut down (e.g. we already sent
   // RESET_STREAM ourselves or finished sending with FIN) there is
   // nothing more to do here. The previous guard checked
-  // `state_->read_ended` which is unrelated to the writable side and
+  // `state()->read_ended` which is unrelated to the writable side and
   // suppressed STOP_SENDING handling whenever a sibling RESET_STREAM
   // frame had been processed first within the same packet.
-  if (state_->write_ended) return;
+  if (state()->write_ended) return;
   Debug(this, "Received stop sending with error %s", error);
   ngtcp2_conn_shutdown_stream_write(session(), 0, id(), error.code());
   EndWritable();
@@ -1528,7 +1624,7 @@ void Stream::ReceiveStreamReset(uint64_t final_size, QuicError error) {
         "Received stream reset with final size %" PRIu64 " and error %s",
         final_size,
         error);
-  state_->reset_code = error.code();
+  state()->reset_code = error.code();
   EndReadable(final_size);
   EmitReset(error);
 }
@@ -1536,10 +1632,10 @@ void Stream::ReceiveStreamReset(uint64_t final_size, QuicError error) {
 // ============================================================================
 
 void Stream::EmitBlocked() {
-  // state_->wants_block will be set from the javascript side if the
+  // state()->wants_block will be set from the javascript side if the
   // stream object has a handler for the blocked event.
   Debug(this, "Blocked");
-  if (!env()->can_call_into_js() || !state_->wants_block) {
+  if (!env()->can_call_into_js() || !state()->wants_block) {
     return;
   }
   CallbackScope<Stream> cb_scope(this);
@@ -1556,7 +1652,7 @@ void Stream::UpdateWriteDesiredSize() {
   if (!outbound_ || !outbound_->is_streaming()) return;
 
   uint64_t available;
-  uint64_t hwm = state_->high_water_mark;
+  uint64_t hwm = state()->high_water_mark;
 
   if (is_pending()) {
     // Pending streams don't have a stream ID yet, so ngtcp2 can't
@@ -1589,8 +1685,8 @@ void Stream::UpdateWriteDesiredSize() {
   uint32_t clamped = static_cast<uint32_t>(
       std::min<uint64_t>(desired, std::numeric_limits<uint32_t>::max()));
 
-  uint32_t old_size = state_->write_desired_size;
-  state_->write_desired_size = clamped;
+  uint32_t old_size = state()->write_desired_size;
+  state()->write_desired_size = clamped;
 
   // Fire drain when transitioning from 0 to non-zero.
   // writeDesiredSize == 0 means the buffer is full or flow control is
@@ -1609,9 +1705,9 @@ void Stream::EmitClose(const QuicError& error) {
 }
 
 void Stream::EmitHeaders() {
-  // state_->wants_headers will be set from the javascript side if the
+  // state()->wants_headers will be set from the javascript side if the
   // stream object has a handler for the headers event.
-  if (!env()->can_call_into_js() || !state_->wants_headers) {
+  if (!env()->can_call_into_js() || !state()->wants_headers) {
     return;
   }
   CallbackScope<Stream> cb_scope(this);
@@ -1628,9 +1724,9 @@ void Stream::EmitHeaders() {
 }
 
 void Stream::EmitReset(const QuicError& error) {
-  // state_->wants_reset will be set from the javascript side if the
+  // state()->wants_reset will be set from the javascript side if the
   // stream object has a handler for the reset event.
-  if (!env()->can_call_into_js() || !state_->wants_reset) {
+  if (!env()->can_call_into_js() || !state()->wants_reset) {
     return;
   }
   CallbackScope<Stream> cb_scope(this);
@@ -1641,9 +1737,9 @@ void Stream::EmitReset(const QuicError& error) {
 }
 
 void Stream::EmitWantTrailers() {
-  // state_->wants_trailers will be set from the javascript side if the
+  // state()->wants_trailers will be set from the javascript side if the
   // stream object has a handler for the trailers event.
-  if (!env()->can_call_into_js() || !state_->wants_trailers) {
+  if (!env()->can_call_into_js() || !state()->wants_trailers) {
     return;
   }
   CallbackScope<Stream> cb_scope(this);
diff --git a/src/quic/streams.h b/src/quic/streams.h
index 0edeeed7a9209e..b72298f16636ae 100644
--- a/src/quic/streams.h
+++ b/src/quic/streams.h
@@ -304,6 +304,17 @@ class Stream final : public AsyncWrap,
   struct State;
   struct Stats;
 
+  // Typed accessors for arena-allocated state/stats. These are defined
+  // in streams.cc where State and Stats are complete types.
+  inline State* state() { return static_cast<State*>(state_slot_.ptr); }
+  inline const State* state() const {
+    return static_cast<const State*>(state_slot_.ptr);
+  }
+  inline Stats* stats() { return static_cast<Stats*>(stats_slot_.ptr); }
+  inline const Stats* stats() const {
+    return static_cast<const Stats*>(stats_slot_.ptr);
+  }
+
  private:
   struct Impl;
   struct PendingHeaders;
@@ -362,8 +373,8 @@ class Stream final : public AsyncWrap,
                              v8::Local<v8::Array> headers,
                              HeadersFlags flags);
 
-  AliasedStruct<Stats> stats_;
-  AliasedStruct<State> state_;
+  ArenaSlotBase stats_slot_;
+  ArenaSlotBase state_slot_;
   BaseObjectWeakPtr<Session> session_;
   std::unique_ptr<Outbound> outbound_;
   std::shared_ptr<DataQueue> inbound_;

From e56badc96d7c789833f4577f811e1fbfe62230dd Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 13 May 2026 06:50:43 -0700
Subject: [PATCH 57/83] quic: improve internal structure of QuicStream

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/quic/quic.js | 421 ++++++++++++++++++--------------------
 1 file changed, 195 insertions(+), 226 deletions(-)

diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 34e3cbf10a1821..6082226edf4d9d 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -1391,56 +1391,17 @@ function maybeGetCloseError(context, status, pendingError) {
 }
 
 class QuicStream {
+  // All mutable per-stream state is consolidated into a single object
+  // to minimize the number of V8 private field slots. Only #handle is
+  // kept as a private field for the brand check in #assertIsQuicStream.
   /** @type {object} */
   #handle;
-  /**
-   * Flag set at the top of `destroy()` to make the method safely
-   * re-entrant. Distinct from `#handle === undefined` (which signals
-   * "fully destroyed" and is set inside `[kFinishClose]`) so that
-   * `[kFinishClose]`'s own destroyed-guard does not bail before the
-   * cleanup work runs.
-   * @type {boolean}
-   */
-  #destroying = false;
-  /** @type {QuicSession} */
-  #session;
-  /** @type {QuicStreamStats} */
-  #stats;
-  /** @type {QuicStreamState} */
-  #state;
-  /** @type {number} */
-  #direction = undefined;
-  /** @type {Function|undefined} */
-  #onerror = undefined;
-  /** @type {OnBlockedCallback|undefined} */
-  #onblocked = undefined;
-  /** @type {OnStreamErrorCallback|undefined} */
-  #onreset = undefined;
-  /** @type {Function|undefined} */
-  #onheaders = undefined;
-  /** @type {Function|undefined} */
-  #ontrailers = undefined;
-  /** @type {Function|undefined} */
-  #oninfo = undefined;
-  /** @type {Function|undefined} */
-  #onwanttrailers = undefined;
-  /** @type {object|undefined} */
-  #headers = undefined;
-  /** @type {object|undefined} */
-  #pendingTrailers = undefined;
-  /** @type {Promise<void>} */
-  #pendingClose = PromiseWithResolvers();
-  #reader;
-  #iteratorLocked = false;
-  #writer = undefined;
-  #outboundSet = false;
-  /** @type {FileHandle|undefined} */
-  #fileHandle = undefined;
+  #inner;
 
   static {
     getQuicStreamState = function(stream) {
       QuicStream.#assertIsQuicStream(stream);
-      return stream.#state;
+      return stream.#inner.state;
     };
   }
 
@@ -1451,7 +1412,7 @@ class QuicStream {
   }
 
   #assertHeadersSupported() {
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
@@ -1462,31 +1423,47 @@ class QuicStream {
    * @param {object} handle
    * @param {QuicSession} session
    * @param {number} direction
+   * @param {boolean} [isLocal] True for locally-initiated streams
    */
-  constructor(privateSymbol, handle, session, direction) {
+  constructor(privateSymbol, handle, session, direction, isLocal = false) {
     if (privateSymbol !== kPrivateConstructor) {
       throw new ERR_ILLEGAL_CONSTRUCTOR();
     }
 
     this.#handle = handle;
-    this.#handle[kOwner] = this;
-    this.#session = session;
-    this.#direction = direction;
-    this.#stats = new QuicStreamStats(
-      kPrivateConstructor, this.#handle.stats, this.#handle.statsByteOffset);
-    this.#state = new QuicStreamState(
-      kPrivateConstructor, this.#handle.state, this.#handle.stateByteOffset);
-    this.#reader = this.#handle.getReader();
+    handle[kOwner] = this;
+    this.#inner = {
+      __proto__: null,
+      session,
+      direction,
+      isLocal,
+      state: new QuicStreamState(
+        kPrivateConstructor, handle.state, handle.stateByteOffset),
+      stats: undefined,
+      pendingClose: undefined,
+      reader: undefined,
+      destroying: false,
+      iteratorLocked: false,
+      outboundSet: false,
+      writer: undefined,
+      fileHandle: undefined,
+      headers: undefined,
+      pendingTrailers: undefined,
+      // Callback slots
+      onerror: undefined,
+      onblocked: undefined,
+      onreset: undefined,
+      onheaders: undefined,
+      ontrailers: undefined,
+      oninfo: undefined,
+      onwanttrailers: undefined,
+    };
 
     if (hasObserver('quic')) {
       startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicStream' });
     }
 
-    if (this.pending) {
-      debug(`pending ${this.direction} stream created`);
-    } else {
-      debug(`${this.direction} stream ${this.id} created`);
-    }
+    debug('stream created');
   }
 
   get [kValidatedSource]() { return true; }
@@ -1499,15 +1476,16 @@ class QuicStream {
    */
   async *[SymbolAsyncIterator]() {
     QuicStream.#assertIsQuicStream(this);
-    if (this.#iteratorLocked) {
+    if (this.#inner.iteratorLocked) {
       throw new ERR_INVALID_STATE('Stream is already being read');
     }
-    this.#iteratorLocked = true;
+    this.#inner.iteratorLocked = true;
 
+    this.#inner.reader ??= this.#handle?.getReader();
     // Non-readable stream (outbound-only unidirectional, or closed)
-    if (!this.#reader) return;
+    if (!this.#inner.reader) return;
 
-    yield* createBlobReaderIterable(this.#reader, {
+    yield* createBlobReaderIterable(this.#inner.reader, {
       getReadError: () => {
         // The read side ends for one of three reasons:
         //   * Clean FIN received from the peer (state.finReceived
@@ -1521,8 +1499,8 @@ class QuicStream {
         //     stream.stopSending(). Both paths run EndReadable in
         //     C++, setting state.readEnded without setting
         //     state.finReceived. There is no peer code to surface.
-        if (this.#state.readEnded && !this.#state.finReceived) {
-          const peerResetCode = this.#state.resetCode;
+        if (this.#inner.state.readEnded && !this.#inner.state.finReceived) {
+          const peerResetCode = this.#inner.state.resetCode;
           if (peerResetCode !== undefined && peerResetCode > 0n) {
             return new ERR_QUIC_STREAM_RESET(Number(peerResetCode));
           }
@@ -1541,7 +1519,7 @@ class QuicStream {
    */
   get pending() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#state.pending;
+    return this.#inner.state.pending;
   }
 
   /**
@@ -1552,7 +1530,7 @@ class QuicStream {
    */
   get early() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#state.early;
+    return this.#inner.state.early;
   }
 
   /**
@@ -1563,142 +1541,144 @@ class QuicStream {
    */
   get highWaterMark() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#state.highWaterMark;
+    return this.#inner.state.highWaterMark;
   }
 
   set highWaterMark(val) {
     QuicStream.#assertIsQuicStream(this);
     validateInteger(val, 'highWaterMark', 0, 0xFFFFFFFF);
-    this.#state.highWaterMark = val;
+    this.#inner.state.highWaterMark = val;
     // If writeDesiredSize hasn't been set yet (still 0 from initialization),
     // initialize it to the highWaterMark so the first write can proceed.
-    if (this.#state.writeDesiredSize === 0 && val > 0) {
-      this.#state.writeDesiredSize = val;
+    if (this.#inner.state.writeDesiredSize === 0 && val > 0) {
+      this.#inner.state.writeDesiredSize = val;
     }
   }
 
   /** @type {Function|undefined} */
   get onerror() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#onerror;
+    return this.#inner.onerror;
   }
 
   set onerror(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#onerror = undefined;
+      this.#inner.onerror = undefined;
     } else {
       validateFunction(fn, 'onerror');
-      this.#onerror = FunctionPrototypeBind(fn, this);
-      markPromiseAsHandled(this.#pendingClose.promise);
+      this.#inner.onerror = FunctionPrototypeBind(fn, this);
+      // Lazily create the close promise so it can be marked handled.
+      this.#inner.pendingClose ??= PromiseWithResolvers();
+      markPromiseAsHandled(this.#inner.pendingClose.promise);
     }
   }
 
   /** @type {OnBlockedCallback} */
   get onblocked() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#onblocked;
+    return this.#inner.onblocked;
   }
 
   set onblocked(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#onblocked = undefined;
-      this.#state.wantsBlock = false;
+      this.#inner.onblocked = undefined;
+      this.#inner.state.wantsBlock = false;
     } else {
       validateFunction(fn, 'onblocked');
-      this.#onblocked = FunctionPrototypeBind(fn, this);
-      this.#state.wantsBlock = true;
+      this.#inner.onblocked = FunctionPrototypeBind(fn, this);
+      this.#inner.state.wantsBlock = true;
     }
   }
 
   /** @type {OnStreamErrorCallback} */
   get onreset() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#onreset;
+    return this.#inner.onreset;
   }
 
   set onreset(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#onreset = undefined;
-      this.#state.wantsReset = false;
+      this.#inner.onreset = undefined;
+      this.#inner.state.wantsReset = false;
     } else {
       validateFunction(fn, 'onreset');
-      this.#onreset = FunctionPrototypeBind(fn, this);
-      this.#state.wantsReset = true;
+      this.#inner.onreset = FunctionPrototypeBind(fn, this);
+      this.#inner.state.wantsReset = true;
     }
   }
 
   /** @type {OnHeadersCallback} */
   get onheaders() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#onheaders;
+    return this.#inner.onheaders;
   }
 
   set onheaders(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#onheaders = undefined;
-      this.#state[kWantsHeaders] = false;
+      this.#inner.onheaders = undefined;
+      this.#inner.state[kWantsHeaders] = false;
     } else {
       this.#assertHeadersSupported();
       validateFunction(fn, 'onheaders');
-      this.#onheaders = FunctionPrototypeBind(fn, this);
-      this.#state[kWantsHeaders] = true;
+      this.#inner.onheaders = FunctionPrototypeBind(fn, this);
+      this.#inner.state[kWantsHeaders] = true;
     }
   }
 
   /** @type {Function|undefined} */
   get oninfo() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#oninfo;
+    return this.#inner.oninfo;
   }
 
   set oninfo(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#oninfo = undefined;
+      this.#inner.oninfo = undefined;
     } else {
       this.#assertHeadersSupported();
       validateFunction(fn, 'oninfo');
-      this.#oninfo = FunctionPrototypeBind(fn, this);
+      this.#inner.oninfo = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get ontrailers() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#ontrailers;
+    return this.#inner.ontrailers;
   }
 
   set ontrailers(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#ontrailers = undefined;
+      this.#inner.ontrailers = undefined;
     } else {
       this.#assertHeadersSupported();
       validateFunction(fn, 'ontrailers');
-      this.#ontrailers = FunctionPrototypeBind(fn, this);
+      this.#inner.ontrailers = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get onwanttrailers() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#onwanttrailers;
+    return this.#inner.onwanttrailers;
   }
 
   set onwanttrailers(fn) {
     QuicStream.#assertIsQuicStream(this);
     if (fn === undefined) {
-      this.#onwanttrailers = undefined;
-      this.#state[kWantsTrailers] = false;
+      this.#inner.onwanttrailers = undefined;
+      this.#inner.state[kWantsTrailers] = false;
     } else {
       this.#assertHeadersSupported();
       validateFunction(fn, 'onwanttrailers');
-      this.#onwanttrailers = FunctionPrototypeBind(fn, this);
-      this.#state[kWantsTrailers] = true;
+      this.#inner.onwanttrailers = FunctionPrototypeBind(fn, this);
+      this.#inner.state[kWantsTrailers] = true;
     }
   }
 
@@ -1710,7 +1690,7 @@ class QuicStream {
    */
   get headers() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#headers;
+    return this.#inner.headers;
   }
 
   /**
@@ -1719,21 +1699,21 @@ class QuicStream {
    */
   get pendingTrailers() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#pendingTrailers;
+    return this.#inner.pendingTrailers;
   }
 
   set pendingTrailers(headers) {
     QuicStream.#assertIsQuicStream(this);
     if (headers === undefined) {
-      this.#pendingTrailers = undefined;
+      this.#inner.pendingTrailers = undefined;
       return;
     }
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
     validateObject(headers, 'headers');
-    this.#pendingTrailers = headers;
+    this.#inner.pendingTrailers = headers;
   }
 
   /**
@@ -1742,7 +1722,11 @@ class QuicStream {
    */
   get stats() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#stats;
+    if (this.#inner.stats === undefined) {
+      this.#inner.stats = new QuicStreamStats(
+        kPrivateConstructor, this.#handle.stats, this.#handle.statsByteOffset);
+    }
+    return this.#inner.stats;
   }
 
   /**
@@ -1753,7 +1737,7 @@ class QuicStream {
   get session() {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed) return null;
-    return this.#session;
+    return this.#inner.session;
   }
 
   /**
@@ -1764,7 +1748,7 @@ class QuicStream {
   get id() {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed || this.pending) return null;
-    return this.#state.id;
+    return this.#inner.state.id;
   }
 
   /**
@@ -1775,7 +1759,7 @@ class QuicStream {
   get direction() {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed || this.pending) return null;
-    return this.#direction === kStreamDirectionBidirectional ? 'bidi' : 'uni';
+    return this.#inner.direction === kStreamDirectionBidirectional ? 'bidi' : 'uni';
   }
 
   /**
@@ -1793,7 +1777,10 @@ class QuicStream {
    */
   get closed() {
     QuicStream.#assertIsQuicStream(this);
-    return this.#pendingClose.promise;
+    if (this.#inner.pendingClose === undefined) {
+      this.#inner.pendingClose = PromiseWithResolvers();
+    }
+    return this.#inner.pendingClose.promise;
   }
 
   /**
@@ -1829,7 +1816,7 @@ class QuicStream {
     //     `onStreamClose -> [kFinishClose]` path - which does NOT go
     //     through `destroy()` and therefore never sets `#destroying`.
     //     `[kFinishClose]` clears `#handle` at the end of its work.
-    if (this.#destroying || this.destroyed) return;
+    if (this.#inner.destroying || this.destroyed) return;
     // Validate options up front so a malformed `options` argument
     // throws before any side effects (mutating `#destroying`,
     // emitting wire frames, invoking `onerror`, settling the closed
@@ -1845,7 +1832,7 @@ class QuicStream {
     if (reason !== undefined) {
       validateString(reason, 'options.reason');
     }
-    this.#destroying = true;
+    this.#inner.destroying = true;
     // Resolve the wire error code for any RESET_STREAM / STOP_SENDING
     // frames emitted below.
     let abortCode;
@@ -1854,21 +1841,16 @@ class QuicStream {
     } else if (error !== undefined) {
       abortCode = error instanceof QuicError ?
         error.errorCode :
-        getQuicSessionState(this.#session).internalErrorCode;
+        getQuicSessionState(this.#inner.session).internalErrorCode;
     }
     // When destroying with an error, ensure the peer stops sending
     // data we are about to discard by emitting STOP_SENDING. The
     // condition gates the emission to error-path destroys with a
-    // still-open readable side. Direction model for the readable
-    // side:
-    //   * bidi: always has a readable side.
-    //   * uni + #reader !== undefined: remote-initiated, read-only.
-    //   * uni + #reader === undefined: locally-initiated, write-only;
-    //     no readable side to stop.
+    // still-open readable side. The C++ state.readEnded flag is
+    // authoritative -- it is set for locally-initiated uni streams
+    // (which have no readable side) and when reading completes.
     if (abortCode !== undefined &&
-        !this.#state.readEnded &&
-        (this.#direction === kStreamDirectionBidirectional ||
-         this.#reader !== undefined)) {
+        !this.#inner.state.readEnded) {
       this.#handle.stopSending(abortCode);
     }
     // When destroying with an error, ensure the peer learns about
@@ -1877,22 +1859,14 @@ class QuicStream {
     // streams that destroy without ever accessing stream.writer
     // (e.g. used setBody or never wrote at all) need an explicit
     // RESET_STREAM here so the write side does not dangle on the
-    // wire. The condition gates the emission to error-path destroys
-    // with a still-open writable side.
-    // Direction model for the writable side:
-    //   * bidi: always has a writable side.
-    //   * uni + #reader === undefined: locally-initiated, write-only.
-    //   * uni + #reader !== undefined: remote-initiated, read-only;
-    //     no writable side to reset.
+    // wire. The C++ state.writeEnded flag is authoritative.
     if (abortCode !== undefined &&
-        this.#writer === undefined &&
-        !this.#state.writeEnded &&
-        (this.#direction === kStreamDirectionBidirectional ||
-         this.#reader === undefined)) {
+        this.#inner.writer === undefined &&
+        !this.#inner.state.writeEnded) {
       this.#handle.resetStream(abortCode);
     }
-    if (error !== undefined && typeof this.#onerror === 'function') {
-      invokeOnerror(this.#onerror, error);
+    if (error !== undefined && typeof this.#inner.onerror === 'function') {
+      invokeOnerror(this.#inner.onerror, error);
     }
     const handle = this.#handle;
     this[kFinishClose](error);
@@ -1912,7 +1886,7 @@ class QuicStream {
     if (this.destroyed) {
       throw new ERR_INVALID_STATE('Stream is destroyed');
     }
-    if (this.#state.hasOutbound) {
+    if (this.#inner.state.hasOutbound) {
       throw new ERR_INVALID_STATE('Stream already has an outbound data source');
     }
     this.#handle.attachSource(validateBody(outbound));
@@ -1928,7 +1902,7 @@ class QuicStream {
   sendHeaders(headers, options = kEmptyObject) {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed) return false;
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
@@ -1949,7 +1923,7 @@ class QuicStream {
   sendInformationalHeaders(headers) {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed) return false;
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
@@ -1970,7 +1944,7 @@ class QuicStream {
   sendTrailers(headers) {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed) return false;
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
@@ -1988,8 +1962,8 @@ class QuicStream {
    */
   get writer() {
     QuicStream.#assertIsQuicStream(this);
-    if (this.#writer !== undefined) return this.#writer;
-    if (this.#outboundSet) {
+    if (this.#inner.writer !== undefined) return this.#inner.writer;
+    if (this.#inner.outboundSet) {
       throw new ERR_INVALID_STATE(
         'Stream outbound already configured with a body source');
     }
@@ -2020,7 +1994,7 @@ class QuicStream {
       // more data. Refuse the sync write.
       // If a drain is already pending, another operation is waiting
       // for capacity. Refuse the sync write.
-      if (closed || errored || stream.#state.writeEnded || drainWakeup != null) {
+      if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
         return false;
       }
       chunk = toUint8Array(chunk);
@@ -2034,7 +2008,7 @@ class QuicStream {
       // at which point the standard drain mechanism takes over.
       // This follows the Web Streams model where writes beyond the HWM
       // succeed and backpressure applies to *subsequent* writes.
-      if (stream.#state.writeDesiredSize === 0) return false;
+      if (stream.#inner.state.writeDesiredSize === 0) return false;
       const result = handle.write([chunk]);
       if (result === undefined) return false;
       totalBytesWritten += len;
@@ -2049,7 +2023,7 @@ class QuicStream {
         signal.throwIfAborted();
       }
       if (errored) throw error;
-      if (closed || stream.#state.writeEnded) {
+      if (closed || stream.#inner.state.writeEnded) {
         throw new ERR_INVALID_STATE('Writer is closed');
       }
       // If a drain is already pending, another operation is waiting
@@ -2066,14 +2040,14 @@ class QuicStream {
     }
 
     function writevSync(chunks) {
-      if (closed || errored || stream.#state.writeEnded || drainWakeup != null) {
+      if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
         return false;
       }
       chunks = convertChunks(chunks);
       let len = 0;
       for (const c of chunks) len += TypedArrayPrototypeGetByteLength(c);
       if (len === 0) return true;
-      if (stream.#state.writeDesiredSize === 0) return false;
+      if (stream.#inner.state.writeDesiredSize === 0) return false;
       const result = handle.write(chunks);
       if (result === undefined) return false;
       totalBytesWritten += len;
@@ -2089,7 +2063,7 @@ class QuicStream {
       }
 
       if (errored) throw error;
-      if (closed || stream.#state.writeEnded) {
+      if (closed || stream.#inner.state.writeEnded) {
         throw new ERR_INVALID_STATE('Writer is closed');
       }
 
@@ -2182,7 +2156,7 @@ class QuicStream {
       //      `INTERNAL_ERROR` (0x1).
       const code = error instanceof QuicError ?
         error.errorCode :
-        getQuicSessionState(stream.#session).internalErrorCode;
+        getQuicSessionState(stream.#inner.session).internalErrorCode;
       handle.resetStream(code);
       if (drainWakeup != null) {
         drainWakeup.reject(error);
@@ -2193,8 +2167,8 @@ class QuicStream {
     const writer = {
       __proto__: null,
       get desiredSize() {
-        if (closed || errored || stream.#state.writeEnded) return null;
-        return stream.#state.writeDesiredSize;
+        if (closed || errored || stream.#inner.state.writeEnded) return null;
+        return stream.#inner.state.writeDesiredSize;
       },
       writeSync,
       write,
@@ -2207,7 +2181,7 @@ class QuicStream {
         if (closed || errored) return null;
         // If a drain is already pending, return the existing promise.
         if (drainWakeup != null) return drainWakeup.promise;
-        if (stream.#state.writeDesiredSize > 0) return null;
+        if (stream.#inner.state.writeDesiredSize > 0) return null;
         drainWakeup = PromiseWithResolvers();
         return drainWakeup.promise;
       },
@@ -2221,21 +2195,23 @@ class QuicStream {
     };
 
     // Non-writable stream - return a pre-closed writer.
-    // A readable unidirectional stream is a remote uni (read-only).
-    if (!handle || this.destroyed || this.#state.writeEnded ||
-        (this.#direction === kStreamDirectionUnidirectional &&
-         this.#reader !== undefined)) {
+    // A remote unidirectional stream is read-only and has no writable
+    // side. isLocal distinguishes locally-initiated (writable) from
+    // remotely-initiated (read-only) uni streams.
+    if (!handle || this.destroyed || this.#inner.state.writeEnded ||
+        (this.#inner.direction === kStreamDirectionUnidirectional &&
+         !this.#inner.isLocal)) {
       closed = true;
-      this.#writer = writer;
-      return this.#writer;
+      this.#inner.writer = writer;
+      return this.#inner.writer;
     }
 
     // Initialize the outbound DataQueue for streaming writes
     handle.initStreamingSource();
     initStreamingBackpressure(this);
 
-    this.#writer = writer;
-    return this.#writer;
+    this.#inner.writer = writer;
+    return this.#inner.writer;
   }
 
   /**
@@ -2249,17 +2225,17 @@ class QuicStream {
     if (this.destroyed) {
       throw new ERR_INVALID_STATE('Stream is destroyed');
     }
-    if (this.#outboundSet) {
+    if (this.#inner.outboundSet) {
       throw new ERR_INVALID_STATE('Stream outbound already configured');
     }
-    if (this.#writer !== undefined) {
+    if (this.#inner.writer !== undefined) {
       throw new ERR_INVALID_STATE('Stream writer already accessed');
     }
-    this.#outboundSet = true;
+    this.#inner.outboundSet = true;
     // If the body is a FileHandle, store it so it is closed
     // automatically when the stream finishes.
     if (body instanceof FileHandle) {
-      this.#fileHandle = body;
+      this.#inner.fileHandle = body;
     }
     configureOutbound(this.#handle, this, body);
   }
@@ -2271,7 +2247,7 @@ class QuicStream {
    * @param {FileHandle} fh
    */
   [kAttachFileHandle](fh) {
-    this.#fileHandle = fh;
+    this.#inner.fileHandle = fh;
   }
 
   /**
@@ -2309,7 +2285,7 @@ class QuicStream {
   get priority() {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed ||
-        !getQuicSessionState(this.#session).isPrioritySupported) return null;
+        !getQuicSessionState(this.#inner.session).isPrioritySupported) return null;
     const packed = this.#handle.getPriority();
     const urgency = packed >> 1;
     const incremental = !!(packed & 1);
@@ -2327,7 +2303,7 @@ class QuicStream {
   setPriority(options = kEmptyObject) {
     QuicStream.#assertIsQuicStream(this);
     if (this.destroyed) return;
-    if (!getQuicSessionState(this.#session).isPrioritySupported) {
+    if (!getQuicSessionState(this.#inner.session).isPrioritySupported) {
       throw new ERR_INVALID_STATE(
         'The session does not support stream priority');
     }
@@ -2357,7 +2333,7 @@ class QuicStream {
   [kSendHeaders](headers, kind = kHeadersKindInitial,
                  flags = kHeadersFlagsTerminal) {
     validateObject(headers, 'headers');
-    if (getQuicSessionState(this.#session).headersSupported === 2) {
+    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
         'The negotiated QUIC application protocol does not support headers');
     }
@@ -2375,27 +2351,21 @@ class QuicStream {
   }
 
   [kFinishClose](error) {
-    if (this.destroyed) return this.#pendingClose.promise;
+    this.#inner.pendingClose ??= PromiseWithResolvers();
+    if (this.destroyed) {
+      return this.#inner.pendingClose.promise;
+    }
     if (error !== undefined) {
-      if (this.pending) {
-        debug(`destroying pending stream with error: ${error}`);
-      } else {
-        debug(`destroying stream ${this.id} with error: ${error}`);
-      }
-      this.#pendingClose.reject(error);
+      this.#inner.pendingClose.reject(error);
     } else {
-      if (this.pending) {
-        debug('destroying pending stream with no error');
-      } else {
-        debug(`destroying stream ${this.id} with no error`);
-      }
-      this.#pendingClose.resolve();
+      this.#inner.pendingClose.resolve();
     }
+    debug('stream closed');
     if (onStreamClosedChannel.hasSubscribers) {
       onStreamClosedChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#session,
+        session: this.#inner.session,
         error,
         stats: this.stats,
       });
@@ -2408,46 +2378,44 @@ class QuicStream {
         },
       });
     }
-    this.#stats[kFinishClose]();
-    this.#state[kFinishClose]();
-    this.#session[kRemoveStream](this);
-    if (this.#writer !== undefined) {
-      this.#writer.fail(error);
-    }
-    this.#session = undefined;
-    this.#pendingClose.reject = undefined;
-    this.#pendingClose.resolve = undefined;
-    this.#onblocked = undefined;
-    this.#onreset = undefined;
-    this.#onheaders = undefined;
-    this.#onerror = undefined;
-    this.#ontrailers = undefined;
-    this.#oninfo = undefined;
-    this.#onwanttrailers = undefined;
-    this.#headers = undefined;
-    this.#pendingTrailers = undefined;
+    this.#inner.stats?.[kFinishClose]();
+    this.#inner.state?.[kFinishClose]();
+    this.#inner.session[kRemoveStream](this);
+    this.#inner.writer?.fail(error);
+    this.#inner.session = undefined;
+    this.#inner.pendingClose.reject = undefined;
+    this.#inner.pendingClose.resolve = undefined;
+    this.#inner.onblocked = undefined;
+    this.#inner.onreset = undefined;
+    this.#inner.onheaders = undefined;
+    this.#inner.onerror = undefined;
+    this.#inner.ontrailers = undefined;
+    this.#inner.oninfo = undefined;
+    this.#inner.onwanttrailers = undefined;
+    this.#inner.headers = undefined;
+    this.#inner.pendingTrailers = undefined;
     this.#handle = undefined;
-    if (this.#fileHandle !== undefined) {
+    if (this.#inner.fileHandle !== undefined) {
       // Close the FileHandle that was used as a body source. The close
       // may fail if the user already closed it -- that's expected and
       // harmless, so mark the promise as handled.
-      markPromiseAsHandled(this.#fileHandle.close());
-      this.#fileHandle = undefined;
+      markPromiseAsHandled(this.#inner.fileHandle.close());
+      this.#inner.fileHandle = undefined;
     }
   }
 
   [kBlocked]() {
     // The blocked event should only be called if the stream was created with
     // an onblocked callback. The callback should always exist here.
-    assert(this.#onblocked, 'Unexpected stream blocked event');
+    assert(this.#inner.onblocked, 'Unexpected stream blocked event');
     if (onStreamBlockedChannel.hasSubscribers) {
       onStreamBlockedChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#session,
+        session: this.#inner.session,
       });
     }
-    safeCallbackInvoke(this.#onblocked, this);
+    safeCallbackInvoke(this.#inner.onblocked, this);
   }
 
   [kDrain]() {
@@ -2458,16 +2426,16 @@ class QuicStream {
   [kReset](error) {
     // The reset event should only be called if the stream was created with
     // an onreset callback. The callback should always exist here.
-    assert(this.#onreset, 'Unexpected stream reset event');
+    assert(this.#inner.onreset, 'Unexpected stream reset event');
     if (onStreamResetChannel.hasSubscribers) {
       onStreamResetChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#session,
+        session: this.#inner.session,
         error,
       });
     }
-    safeCallbackInvoke(this.#onreset, this, error);
+    safeCallbackInvoke(this.#inner.onreset, this, error);
   }
 
   [kHeaders](headers, kind) {
@@ -2476,41 +2444,41 @@ class QuicStream {
 
     switch (kindName) {
       case 'initial':
-        assert(this.#onheaders, 'Unexpected stream headers event');
-        if (this.#headers === undefined) this.#headers = block;
+        assert(this.#inner.onheaders, 'Unexpected stream headers event');
+        this.#inner.headers ??= block;
         if (onStreamHeadersChannel.hasSubscribers) {
           onStreamHeadersChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#session,
+            session: this.#inner.session,
             headers: block,
           });
         }
-        safeCallbackInvoke(this.#onheaders, this, block);
+        safeCallbackInvoke(this.#inner.onheaders, this, block);
         break;
       case 'trailing':
         if (onStreamTrailersChannel.hasSubscribers) {
           onStreamTrailersChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#session,
+            session: this.#inner.session,
             trailers: block,
           });
         }
-        if (this.#ontrailers)
-          safeCallbackInvoke(this.#ontrailers, this, block);
+        if (this.#inner.ontrailers)
+          safeCallbackInvoke(this.#inner.ontrailers, this, block);
         break;
       case 'hints':
         if (onStreamInfoChannel.hasSubscribers) {
           onStreamInfoChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#session,
+            session: this.#inner.session,
             headers: block,
           });
         }
-        if (this.#oninfo)
-          safeCallbackInvoke(this.#oninfo, this, block);
+        if (this.#inner.oninfo)
+          safeCallbackInvoke(this.#inner.oninfo, this, block);
         break;
     }
   }
@@ -2520,11 +2488,11 @@ class QuicStream {
 
     // nghttp3 is asking us to provide trailers to send.
     // Check for pre-set pendingTrailers first, then the callback.
-    if (this.#pendingTrailers) {
-      this.sendTrailers(this.#pendingTrailers);
-      this.#pendingTrailers = undefined;
-    } else if (this.#onwanttrailers) {
-      safeCallbackInvoke(this.#onwanttrailers, this);
+    if (this.#inner.pendingTrailers) {
+      this.sendTrailers(this.#inner.pendingTrailers);
+      this.#inner.pendingTrailers = undefined;
+    } else if (this.#inner.onwanttrailers) {
+      safeCallbackInvoke(this.#inner.onwanttrailers, this);
     }
   }
 
@@ -2544,7 +2512,7 @@ class QuicStream {
       direction: this.direction,
       pending: this.pending,
       stats: this.stats,
-      state: this.#state,
+      state: this.#inner.state,
       session: this.session,
     }, opts)}`;
   }
@@ -3071,7 +3039,8 @@ class QuicSession {
       handle.setPriority((urgency << 1) | (incremental ? 1 : 0));
     }
 
-    const stream = new QuicStream(kPrivateConstructor, handle, this, direction);
+    const stream = new QuicStream(
+      kPrivateConstructor, handle, this, direction, true /* isLocal */);
     this.#streams.add(stream);
     if (typeof this.#onerror === 'function') {
       markPromiseAsHandled(stream.closed);

From fb49d3695629b5e58278fbe0e5d1e0cdf9fec6be Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 12:47:09 -0700
Subject: [PATCH 58/83] quic: improve the quic js structure

* Adds invalid this protections in the stats classes
* Collects internal private fields into a single private symbol
  to reduce the number of private field accesses
* Adds and corrects isQuic* class checks
* Preserve stream id and direction after destroy
* Improve stats close snapshotting
* Fixes a handful of other bugs and doc issues

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/fs/promises.js                   |    6 +
 lib/internal/quic/quic.js                     | 1433 +++++++++--------
 lib/internal/quic/state.js                    |  633 +++++---
 lib/internal/quic/stats.js                    |  531 ++++--
 lib/internal/quic/symbols.js                  |    4 -
 src/quic/session.cc                           |    2 +
 src/quic/streams.cc                           |    2 +
 .../parallel/test-quic-h3-headers-support.mjs |   43 +-
 ...est-quic-internal-endpoint-stats-state.mjs |    2 +-
 .../test-quic-session-stream-lifecycle.mjs    |    7 +-
 10 files changed, 1549 insertions(+), 1114 deletions(-)

diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 720bd1319b381f..0aa01d9b39dc3e 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -178,6 +178,12 @@ function handleErrorFromBinding(error) {
 }
 
 class FileHandle extends EventEmitter {
+  #brandCheck = undefined;
+
+  static isFileHandle(value) {
+    return (value != null && typeof value === 'object' && #brandCheck in value);
+  }
+
   /**
    * @param {InternalFSBinding.FileHandle | undefined} filehandle
    */
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 6082226edf4d9d..0ae04441ea19ce 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -203,14 +203,13 @@ const {
   kTrailers,
   kVersionNegotiation,
   kInspect,
-  kWantsHeaders,
-  kWantsTrailers,
 } = require('internal/quic/symbols');
 
 const {
   QuicEndpointStats,
   QuicStreamStats,
   QuicSessionStats,
+  kCreateDisconnected,
 } = require('internal/quic/stats');
 
 const {
@@ -464,6 +463,51 @@ const endpointRegistry = new SafeSet();
  * @property {string} [validationErrorCode] The error code for the validation failure (if any)
  */
 
+/**
+ * @typedef {object} QuicStreamDestroyOptions
+ * @property {bigint|number} [code] An explicit application
+ *   error code to send on the resulting `RESET_STREAM` /
+ *   `STOP_SENDING` frames. Numbers are coerced to `BigInt`. When
+ *   omitted, the code is derived from `error` per the precedence
+ *   above.
+ * @property {string} [reason] Optional human-readable reason.
+ *   Accepted for symmetry with `session.close()` /
+ *   `session.destroy()`; QUIC `RESET_STREAM` and `STOP_SENDING`
+ *   frames do not themselves carry a reason field over the wire.
+ */
+
+/**
+ * @typedef {object} SendHeadersOptions
+ * @property {boolean} [terminal] When true, indicates that no body data will be
+ *   sent after these headers.
+ */
+
+/**
+ * @typedef {object} StreamPriority
+ * @property {'default' | 'low' | 'high'} level The priority level of the stream.
+ * @property {boolean} incremental Whether to interleave data with same-priority streams.
+ */
+
+/**
+ * @typedef {object} QuicSessionPath
+ * @property {SocketAddress} local The local address for this path
+ * @property {SocketAddress} remote The remote address for this path
+ */
+
+/**
+ * @typedef {object} SNIContextOptions
+ * @property {boolean} [replace] When `true`, the provided SNI context will replace
+ *   the default context for the session. When `false` (default), the provided
+ *   context will be merged with the default context, with precedence given to
+ *   the provided context on any overlapping options.
+ */
+
+/**
+ * @typedef {object} ProcessSessionOptions
+ * @property {boolean} forServer true if processing options for a server session
+ * @property {string} addressFamily the address family to use for validating
+ */
+
 /**
  * Called when the Endpoint receives a new server-side Session.
  * @callback OnSessionCallback
@@ -658,7 +702,7 @@ setCallbacks({
   },
   /**
    * Called when the QuicEndpoint C++ handle receives a new server-side session
-   * @param {*} session The QuicSession C++ handle
+   * @param {object} session The QuicSession C++ handle
    */
   onSessionNew(session) {
     debug('new server session callback', this[kOwner], session);
@@ -792,9 +836,9 @@ setCallbacks({
 
   /**
    * Called when the session receives a session version negotiation request
-   * @param {*} version
-   * @param {*} requestedVersions
-   * @param {*} supportedVersions
+   * @param {number} version
+   * @param {number[]} requestedVersions
+   * @param {number[]} supportedVersions
    */
   onSessionVersionNegotiation(version,
                               requestedVersions,
@@ -885,6 +929,12 @@ setCallbacks({
   },
 });
 
+function assertPrivateSymbol(privateSymbol) {
+  if (privateSymbol !== kPrivateConstructor) {
+    throw new ERR_ILLEGAL_CONSTRUCTOR();
+  }
+}
+
 // QUIC error codes are 62-bit varints (RFC 9000 section 16). The
 // maximum representable code is 2**62 - 1.
 const kMaxQuicErrorCode = (1n << 62n) - 1n;
@@ -911,6 +961,10 @@ class QuicError extends Error {
   /** @type {'transport' | 'application'} */
   #type;
 
+  static isQuicError(val) {
+    return val != null && typeof val === 'object' && #errorCode in val;
+  }
+
   /**
    * @param {string} message
    * @param {object} options
@@ -1089,7 +1143,7 @@ function validateBody(body) {
 
   // FileHandle -- lock it and pass the C++ handle to GetDataQueueFromSource
   // which creates an fd-backed DataQueue entry from the file path.
-  if (body instanceof FileHandle) {
+  if (FileHandle.isFileHandle(body)) {
     if (body[kFileLocked]) {
       throw new ERR_INVALID_STATE('FileHandle is locked');
     }
@@ -1166,7 +1220,7 @@ function applyCallbacks(session, cbs) {
  * type and calls the appropriate C++ method.
  * @param {object} handle The C++ stream handle
  * @param {QuicStream} stream The JS stream object
- * @param {*} body The body source
+ * @param {any} body The body source
  */
 const kDefaultHighWaterMark = 65536;
 const kDefaultMaxPendingDatagrams = 128;
@@ -1208,7 +1262,7 @@ function configureOutbound(handle, stream, body) {
   // DataQueue entry from the file path. The FileHandle is locked to
   // prevent concurrent use and closed automatically when the stream
   // finishes.
-  if (body instanceof FileHandle) {
+  if (FileHandle.isFileHandle(body)) {
     if (body[kFileLocked]) {
       throw new ERR_INVALID_STATE('FileHandle is locked');
     }
@@ -1363,8 +1417,14 @@ let getQuicStreamState;
 let getQuicSessionState;
 let getQuicEndpointState;
 let assertIsQuicEndpoint;
+let assertIsQuicStream;
+let assertIsQuicSession;
+let assertHeadersSupported;
 let assertEndpointNotClosedOrClosing;
 let assertEndpointIsNotBusy;
+let isQuicStream;
+let isQuicSession;
+let isQuicEndpoint;
 
 function maybeGetCloseError(context, status, pendingError) {
   switch (context) {
@@ -1391,31 +1451,54 @@ function maybeGetCloseError(context, status, pendingError) {
 }
 
 class QuicStream {
-  // All mutable per-stream state is consolidated into a single object
-  // to minimize the number of V8 private field slots. Only #handle is
-  // kept as a private field for the brand check in #assertIsQuicStream.
-  /** @type {object} */
   #handle;
-  #inner;
+  #inner = {
+    __proto__: null,
+    session: undefined,
+    direction: undefined,
+    isLocal: false,
+    state: undefined,
+    stats: undefined,
+    pendingClose: undefined,
+    reader: undefined,
+    destroying: false,
+    iteratorLocked: false,
+    outboundSet: false,
+    writer: undefined,
+    fileHandle: undefined,
+    headers: undefined,
+    pendingTrailers: undefined,
+    onerror: undefined,
+    onblocked: undefined,
+    onreset: undefined,
+    onheaders: undefined,
+    ontrailers: undefined,
+    oninfo: undefined,
+    onwanttrailers: undefined,
+  };
 
   static {
-    getQuicStreamState = function(stream) {
-      QuicStream.#assertIsQuicStream(stream);
-      return stream.#inner.state;
+    isQuicStream = function(val) {
+      return val != null && typeof val === 'object' && #handle in val;
     };
-  }
 
-  static #assertIsQuicStream(val) {
-    if (val == null || !(#handle in val)) {
-      throw new ERR_INVALID_THIS('QuicStream');
-    }
-  }
+    assertIsQuicStream = function(val) {
+      if (!isQuicStream(val)) {
+        throw new ERR_INVALID_THIS('QuicStream');
+      }
+    };
 
-  #assertHeadersSupported() {
-    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
-      throw new ERR_INVALID_STATE(
-        'The negotiated QUIC application protocol does not support headers');
-    }
+    assertHeadersSupported = function(session) {
+      if (getQuicSessionState(session).headersSupported === 2) {
+        throw new ERR_INVALID_STATE(
+          'The negotiated QUIC application protocol does not support headers');
+      }
+    };
+
+    getQuicStreamState = function(stream) {
+      assertIsQuicStream(stream);
+      return stream.#inner.state;
+    };
   }
 
   /**
@@ -1423,41 +1506,19 @@ class QuicStream {
    * @param {object} handle
    * @param {QuicSession} session
    * @param {number} direction
-   * @param {boolean} [isLocal] True for locally-initiated streams
+   * @param {boolean} [isLocal]
    */
-  constructor(privateSymbol, handle, session, direction, isLocal = false) {
-    if (privateSymbol !== kPrivateConstructor) {
-      throw new ERR_ILLEGAL_CONSTRUCTOR();
-    }
+  constructor(privateSymbol, handle, session, direction, isLocal) {
+    assertPrivateSymbol(privateSymbol);
 
     this.#handle = handle;
     handle[kOwner] = this;
-    this.#inner = {
-      __proto__: null,
-      session,
-      direction,
-      isLocal,
-      state: new QuicStreamState(
-        kPrivateConstructor, handle.state, handle.stateByteOffset),
-      stats: undefined,
-      pendingClose: undefined,
-      reader: undefined,
-      destroying: false,
-      iteratorLocked: false,
-      outboundSet: false,
-      writer: undefined,
-      fileHandle: undefined,
-      headers: undefined,
-      pendingTrailers: undefined,
-      // Callback slots
-      onerror: undefined,
-      onblocked: undefined,
-      onreset: undefined,
-      onheaders: undefined,
-      ontrailers: undefined,
-      oninfo: undefined,
-      onwanttrailers: undefined,
-    };
+    const inner = this.#inner;
+    inner.session = session;
+    inner.direction = direction;
+    inner.isLocal = isLocal;
+    inner.state = new QuicStreamState(
+      kPrivateConstructor, handle.state, handle.stateByteOffset);
 
     if (hasObserver('quic')) {
       startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicStream' });
@@ -1475,17 +1536,18 @@ class QuicStream {
    * @yields {Uint8Array[]}
    */
   async *[SymbolAsyncIterator]() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.#inner.iteratorLocked) {
+    assertIsQuicStream(this);
+    const inner = this.#inner;
+    if (inner.iteratorLocked) {
       throw new ERR_INVALID_STATE('Stream is already being read');
     }
-    this.#inner.iteratorLocked = true;
+    inner.iteratorLocked = true;
 
-    this.#inner.reader ??= this.#handle?.getReader();
+    inner.reader ??= this.#handle?.getReader();
     // Non-readable stream (outbound-only unidirectional, or closed)
-    if (!this.#inner.reader) return;
+    if (!inner.reader) return;
 
-    yield* createBlobReaderIterable(this.#inner.reader, {
+    yield* createBlobReaderIterable(inner.reader, {
       getReadError: () => {
         // The read side ends for one of three reasons:
         //   * Clean FIN received from the peer (state.finReceived
@@ -1499,8 +1561,8 @@ class QuicStream {
         //     stream.stopSending(). Both paths run EndReadable in
         //     C++, setting state.readEnded without setting
         //     state.finReceived. There is no peer code to surface.
-        if (this.#inner.state.readEnded && !this.#inner.state.finReceived) {
-          const peerResetCode = this.#inner.state.resetCode;
+        if (inner.state.readEnded && !inner.state.finReceived) {
+          const peerResetCode = inner.state.resetCode;
           if (peerResetCode !== undefined && peerResetCode > 0n) {
             return new ERR_QUIC_STREAM_RESET(Number(peerResetCode));
           }
@@ -1518,7 +1580,7 @@ class QuicStream {
    * @type {boolean}
    */
   get pending() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.state.pending;
   }
 
@@ -1529,7 +1591,7 @@ class QuicStream {
    * @type {boolean}
    */
   get early() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.state.early;
   }
 
@@ -1540,145 +1602,153 @@ class QuicStream {
    * @type {number}
    */
   get highWaterMark() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.state.highWaterMark;
   }
 
   set highWaterMark(val) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     validateInteger(val, 'highWaterMark', 0, 0xFFFFFFFF);
-    this.#inner.state.highWaterMark = val;
+    const inner = this.#inner;
+    inner.state.highWaterMark = val;
     // If writeDesiredSize hasn't been set yet (still 0 from initialization),
     // initialize it to the highWaterMark so the first write can proceed.
-    if (this.#inner.state.writeDesiredSize === 0 && val > 0) {
-      this.#inner.state.writeDesiredSize = val;
+    if (inner.state.writeDesiredSize === 0 && val > 0) {
+      inner.state.writeDesiredSize = val;
     }
   }
 
   /** @type {Function|undefined} */
   get onerror() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.onerror;
   }
 
   set onerror(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.onerror = undefined;
+      inner.onerror = undefined;
     } else {
       validateFunction(fn, 'onerror');
-      this.#inner.onerror = FunctionPrototypeBind(fn, this);
+      inner.onerror = FunctionPrototypeBind(fn, this);
       // Lazily create the close promise so it can be marked handled.
-      this.#inner.pendingClose ??= PromiseWithResolvers();
-      markPromiseAsHandled(this.#inner.pendingClose.promise);
+      inner.pendingClose ??= PromiseWithResolvers();
+      markPromiseAsHandled(inner.pendingClose.promise);
     }
   }
 
   /** @type {OnBlockedCallback} */
   get onblocked() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.onblocked;
   }
 
   set onblocked(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.onblocked = undefined;
-      this.#inner.state.wantsBlock = false;
+      inner.onblocked = undefined;
+      inner.state.wantsBlock = false;
     } else {
       validateFunction(fn, 'onblocked');
-      this.#inner.onblocked = FunctionPrototypeBind(fn, this);
-      this.#inner.state.wantsBlock = true;
+      inner.onblocked = FunctionPrototypeBind(fn, this);
+      inner.state.wantsBlock = true;
     }
   }
 
   /** @type {OnStreamErrorCallback} */
   get onreset() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.onreset;
   }
 
   set onreset(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.onreset = undefined;
-      this.#inner.state.wantsReset = false;
+      inner.onreset = undefined;
+      inner.state.wantsReset = false;
     } else {
       validateFunction(fn, 'onreset');
-      this.#inner.onreset = FunctionPrototypeBind(fn, this);
-      this.#inner.state.wantsReset = true;
+      inner.onreset = FunctionPrototypeBind(fn, this);
+      inner.state.wantsReset = true;
     }
   }
 
   /** @type {OnHeadersCallback} */
   get onheaders() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.onheaders;
   }
 
   set onheaders(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.onheaders = undefined;
-      this.#inner.state[kWantsHeaders] = false;
+      inner.onheaders = undefined;
+      inner.state.wantsHeaders = false;
     } else {
-      this.#assertHeadersSupported();
       validateFunction(fn, 'onheaders');
-      this.#inner.onheaders = FunctionPrototypeBind(fn, this);
-      this.#inner.state[kWantsHeaders] = true;
+      assertHeadersSupported(inner.session);
+      inner.onheaders = FunctionPrototypeBind(fn, this);
+      inner.state.wantsHeaders = true;
     }
   }
 
   /** @type {Function|undefined} */
   get oninfo() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.oninfo;
   }
 
   set oninfo(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.oninfo = undefined;
+      inner.oninfo = undefined;
     } else {
-      this.#assertHeadersSupported();
       validateFunction(fn, 'oninfo');
-      this.#inner.oninfo = FunctionPrototypeBind(fn, this);
+      assertHeadersSupported(inner.session);
+      inner.oninfo = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get ontrailers() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.ontrailers;
   }
 
   set ontrailers(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.ontrailers = undefined;
+      inner.ontrailers = undefined;
     } else {
-      this.#assertHeadersSupported();
       validateFunction(fn, 'ontrailers');
-      this.#inner.ontrailers = FunctionPrototypeBind(fn, this);
+      assertHeadersSupported(inner.session);
+      inner.ontrailers = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get onwanttrailers() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.onwanttrailers;
   }
 
   set onwanttrailers(fn) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#inner.onwanttrailers = undefined;
-      this.#inner.state[kWantsTrailers] = false;
+      inner.onwanttrailers = undefined;
+      inner.state.wantsTrailers = false;
     } else {
-      this.#assertHeadersSupported();
       validateFunction(fn, 'onwanttrailers');
-      this.#inner.onwanttrailers = FunctionPrototypeBind(fn, this);
-      this.#inner.state[kWantsTrailers] = true;
+      assertHeadersSupported(inner.session);
+      inner.onwanttrailers = FunctionPrototypeBind(fn, this);
+      inner.state.wantsTrailers = true;
     }
   }
 
@@ -1689,7 +1759,7 @@ class QuicStream {
    * @type {object|undefined}
    */
   get headers() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.headers;
   }
 
@@ -1698,22 +1768,20 @@ class QuicStream {
    * @type {object|undefined}
    */
   get pendingTrailers() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#inner.pendingTrailers;
   }
 
   set pendingTrailers(headers) {
-    QuicStream.#assertIsQuicStream(this);
+    const inner = this.#inner;
+    assertIsQuicStream(this);
+    assertHeadersSupported(inner.session);
     if (headers === undefined) {
-      this.#inner.pendingTrailers = undefined;
+      inner.pendingTrailers = undefined;
       return;
     }
-    if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
-      throw new ERR_INVALID_STATE(
-        'The negotiated QUIC application protocol does not support headers');
-    }
     validateObject(headers, 'headers');
-    this.#inner.pendingTrailers = headers;
+    inner.pendingTrailers = headers;
   }
 
   /**
@@ -1721,12 +1789,12 @@ class QuicStream {
    * @type {QuicStreamStats}
    */
   get stats() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.#inner.stats === undefined) {
-      this.#inner.stats = new QuicStreamStats(
-        kPrivateConstructor, this.#handle.stats, this.#handle.statsByteOffset);
-    }
-    return this.#inner.stats;
+    assertIsQuicStream(this);
+    const inner = this.#inner;
+    const handle = this.#handle;
+    return inner.stats ??= (handle == null) ?
+      QuicStreamStats[kCreateDisconnected]() :
+      new QuicStreamStats(kPrivateConstructor, handle.stats, handle.statsByteOffset);
   }
 
   /**
@@ -1735,30 +1803,27 @@ class QuicStream {
    * @type {QuicSession | null}
    */
   get session() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.destroyed) return null;
+    assertIsQuicStream(this);
     return this.#inner.session;
   }
 
   /**
-   * Returns the id for this stream. If the stream is destroyed or still pending,
+   * Returns the id for this stream. If the stream is still pending,
    * `null` will be returned.
    * @type {bigint | null}
    */
   get id() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.destroyed || this.pending) return null;
+    assertIsQuicStream(this);
+    if (this.pending) return null;
     return this.#inner.state.id;
   }
 
   /**
-   * Returns the directionality of this stream. If the stream is destroyed
-   * or still pending, `null` will be returned.
-   * @type {'bidi'|'uni'|null}
+   * Returns the directionality of this stream.
+   * @type {'bidi'|'uni'}
    */
   get direction() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.destroyed || this.pending) return null;
+    assertIsQuicStream(this);
     return this.#inner.direction === kStreamDirectionBidirectional ? 'bidi' : 'uni';
   }
 
@@ -1767,7 +1832,7 @@ class QuicStream {
    * @type {boolean}
    */
   get destroyed() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     return this.#handle === undefined;
   }
 
@@ -1776,10 +1841,8 @@ class QuicStream {
    * @type {Promise<void>}
    */
   get closed() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.#inner.pendingClose === undefined) {
-      this.#inner.pendingClose = PromiseWithResolvers();
-    }
+    assertIsQuicStream(this);
+    this.#inner.pendingClose ??= PromiseWithResolvers();
     return this.#inner.pendingClose.promise;
   }
 
@@ -1794,19 +1857,11 @@ class QuicStream {
    * `QuicError`) -> the negotiated application's "internal error"
    * code from `QuicSessionState.internalErrorCode`.
    * @param {any} error
-   * @param {object} [options]
-   * @param {bigint|number} [options.code] An explicit application
-   *   error code to send on the resulting `RESET_STREAM` /
-   *   `STOP_SENDING` frames. Numbers are coerced to `BigInt`. When
-   *   omitted, the code is derived from `error` per the precedence
-   *   above.
-   * @param {string} [options.reason] Optional human-readable reason.
-   *   Accepted for symmetry with `session.close()` /
-   *   `session.destroy()`; QUIC `RESET_STREAM` and `STOP_SENDING`
-   *   frames do not themselves carry a reason field over the wire.
+   * @param {QuicStreamDestroyOptions} [options]
    */
   destroy(error, options = kEmptyObject) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
+    const inner = this.#inner;
     // Two distinct guards:
     //   * `#destroying` flips synchronously here so any re-entrant call
     //     from inside this method's user callbacks hits the guard and
@@ -1816,7 +1871,7 @@ class QuicStream {
     //     `onStreamClose -> [kFinishClose]` path - which does NOT go
     //     through `destroy()` and therefore never sets `#destroying`.
     //     `[kFinishClose]` clears `#handle` at the end of its work.
-    if (this.#inner.destroying || this.destroyed) return;
+    if (inner.destroying || this.destroyed) return;
     // Validate options up front so a malformed `options` argument
     // throws before any side effects (mutating `#destroying`,
     // emitting wire frames, invoking `onerror`, settling the closed
@@ -1832,16 +1887,16 @@ class QuicStream {
     if (reason !== undefined) {
       validateString(reason, 'options.reason');
     }
-    this.#inner.destroying = true;
+    inner.destroying = true;
     // Resolve the wire error code for any RESET_STREAM / STOP_SENDING
     // frames emitted below.
     let abortCode;
     if (optionCode !== undefined) {
       abortCode = BigInt(optionCode);
     } else if (error !== undefined) {
-      abortCode = error instanceof QuicError ?
+      abortCode = QuicError.isQuicError(error) ?
         error.errorCode :
-        getQuicSessionState(this.#inner.session).internalErrorCode;
+        getQuicSessionState(inner.session).internalErrorCode;
     }
     // When destroying with an error, ensure the peer stops sending
     // data we are about to discard by emitting STOP_SENDING. The
@@ -1850,7 +1905,7 @@ class QuicStream {
     // authoritative -- it is set for locally-initiated uni streams
     // (which have no readable side) and when reading completes.
     if (abortCode !== undefined &&
-        !this.#inner.state.readEnded) {
+        !inner.state.readEnded) {
       this.#handle.stopSending(abortCode);
     }
     // When destroying with an error, ensure the peer learns about
@@ -1861,12 +1916,12 @@ class QuicStream {
     // RESET_STREAM here so the write side does not dangle on the
     // wire. The C++ state.writeEnded flag is authoritative.
     if (abortCode !== undefined &&
-        this.#inner.writer === undefined &&
-        !this.#inner.state.writeEnded) {
+        inner.writer === undefined &&
+        !inner.state.writeEnded) {
       this.#handle.resetStream(abortCode);
     }
-    if (error !== undefined && typeof this.#inner.onerror === 'function') {
-      invokeOnerror(this.#inner.onerror, error);
+    if (error !== undefined && typeof inner.onerror === 'function') {
+      invokeOnerror(inner.onerror, error);
     }
     const handle = this.#handle;
     this[kFinishClose](error);
@@ -1882,7 +1937,7 @@ class QuicStream {
    * @param {ArrayBuffer|SharedArrayBuffer|ArrayBufferView|Blob} outbound
    */
   setOutbound(outbound) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) {
       throw new ERR_INVALID_STATE('Stream is destroyed');
     }
@@ -1893,14 +1948,12 @@ class QuicStream {
   }
 
   /**
-   * Send initial or response headers on this stream. Throws if the
-   * application does not support headers.
    * @param {object} headers
-   * @param {{ terminal?: boolean }} [options]
+   * @param {SendHeadersOptions} [options]
    * @returns {boolean}
    */
   sendHeaders(headers, options = kEmptyObject) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return false;
     if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
@@ -1909,7 +1962,7 @@ class QuicStream {
     validateObject(headers, 'headers');
     const { terminal = false } = options;
     const headerString = buildNgHeaderString(
-      headers, assertValidPseudoHeader, true);
+      headers, assertValidPseudoHeader, true /* strictSingleValueFields */);
     const flags = terminal ? kHeadersFlagsTerminal : kHeadersFlagsNone;
     return this.#handle.sendHeaders(kHeadersKindInitial, headerString, flags);
   }
@@ -1921,7 +1974,7 @@ class QuicStream {
    * @returns {boolean}
    */
   sendInformationalHeaders(headers) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return false;
     if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
@@ -1942,7 +1995,7 @@ class QuicStream {
    * @returns {boolean}
    */
   sendTrailers(headers) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return false;
     if (getQuicSessionState(this.#inner.session).headersSupported === 2) {
       throw new ERR_INVALID_STATE(
@@ -1961,9 +2014,10 @@ class QuicStream {
    * @type {object}
    */
   get writer() {
-    QuicStream.#assertIsQuicStream(this);
-    if (this.#inner.writer !== undefined) return this.#inner.writer;
-    if (this.#inner.outboundSet) {
+    assertIsQuicStream(this);
+    const inner = this.#inner;
+    if (inner.writer !== undefined) return inner.writer;
+    if (inner.outboundSet) {
       throw new ERR_INVALID_STATE(
         'Stream outbound already configured with a body source');
     }
@@ -2154,7 +2208,7 @@ class QuicStream {
       //      `H3_INTERNAL_ERROR` (0x102); for raw QUIC applications
       //      it falls back to the QUIC transport-layer
       //      `INTERNAL_ERROR` (0x1).
-      const code = error instanceof QuicError ?
+      const code = QuicError.isQuicError(error) ?
         error.errorCode :
         getQuicSessionState(stream.#inner.session).internalErrorCode;
       handle.resetStream(code);
@@ -2198,44 +2252,43 @@ class QuicStream {
     // A remote unidirectional stream is read-only and has no writable
     // side. isLocal distinguishes locally-initiated (writable) from
     // remotely-initiated (read-only) uni streams.
-    if (!handle || this.destroyed || this.#inner.state.writeEnded ||
-        (this.#inner.direction === kStreamDirectionUnidirectional &&
-         !this.#inner.isLocal)) {
+    if (!handle || this.destroyed || inner.state.writeEnded ||
+        (inner.direction === kStreamDirectionUnidirectional &&
+         !inner.isLocal)) {
       closed = true;
-      this.#inner.writer = writer;
-      return this.#inner.writer;
+      return inner.writer = writer;
     }
 
     // Initialize the outbound DataQueue for streaming writes
     handle.initStreamingSource();
     initStreamingBackpressure(this);
 
-    this.#inner.writer = writer;
-    return this.#inner.writer;
+    return inner.writer = writer;
   }
 
   /**
    * Sets the outbound body source for this stream. Accepts all body
    * source types (string, TypedArray, Blob, AsyncIterable, Promise, null).
    * Can only be called once. Mutually exclusive with stream.writer.
-   * @param {*} body
+   * @param {any} body
    */
   setBody(body) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) {
       throw new ERR_INVALID_STATE('Stream is destroyed');
     }
-    if (this.#inner.outboundSet) {
+    const inner = this.#inner;
+    if (inner.outboundSet) {
       throw new ERR_INVALID_STATE('Stream outbound already configured');
     }
-    if (this.#inner.writer !== undefined) {
+    if (inner.writer !== undefined) {
       throw new ERR_INVALID_STATE('Stream writer already accessed');
     }
-    this.#inner.outboundSet = true;
+    inner.outboundSet = true;
     // If the body is a FileHandle, store it so it is closed
     // automatically when the stream finishes.
-    if (body instanceof FileHandle) {
-      this.#inner.fileHandle = body;
+    if (FileHandle.isFileHandle(body)) {
+      inner.fileHandle = body;
     }
     configureOutbound(this.#handle, this, body);
   }
@@ -2258,7 +2311,7 @@ class QuicStream {
    * @param {number|bigint} code
    */
   stopSending(code = 0n) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return;
     this.#handle.stopSending(BigInt(code));
   }
@@ -2271,7 +2324,7 @@ class QuicStream {
    * @param {number|bigint} code
    */
   resetStream(code = 0n) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return;
     this.#handle.resetStream(BigInt(code));
   }
@@ -2280,10 +2333,10 @@ class QuicStream {
    * The priority of the stream. If the stream is destroyed or if
    * the session does not support priority, `null` will be
    * returned.
-   * @type {{ level: 'default' | 'low' | 'high', incremental: boolean } | null}
+   * @type {StreamPriority | null}
    */
   get priority() {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed ||
         !getQuicSessionState(this.#inner.session).isPrioritySupported) return null;
     const packed = this.#handle.getPriority();
@@ -2295,13 +2348,10 @@ class QuicStream {
 
   /**
    * Sets the priority of the stream.
-   * @param {{
-   *   level?: 'default' | 'low' | 'high',
-   *   incremental?: boolean,
-   * }} options
+   * @param {StreamPriority} [options]
    */
   setPriority(options = kEmptyObject) {
-    QuicStream.#assertIsQuicStream(this);
+    assertIsQuicStream(this);
     if (this.destroyed) return;
     if (!getQuicSessionState(this.#inner.session).isPrioritySupported) {
       throw new ERR_INVALID_STATE(
@@ -2351,21 +2401,22 @@ class QuicStream {
   }
 
   [kFinishClose](error) {
-    this.#inner.pendingClose ??= PromiseWithResolvers();
+    const inner = this.#inner;
+    inner.pendingClose ??= PromiseWithResolvers();
     if (this.destroyed) {
-      return this.#inner.pendingClose.promise;
+      return inner.pendingClose.promise;
     }
     if (error !== undefined) {
-      this.#inner.pendingClose.reject(error);
+      inner.pendingClose.reject(error);
     } else {
-      this.#inner.pendingClose.resolve();
+      inner.pendingClose.resolve();
     }
     debug('stream closed');
     if (onStreamClosedChannel.hasSubscribers) {
       onStreamClosedChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#inner.session,
+        session: inner.session,
         error,
         stats: this.stats,
       });
@@ -2378,44 +2429,45 @@ class QuicStream {
         },
       });
     }
-    this.#inner.stats?.[kFinishClose]();
-    this.#inner.state?.[kFinishClose]();
-    this.#inner.session[kRemoveStream](this);
-    this.#inner.writer?.fail(error);
-    this.#inner.session = undefined;
-    this.#inner.pendingClose.reject = undefined;
-    this.#inner.pendingClose.resolve = undefined;
-    this.#inner.onblocked = undefined;
-    this.#inner.onreset = undefined;
-    this.#inner.onheaders = undefined;
-    this.#inner.onerror = undefined;
-    this.#inner.ontrailers = undefined;
-    this.#inner.oninfo = undefined;
-    this.#inner.onwanttrailers = undefined;
-    this.#inner.headers = undefined;
-    this.#inner.pendingTrailers = undefined;
+    inner.stats?.[kFinishClose]();
+    inner.state?.[kFinishClose]();
+    inner.session[kRemoveStream](this);
+    inner.writer?.fail(error);
+    inner.session = undefined;
+    inner.pendingClose.reject = undefined;
+    inner.pendingClose.resolve = undefined;
+    inner.onblocked = undefined;
+    inner.onreset = undefined;
+    inner.onheaders = undefined;
+    inner.onerror = undefined;
+    inner.ontrailers = undefined;
+    inner.oninfo = undefined;
+    inner.onwanttrailers = undefined;
+    inner.headers = undefined;
+    inner.pendingTrailers = undefined;
     this.#handle = undefined;
-    if (this.#inner.fileHandle !== undefined) {
+    if (inner.fileHandle !== undefined) {
       // Close the FileHandle that was used as a body source. The close
       // may fail if the user already closed it -- that's expected and
       // harmless, so mark the promise as handled.
       markPromiseAsHandled(this.#inner.fileHandle.close());
-      this.#inner.fileHandle = undefined;
+      inner.fileHandle = undefined;
     }
   }
 
   [kBlocked]() {
+    const inner = this.#inner;
     // The blocked event should only be called if the stream was created with
     // an onblocked callback. The callback should always exist here.
-    assert(this.#inner.onblocked, 'Unexpected stream blocked event');
+    assert(inner.onblocked, 'Unexpected stream blocked event');
     if (onStreamBlockedChannel.hasSubscribers) {
       onStreamBlockedChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#inner.session,
+        session: inner.session,
       });
     }
-    safeCallbackInvoke(this.#inner.onblocked, this);
+    safeCallbackInvoke(inner.onblocked, this);
   }
 
   [kDrain]() {
@@ -2424,81 +2476,85 @@ class QuicStream {
   }
 
   [kReset](error) {
+    const inner = this.#inner;
     // The reset event should only be called if the stream was created with
     // an onreset callback. The callback should always exist here.
-    assert(this.#inner.onreset, 'Unexpected stream reset event');
+    assert(inner.onreset, 'Unexpected stream reset event');
     if (onStreamResetChannel.hasSubscribers) {
       onStreamResetChannel.publish({
         __proto__: null,
         stream: this,
-        session: this.#inner.session,
+        session: inner.session,
         error,
       });
     }
-    safeCallbackInvoke(this.#inner.onreset, this, error);
+    safeCallbackInvoke(inner.onreset, this, error);
   }
 
   [kHeaders](headers, kind) {
     const block = parseHeaderPairs(headers);
     const kindName = kHeadersKindName[kind] ?? kind;
+    const inner = this.#inner;
 
     switch (kindName) {
       case 'initial':
-        assert(this.#inner.onheaders, 'Unexpected stream headers event');
-        this.#inner.headers ??= block;
+        assert(inner.onheaders, 'Unexpected stream headers event');
+        inner.headers ??= block;
         if (onStreamHeadersChannel.hasSubscribers) {
           onStreamHeadersChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#inner.session,
+            session: inner.session,
             headers: block,
           });
         }
-        safeCallbackInvoke(this.#inner.onheaders, this, block);
+        safeCallbackInvoke(inner.onheaders, this, block);
         break;
       case 'trailing':
         if (onStreamTrailersChannel.hasSubscribers) {
           onStreamTrailersChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#inner.session,
+            session: inner.session,
             trailers: block,
           });
         }
-        if (this.#inner.ontrailers)
-          safeCallbackInvoke(this.#inner.ontrailers, this, block);
+        if (inner.ontrailers)
+          safeCallbackInvoke(inner.ontrailers, this, block);
         break;
       case 'hints':
         if (onStreamInfoChannel.hasSubscribers) {
           onStreamInfoChannel.publish({
             __proto__: null,
             stream: this,
-            session: this.#inner.session,
+            session: inner.session,
             headers: block,
           });
         }
-        if (this.#inner.oninfo)
-          safeCallbackInvoke(this.#inner.oninfo, this, block);
+        if (typeof inner.oninfo === 'function')
+          safeCallbackInvoke(inner.oninfo, this, block);
         break;
     }
   }
 
   [kTrailers]() {
     if (this.destroyed) return;
+    const inner = this.#inner;
 
     // nghttp3 is asking us to provide trailers to send.
     // Check for pre-set pendingTrailers first, then the callback.
-    if (this.#inner.pendingTrailers) {
-      this.sendTrailers(this.#inner.pendingTrailers);
-      this.#inner.pendingTrailers = undefined;
-    } else if (this.#inner.onwanttrailers) {
-      safeCallbackInvoke(this.#inner.onwanttrailers, this);
+    if (inner.pendingTrailers) {
+      this.sendTrailers(inner.pendingTrailers);
+      inner.pendingTrailers = undefined;
+    } else if (typeof inner.onwanttrailers === 'function') {
+      safeCallbackInvoke(inner.onwanttrailers, this);
     }
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    if (depth < 0) {
+      return 'QuicStream { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -2506,105 +2562,83 @@ class QuicStream {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      id,
+      direction,
+      pending,
+      stats,
+      session,
+    } = this;
+
     return `QuicStream ${inspect({
       __proto__: null,
-      id: this.id,
-      direction: this.direction,
-      pending: this.pending,
-      stats: this.stats,
+      id,
+      direction,
+      pending,
+      stats,
       state: this.#inner.state,
-      session: this.session,
+      session,
     }, opts)}`;
   }
 }
 
 class QuicSession {
-  /** @type {QuicEndpoint} */
-  #endpoint = undefined;
-  /** @type {boolean} */
-  #isPendingClose = false;
-  /** @type {boolean} */
-  #selfInitiatedClose = false;
-  /**
-   * Flag set at the top of `destroy()` to make the method safely
-   * re-entrant. Distinct from `#handle === undefined` so callbacks
-   * that fire from C++ during teardown (e.g. `onSessionClose` ->
-   * `[kFinishClose]`) still see a live `#handle` and can complete
-   * their work.
-   * @type {boolean}
-   */
-  #destroying = false;
-  /**
-   * Set to `true` once the TLS handshake has completed successfully
-   * (i.e. `[kHandshake]` has fired). Used to gate operations that only
-   * make sense for a fully-opened session - notably, attempting to
-   * send a `CONNECTION_CLOSE` from `endpoint.destroy(error)` cascade.
-   * The C++ side cannot create a valid `CONNECTION_CLOSE` packet
-   * before handshake completion and falls back to a path that
-   * re-enters JS `destroy()` and trips our `#destroying` guard,
-   * leaving the C++ side asserting an inconsistent state.
-   * @type {boolean}
-   */
-  #handshakeCompleted = false;
   /** @type {object|undefined} */
   #handle;
-  /** @type {PromiseWithResolvers<void>} */
-  #pendingClose = PromiseWithResolvers();
-  /** @type {PromiseWithResolvers<QuicSessionInfo>} */
-  #pendingOpen = PromiseWithResolvers();
-  /** @type {QuicSessionState} */
-  #state;
-  /** @type {QuicSessionStats} */
-  #stats;
-  /** @type {Set<QuicStream>} */
-  #streams = new SafeSet();
-  /** @type {Function|undefined} */
-  #onerror = undefined;
-  /** @type {OnStreamCallback} */
-  #onstream = undefined;
-  /** @type {OnDatagramCallback|undefined} */
-  #ondatagram = undefined;
-  /** @type {OnDatagramStatusCallback|undefined} */
-  #ondatagramstatus = undefined;
-  /** @type {Function|undefined} */
-  #onpathvalidation = undefined;
-  /** @type {Function|undefined} */
-  #onsessionticket = undefined;
-  /** @type {Function|undefined} */
-  #onversionnegotiation = undefined;
-  /** @type {Function|undefined} */
-  #onhandshake = undefined;
-  /** @type {Function|undefined} */
-  #onnewtoken = undefined;
-  /** @type {Function|undefined} */
-  #onearlyrejected = undefined;
-  /** @type {Function|undefined} */
-  #onorigin = undefined;
-  /** @type {Function|undefined} */
-  #ongoaway = undefined;
-  /** @type {Function|undefined} */
-  #onkeylog = undefined;
-  /** @type {Function|undefined} */
-  #onqlog = undefined;
-  #pendingQlog = undefined;
-  #handshakeInfo = undefined;
-  /** @type {{ local: SocketAddress, remote: SocketAddress }|undefined} */
-  #path = undefined;
-  #certificate = undefined;
-  #peerCertificate = undefined;
-  #ephemeralKeyInfo = undefined;
+
+  #inner = {
+    __proto__: null,
+    /** @type {QuicEndpoint} */
+    endpoint: undefined,
+    isPendingClose: false,
+    selfInitiatedClose: false,
+    destroying: false,
+    handshakeCompleted: false,
+    pendingClose: PromiseWithResolvers(),
+    pendingOpen: PromiseWithResolvers(),
+    /** @type {QuicSessionState} */
+    state: undefined,
+    /** @type {QuicSessionStats} */
+    stats: undefined,
+    streams: new SafeSet(),
+    onerror: undefined,
+    onstream: undefined,
+    ondatagram: undefined,
+    ondatagramstatus: undefined,
+    onpathvalidation: undefined,
+    onsessionticket: undefined,
+    onversionnegotiation: undefined,
+    onhandshake: undefined,
+    onnewtoken: undefined,
+    onearlyrejected: undefined,
+    onorigin: undefined,
+    ongoaway: undefined,
+    onkeylog: undefined,
+    onqlog: undefined,
+    pendingQlog: undefined,
+    handshakeInfo: undefined,
+    /** @type {QuicSessionPath|undefined} */
+    path: undefined,
+    certificate: undefined,
+    peerCertificate: undefined,
+    ephemeralKeyInfo: undefined,
+  };
 
   static {
-    getQuicSessionState = function(session) {
-      QuicSession.#assertIsQuicSession(session);
-      return session.#state;
+    isQuicSession = function(val) {
+      return val != null && typeof val === 'object' && #handle in val;
     };
-  }
 
-  static #assertIsQuicSession(val) {
-    if (val == null || !(#handle in val)) {
-      throw new ERR_INVALID_THIS('QuicSession');
-    }
+    assertIsQuicSession = function(val) {
+      if (!isQuicSession(val)) {
+        throw new ERR_INVALID_THIS('QuicSession');
+      }
+    };
+
+    getQuicSessionState = function(session) {
+      assertIsQuicSession(session);
+      return session.#inner.state;
+    };
   }
 
   /**
@@ -2614,21 +2648,21 @@ class QuicSession {
    */
   constructor(privateSymbol, handle, endpoint) {
     // Instances of QuicSession can only be created internally.
-    if (privateSymbol !== kPrivateConstructor) {
-      throw new ERR_ILLEGAL_CONSTRUCTOR();
-    }
+    assertPrivateSymbol(privateSymbol);
 
-    this.#endpoint = endpoint;
     this.#handle = handle;
     this.#handle[kOwner] = this;
+
+    const inner = this.#inner;
+    inner.endpoint = endpoint;
     // Move any qlog entries that arrived before the wrapper existed.
     if (handle._pendingQlog !== undefined) {
-      this.#pendingQlog = handle._pendingQlog;
+      inner.pendingQlog = handle._pendingQlog;
       handle._pendingQlog = undefined;
     }
-    this.#stats = new QuicSessionStats(
+    inner.stats = new QuicSessionStats(
       kPrivateConstructor, handle.stats, handle.statsByteOffset);
-    this.#state = new QuicSessionState(
+    inner.state = new QuicSessionState(
       kPrivateConstructor, handle.state, handle.stateByteOffset);
 
     if (hasObserver('quic')) {
@@ -2640,32 +2674,33 @@ class QuicSession {
 
   /** @type {boolean} */
   get #isClosedOrClosing() {
-    return this.#handle === undefined || this.#isPendingClose;
+    return this.#handle === undefined || this.#inner.isPendingClose;
   }
 
   /** @type {Function|undefined} */
   get onerror() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onerror;
+    assertIsQuicSession(this);
+    return this.#inner.onerror;
   }
 
   set onerror(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onerror = undefined;
+      inner.onerror = undefined;
     } else {
       validateFunction(fn, 'onerror');
-      this.#onerror = FunctionPrototypeBind(fn, this);
+      inner.onerror = FunctionPrototypeBind(fn, this);
       // When an onerror handler is provided, mark the pending promises
       // as handled so that rejections from destroy(error) don't surface
       // as unhandled rejections. The onerror callback is the
       // application's error handler for this session.
-      markPromiseAsHandled(this.#pendingClose.promise);
-      markPromiseAsHandled(this.#pendingOpen.promise);
+      markPromiseAsHandled(inner.pendingClose.promise);
+      markPromiseAsHandled(inner.pendingOpen.promise);
       // Also mark existing streams' closed promises. Stream rejections
       // during session destruction are expected collateral when the
       // session has an error handler.
-      for (const stream of this.#streams) {
+      for (const stream of inner.streams) {
         markPromiseAsHandled(stream.closed);
       }
     }
@@ -2673,35 +2708,37 @@ class QuicSession {
 
   /** @type {OnStreamCallback} */
   get onstream() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onstream;
+    assertIsQuicSession(this);
+    return this.#inner.onstream;
   }
 
   set onstream(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onstream = undefined;
+      inner.onstream = undefined;
     } else {
       validateFunction(fn, 'onstream');
-      this.#onstream = FunctionPrototypeBind(fn, this);
+      inner.onstream = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {OnDatagramCallback} */
   get ondatagram() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#ondatagram;
+    assertIsQuicSession(this);
+    return this.#inner.ondatagram;
   }
 
   set ondatagram(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#ondatagram = undefined;
-      this.#state.hasDatagramListener = false;
+      inner.ondatagram = undefined;
+      inner.state.hasDatagramListener = false;
     } else {
       validateFunction(fn, 'ondatagram');
-      this.#ondatagram = FunctionPrototypeBind(fn, this);
-      this.#state.hasDatagramListener = true;
+      inner.ondatagram = FunctionPrototypeBind(fn, this);
+      inner.state.hasDatagramListener = true;
     }
   }
 
@@ -2711,71 +2748,75 @@ class QuicSession {
    * @type {OnDatagramStatusCallback}
    */
   get ondatagramstatus() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#ondatagramstatus;
+    assertIsQuicSession(this);
+    return this.#inner.ondatagramstatus;
   }
 
   set ondatagramstatus(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#ondatagramstatus = undefined;
-      this.#state.hasDatagramStatusListener = false;
+      inner.ondatagramstatus = undefined;
+      inner.state.hasDatagramStatusListener = false;
     } else {
       validateFunction(fn, 'ondatagramstatus');
-      this.#ondatagramstatus = FunctionPrototypeBind(fn, this);
-      this.#state.hasDatagramStatusListener = true;
+      inner.ondatagramstatus = FunctionPrototypeBind(fn, this);
+      inner.state.hasDatagramStatusListener = true;
     }
   }
 
   /** @type {Function|undefined} */
   get onpathvalidation() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onpathvalidation;
+    assertIsQuicSession(this);
+    return this.#inner.onpathvalidation;
   }
 
   set onpathvalidation(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onpathvalidation = undefined;
-      this.#state.hasPathValidationListener = false;
+      inner.onpathvalidation = undefined;
+      inner.state.hasPathValidationListener = false;
     } else {
       validateFunction(fn, 'onpathvalidation');
-      this.#onpathvalidation = FunctionPrototypeBind(fn, this);
-      this.#state.hasPathValidationListener = true;
+      inner.onpathvalidation = FunctionPrototypeBind(fn, this);
+      inner.state.hasPathValidationListener = true;
     }
   }
 
   get onkeylog() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onkeylog;
+    assertIsQuicSession(this);
+    return this.#inner.onkeylog;
   }
 
   set onkeylog(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onkeylog = undefined;
+      inner.onkeylog = undefined;
     } else {
       validateFunction(fn, 'onkeylog');
-      this.#onkeylog = FunctionPrototypeBind(fn, this);
+      inner.onkeylog = FunctionPrototypeBind(fn, this);
     }
   }
 
   get onqlog() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onqlog;
+    assertIsQuicSession(this);
+    return this.#inner.onqlog;
   }
 
   set onqlog(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onqlog = undefined;
+      inner.onqlog = undefined;
     } else {
       validateFunction(fn, 'onqlog');
-      this.#onqlog = FunctionPrototypeBind(fn, this);
+      inner.onqlog = FunctionPrototypeBind(fn, this);
       // Flush any qlog entries that were cached before the callback was set.
-      if (this.#pendingQlog !== undefined) {
-        const pending = this.#pendingQlog;
-        this.#pendingQlog = undefined;
+      if (inner.pendingQlog !== undefined) {
+        const pending = inner.pendingQlog;
+        inner.pendingQlog = undefined;
         for (let i = 0; i < pending.length; i += 2) {
           this[kQlog](pending[i], pending[i + 1]);
         }
@@ -2785,119 +2826,126 @@ class QuicSession {
 
   /** @type {Function|undefined} */
   get onsessionticket() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onsessionticket;
+    assertIsQuicSession(this);
+    return this.#inner.onsessionticket;
   }
 
   set onsessionticket(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onsessionticket = undefined;
-      this.#state.hasSessionTicketListener = false;
+      inner.onsessionticket = undefined;
+      inner.state.hasSessionTicketListener = false;
     } else {
       validateFunction(fn, 'onsessionticket');
-      this.#onsessionticket = FunctionPrototypeBind(fn, this);
-      this.#state.hasSessionTicketListener = true;
+      inner.onsessionticket = FunctionPrototypeBind(fn, this);
+      inner.state.hasSessionTicketListener = true;
     }
   }
 
   /** @type {Function|undefined} */
   get onversionnegotiation() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onversionnegotiation;
+    assertIsQuicSession(this);
+    return this.#inner.onversionnegotiation;
   }
 
   set onversionnegotiation(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onversionnegotiation = undefined;
+      inner.onversionnegotiation = undefined;
     } else {
       validateFunction(fn, 'onversionnegotiation');
-      this.#onversionnegotiation = FunctionPrototypeBind(fn, this);
+      inner.onversionnegotiation = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get onhandshake() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onhandshake;
+    assertIsQuicSession(this);
+    return this.#inner.onhandshake;
   }
 
   set onhandshake(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onhandshake = undefined;
+      inner.onhandshake = undefined;
     } else {
       validateFunction(fn, 'onhandshake');
-      this.#onhandshake = FunctionPrototypeBind(fn, this);
+      inner.onhandshake = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get onnewtoken() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onnewtoken;
+    assertIsQuicSession(this);
+    return this.#inner.onnewtoken;
   }
 
   set onnewtoken(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onnewtoken = undefined;
-      this.#state.hasNewTokenListener = false;
+      inner.onnewtoken = undefined;
+      inner.state.hasNewTokenListener = false;
     } else {
       validateFunction(fn, 'onnewtoken');
-      this.#onnewtoken = FunctionPrototypeBind(fn, this);
-      this.#state.hasNewTokenListener = true;
+      inner.onnewtoken = FunctionPrototypeBind(fn, this);
+      inner.state.hasNewTokenListener = true;
     }
   }
 
   /** @type {Function|undefined} */
   get onearlyrejected() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onearlyrejected;
+    assertIsQuicSession(this);
+    return this.#inner.onearlyrejected;
   }
 
   set onearlyrejected(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onearlyrejected = undefined;
+      inner.onearlyrejected = undefined;
     } else {
       validateFunction(fn, 'onearlyrejected');
-      this.#onearlyrejected = FunctionPrototypeBind(fn, this);
+      inner.onearlyrejected = FunctionPrototypeBind(fn, this);
     }
   }
 
   /** @type {Function|undefined} */
   get onorigin() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#onorigin;
+    assertIsQuicSession(this);
+    return this.#inner.onorigin;
   }
 
   set onorigin(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#onorigin = undefined;
-      this.#state.hasOriginListener = false;
+      inner.onorigin = undefined;
+      inner.state.hasOriginListener = false;
     } else {
       validateFunction(fn, 'onorigin');
-      this.#onorigin = FunctionPrototypeBind(fn, this);
-      this.#state.hasOriginListener = true;
+      inner.onorigin = FunctionPrototypeBind(fn, this);
+      inner.state.hasOriginListener = true;
     }
   }
 
   /** @type {Function|undefined} */
   get ongoaway() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#ongoaway;
+    assertIsQuicSession(this);
+    return this.#inner.ongoaway;
   }
 
   set ongoaway(fn) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     if (fn === undefined) {
-      this.#ongoaway = undefined;
+      inner.ongoaway = undefined;
     } else {
       validateFunction(fn, 'ongoaway');
-      this.#ongoaway = FunctionPrototypeBind(fn, this);
+      inner.ongoaway = FunctionPrototypeBind(fn, this);
     }
   }
 
@@ -2907,8 +2955,8 @@ class QuicSession {
    * @type {bigint}
    */
   get maxDatagramSize() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#state.maxDatagramSize;
+    assertIsQuicSession(this);
+    return this.#inner.state.maxDatagramSize;
   }
 
   /**
@@ -2918,14 +2966,14 @@ class QuicSession {
    * @type {number}
    */
   get maxPendingDatagrams() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#state.maxPendingDatagrams;
+    assertIsQuicSession(this);
+    return this.#inner.state.maxPendingDatagrams;
   }
 
   set maxPendingDatagrams(val) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     validateInteger(val, 'maxPendingDatagrams', 0, 0xFFFF);
-    this.#state.maxPendingDatagrams = val;
+    this.#inner.state.maxPendingDatagrams = val;
   }
 
   /**
@@ -2933,8 +2981,8 @@ class QuicSession {
    * @type {QuicSessionStats}
    */
   get stats() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#stats;
+    assertIsQuicSession(this);
+    return this.#inner.stats;
   }
 
   /**
@@ -2943,19 +2991,19 @@ class QuicSession {
    * @type {QuicEndpoint|null}
    */
   get endpoint() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.destroyed) return null;
-    return this.#endpoint;
+    return this.#inner.endpoint;
   }
 
   /**
    * The local and remote socket addresses associated with the session.
-   * @type {{ local: SocketAddress, remote: SocketAddress } | undefined}
+   * @type {QuicSessionPath | undefined}
    */
   get path() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.destroyed) return undefined;
-    return this.#path ??= {
+    return this.#inner.path ??= {
       __proto__: null,
       local: new InternalSocketAddress(this.#handle.getLocalAddress()),
       remote: new InternalSocketAddress(this.#handle.getRemoteAddress()),
@@ -2967,9 +3015,9 @@ class QuicSession {
    * @type {object|undefined}
    */
   get certificate() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.destroyed) return undefined;
-    return this.#certificate ??= this.#handle.getCertificate();
+    return this.#inner.certificate ??= this.#handle.getCertificate();
   }
 
   /**
@@ -2978,9 +3026,9 @@ class QuicSession {
    * @type {object|undefined}
    */
   get peerCertificate() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.destroyed) return undefined;
-    return this.#peerCertificate ??= this.#handle.getPeerCertificate();
+    return this.#inner.peerCertificate ??= this.#handle.getPeerCertificate();
   }
 
   /**
@@ -2990,9 +3038,9 @@ class QuicSession {
    * @type {object|undefined}
    */
   get ephemeralKeyInfo() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.destroyed) return undefined;
-    return this.#ephemeralKeyInfo ??= this.#handle.getEphemeralKey();
+    return this.#inner.ephemeralKeyInfo ??= this.#handle.getEphemeralKey();
   }
 
   /**
@@ -3001,11 +3049,12 @@ class QuicSession {
    * @returns {QuicStream}
    */
   async #createStream(direction, options = kEmptyObject) {
+    const inner = this.#inner;
     if (this.#isClosedOrClosing) {
       throw new ERR_INVALID_STATE('Session is closed. New streams cannot be opened.');
     }
     const dir = direction === kStreamDirectionBidirectional ? 'bidi' : 'uni';
-    if (this.#state.isStreamOpenAllowed) {
+    if (inner.state.isStreamOpenAllowed) {
       debug(`opening new pending ${dir} stream`);
     } else {
       debug(`opening new ${dir} stream`);
@@ -3034,21 +3083,21 @@ class QuicSession {
       throw new ERR_QUIC_OPEN_STREAM_FAILED();
     }
 
-    if (this.#state.isPrioritySupported) {
+    if (inner.state.isPrioritySupported) {
       const urgency = priority === 'high' ? 0 : priority === 'low' ? 7 : 3;
       handle.setPriority((urgency << 1) | (incremental ? 1 : 0));
     }
 
     const stream = new QuicStream(
       kPrivateConstructor, handle, this, direction, true /* isLocal */);
-    this.#streams.add(stream);
-    if (typeof this.#onerror === 'function') {
+    inner.streams.add(stream);
+    if (typeof this.#inner.onerror === 'function') {
       markPromiseAsHandled(stream.closed);
     }
 
     // If the body was a FileHandle, store it on the stream so it is
     // closed automatically when the stream finishes.
-    if (body instanceof FileHandle) {
+    if (FileHandle.isFileHandle(body)) {
       stream[kAttachFileHandle](body);
     }
 
@@ -3083,7 +3132,7 @@ class QuicSession {
    * @returns {Promise<QuicStream>}
    */
   async createBidirectionalStream(options = kEmptyObject) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     return await this.#createStream(kStreamDirectionBidirectional, options);
   }
 
@@ -3094,7 +3143,7 @@ class QuicSession {
    * @returns {Promise<QuicStream>}
    */
   async createUnidirectionalStream(options = kEmptyObject) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     return await this.#createStream(kStreamDirectionUnidirectional, options);
   }
 
@@ -3119,12 +3168,12 @@ class QuicSession {
    * @returns {Promise<bigint>} The datagram ID
    */
   async sendDatagram(datagram, encoding = 'utf8') {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.#isClosedOrClosing) {
       throw new ERR_INVALID_STATE('Session is closed');
     }
 
-    const maxDatagramSize = this.#state.maxDatagramSize;
+    const maxDatagramSize = this.#inner.state.maxDatagramSize;
 
     // The peer max datagram size is either unknown or they have explicitly
     // indicated that they do not support datagrams by setting it to 0. In
@@ -3177,7 +3226,7 @@ class QuicSession {
    * Initiate a key update.
    */
   updateKey() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     if (this.#isClosedOrClosing) {
       throw new ERR_INVALID_STATE('Session is closed');
     }
@@ -3211,12 +3260,13 @@ class QuicSession {
    * @returns {Promise<void>}
    */
   close(options = kEmptyObject) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     options = validateCloseOptions(options);
+    const inner = this.#inner;
     if (!this.#isClosedOrClosing) {
-      this.#isPendingClose = true;
+      inner.isPendingClose = true;
       if (options?.code !== undefined) {
-        this.#selfInitiatedClose = true;
+        inner.selfInitiatedClose = true;
       }
 
       debug('gracefully closing the session');
@@ -3234,13 +3284,13 @@ class QuicSession {
 
   /** @type {boolean} */
   get closing() {
-    return this.#isPendingClose;
+    return this.#inner.isPendingClose;
   }
 
   /** @type {Promise<QuicSessionInfo>} */
   get opened() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#pendingOpen.promise;
+    assertIsQuicSession(this);
+    return this.#inner.pendingOpen.promise;
   }
 
   /**
@@ -3249,13 +3299,13 @@ class QuicSession {
    * @type {Promise<void>}
    */
   get closed() {
-    QuicSession.#assertIsQuicSession(this);
-    return this.#pendingClose.promise;
+    assertIsQuicSession(this);
+    return this.#inner.pendingClose.promise;
   }
 
   /** @type {boolean} */
   get destroyed() {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
     return this.#handle === undefined;
   }
 
@@ -3275,7 +3325,8 @@ class QuicSession {
    *   string included in the CONNECTION_CLOSE frame (diagnostic only).
    */
   destroy(error, options) {
-    QuicSession.#assertIsQuicSession(this);
+    assertIsQuicSession(this);
+    const inner = this.#inner;
     // Two distinct guards (see also `QuicStream.destroy`):
     //   * `#destroying` flips synchronously here so any re-entrant call
     //     (e.g. from a user `onerror` callback or from a cascading
@@ -3286,10 +3337,10 @@ class QuicSession {
     //     "fully torn down". Defense-in-depth for paths that may have
     //     finished teardown without setting `#destroying` and for
     //     repeat invocations after this method has fully run.
-    if (this.#destroying || this.destroyed) return;
+    if (inner.destroying || this.destroyed) return;
 
     if (options !== undefined) options = validateCloseOptions(options);
-    this.#destroying = true;
+    inner.destroying = true;
 
     debug('destroying the session');
 
@@ -3301,31 +3352,31 @@ class QuicSession {
           error,
         });
       }
-      if (typeof this.#onerror === 'function') {
-        invokeOnerror(this.#onerror, error);
+      if (typeof inner.onerror === 'function') {
+        invokeOnerror(inner.onerror, error);
       }
     }
 
     // First, forcefully and immediately destroy all open streams, if any.
-    for (const stream of this.#streams) {
+    for (const stream of inner.streams) {
       stream.destroy(error);
     }
     // The streams should remove themselves when they are destroyed but let's
     // be doubly sure.
-    if (this.#streams.size) {
+    if (inner.streams.size) {
       process.emitWarning(
-        `The session is destroyed with ${this.#streams.size} active streams. ` +
+        `The session is destroyed with ${inner.streams.size} active streams. ` +
         'This should not happen and indicates a bug in Node.js. Please open an ' +
         'issue in the Node.js GitHub repository at https://github.com/nodejs/node ' +
         'to report the problem.',
       );
     }
-    this.#streams.clear();
+    inner.streams.clear();
 
     // Remove this session immediately from the endpoint
-    this.#endpoint[kRemoveSession](this);
-    this.#endpoint = undefined;
-    this.#isPendingClose = false;
+    inner.endpoint[kRemoveSession](this);
+    inner.endpoint = undefined;
+    inner.isPendingClose = false;
 
     // If the handshake never completed, reject the opened promise. The
     // session is being destroyed, so the handshake will never complete
@@ -3341,54 +3392,54 @@ class QuicSession {
     // rejection warning - common for server-side sessions delivered via
     // `onsession`, which often do not await opened. The rejection is
     // still observable via `await session.opened`.
-    if (this.#pendingOpen.reject) {
-      markPromiseAsHandled(this.#pendingOpen.promise);
-      this.#pendingOpen.reject(error ?? new ERR_INVALID_STATE(
+    if (inner.pendingOpen.reject) {
+      markPromiseAsHandled(inner.pendingOpen.promise);
+      inner.pendingOpen.reject(error ?? new ERR_INVALID_STATE(
         'Session was destroyed before it opened'));
     }
 
     if (error) {
       // If the session is still waiting to be closed, and error
       // is specified, reject the closed promise.
-      this.#pendingClose.reject?.(error);
+      inner.pendingClose.reject?.(error);
     } else {
-      this.#pendingClose.resolve?.();
+      inner.pendingClose.resolve?.();
     }
 
-    this.#pendingClose.reject = undefined;
-    this.#pendingClose.resolve = undefined;
-    this.#pendingOpen.reject = undefined;
-    this.#pendingOpen.resolve = undefined;
+    inner.pendingClose.reject = undefined;
+    inner.pendingClose.resolve = undefined;
+    inner.pendingOpen.reject = undefined;
+    inner.pendingOpen.resolve = undefined;
 
-    this.#state[kFinishClose]();
-    this.#stats[kFinishClose]();
+    inner.state[kFinishClose]();
+    inner.stats[kFinishClose]();
 
     if (this[kPerfEntry] && hasObserver('quic')) {
       stopPerf(this, kPerfEntry, {
         detail: {
-          stats: this.stats,
-          handshake: this.#handshakeInfo,
-          path: this.#path,
+          stats: inner.stats,
+          handshake: inner.handshakeInfo,
+          path: inner.path,
         },
       });
     }
 
-    this.#onerror = undefined;
-    this.#onstream = undefined;
-    this.#ondatagram = undefined;
-    this.#ondatagramstatus = undefined;
-    this.#onpathvalidation = undefined;
-    this.#onsessionticket = undefined;
-    this.#onkeylog = undefined;
-    this.#onversionnegotiation = undefined;
-    this.#onhandshake = undefined;
-    this.#onnewtoken = undefined;
-    this.#onorigin = undefined;
-    this.#ongoaway = undefined;
-    this.#path = undefined;
-    this.#certificate = undefined;
-    this.#peerCertificate = undefined;
-    this.#ephemeralKeyInfo = undefined;
+    inner.onerror = undefined;
+    inner.onstream = undefined;
+    inner.ondatagram = undefined;
+    inner.ondatagramstatus = undefined;
+    inner.onpathvalidation = undefined;
+    inner.onsessionticket = undefined;
+    inner.onkeylog = undefined;
+    inner.onversionnegotiation = undefined;
+    inner.onhandshake = undefined;
+    inner.onnewtoken = undefined;
+    inner.onorigin = undefined;
+    inner.ongoaway = undefined;
+    inner.path = undefined;
+    inner.certificate = undefined;
+    inner.peerCertificate = undefined;
+    inner.ephemeralKeyInfo = undefined;
 
     // Destroy the underlying C++ handle. Pass close error options if
     // provided so the CONNECTION_CLOSE frame carries the correct code.
@@ -3404,7 +3455,7 @@ class QuicSession {
         __proto__: null,
         session: this,
         error,
-        stats: this.stats,
+        stats: inner.stats,
       });
     }
   }
@@ -3416,7 +3467,8 @@ class QuicSession {
    * @param {bigint} lastStreamId
    */
   [kGoaway](lastStreamId) {
-    this.#isPendingClose = true;
+    const inner = this.#inner;
+    inner.isPendingClose = true;
     if (onSessionClosingChannel.hasSubscribers) {
       onSessionClosingChannel.publish({ __proto__: null, session: this });
     }
@@ -3427,8 +3479,8 @@ class QuicSession {
         lastStreamId,
       });
     }
-    if (this.#ongoaway) {
-      safeCallbackInvoke(this.#ongoaway, this, lastStreamId);
+    if (typeof inner.ongoaway === 'function') {
+      safeCallbackInvoke(inner.ongoaway, this, lastStreamId);
     }
   }
 
@@ -3451,7 +3503,7 @@ class QuicSession {
     // If the local side initiated this close with an error code (via
     // close({ code })), this is an intentional shutdown; not an error.
     // The closed promise should resolve, not reject.
-    if (this.#selfInitiatedClose) {
+    if (this.#inner.selfInitiatedClose) {
       this.destroy();
       return;
     }
@@ -3491,13 +3543,15 @@ class QuicSession {
   }
 
   [kKeylog](line) {
-    if (this.destroyed || this.onkeylog === undefined) return;
-    safeCallbackInvoke(this.#onkeylog, this, line);
+    const inner = this.#inner;
+    if (this.destroyed || inner.onkeylog === undefined) return;
+    safeCallbackInvoke(inner.onkeylog, this, line);
   }
 
   [kQlog](data, fin) {
-    if (this.onqlog === undefined) return;
-    safeCallbackInvoke(this.#onqlog, this, data, fin);
+    const inner = this.#inner;
+    if (inner.onqlog === undefined) return;
+    safeCallbackInvoke(inner.onqlog, this, data, fin);
   }
 
   /**
@@ -3507,7 +3561,8 @@ class QuicSession {
   [kDatagram](u8, early) {
     // The datagram event should only be called if the session has
     // an ondatagram callback. The callback should always exist here.
-    assert(typeof this.#ondatagram === 'function', 'Unexpected datagram event');
+    const inner = this.#inner;
+    assert(typeof inner.ondatagram === 'function', 'Unexpected datagram event');
     if (this.destroyed) return;
     const length = TypedArrayPrototypeGetByteLength(u8);
     if (onSessionReceiveDatagramChannel.hasSubscribers) {
@@ -3518,7 +3573,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#ondatagram, this, u8, early);
+    safeCallbackInvoke(inner.ondatagram, this, u8, early);
   }
 
   /**
@@ -3526,9 +3581,10 @@ class QuicSession {
    * @param {'lost'|'acknowledged'} status
    */
   [kDatagramStatus](id, status) {
+    const inner = this.#inner;
     // The datagram status event should only be called if the session has
     // an ondatagramstatus callback. The callback should always exist here.
-    assert(typeof this.#ondatagramstatus === 'function', 'Unexpected datagram status event');
+    assert(typeof inner.ondatagramstatus === 'function', 'Unexpected datagram status event');
     if (this.destroyed) return;
     if (onSessionReceiveDatagramStatusChannel.hasSubscribers) {
       onSessionReceiveDatagramStatusChannel.publish({
@@ -3538,7 +3594,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#ondatagramstatus, this, id, status);
+    safeCallbackInvoke(inner.ondatagramstatus, this, id, status);
   }
 
   /**
@@ -3551,7 +3607,8 @@ class QuicSession {
    */
   [kPathValidation](result, newLocalAddress, newRemoteAddress, oldLocalAddress,
                     oldRemoteAddress, preferredAddress) {
-    assert(typeof this.#onpathvalidation === 'function',
+    const inner = this.#inner;
+    assert(typeof inner.onpathvalidation === 'function',
            'Unexpected path validation event');
     if (this.destroyed) return;
     const newLocal = new InternalSocketAddress(newLocalAddress);
@@ -3572,7 +3629,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#onpathvalidation, this, result, newLocal, newRemote,
+    safeCallbackInvoke(inner.onpathvalidation, this, result, newLocal, newRemote,
                        oldLocal, oldRemote, preferredAddress);
   }
 
@@ -3580,7 +3637,8 @@ class QuicSession {
    * @param {object} ticket
    */
   [kSessionTicket](ticket) {
-    assert(typeof this.#onsessionticket === 'function',
+    const inner = this.#inner;
+    assert(typeof inner.onsessionticket === 'function',
            'Unexpected session ticket event');
     if (this.destroyed) return;
     if (onSessionTicketChannel.hasSubscribers) {
@@ -3590,7 +3648,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#onsessionticket, this, ticket);
+    safeCallbackInvoke(inner.onsessionticket, this, ticket);
   }
 
   /**
@@ -3598,7 +3656,8 @@ class QuicSession {
    * @param {SocketAddress} address
    */
   [kNewToken](token, address) {
-    assert(typeof this.#onnewtoken === 'function',
+    const inner = this.#inner;
+    assert(typeof inner.onnewtoken === 'function',
            'Unexpected new token event');
     if (this.destroyed) return;
     const addr = new InternalSocketAddress(address);
@@ -3610,7 +3669,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#onnewtoken, this, token, addr);
+    safeCallbackInvoke(inner.onnewtoken, this, token, addr);
   }
 
   [kEarlyDataRejected]() {
@@ -3621,8 +3680,9 @@ class QuicSession {
         session: this,
       });
     }
-    if (typeof this.#onearlyrejected === 'function') {
-      safeCallbackInvoke(this.#onearlyrejected, this);
+    const inner = this.#inner;
+    if (typeof inner.onearlyrejected === 'function') {
+      safeCallbackInvoke(inner.onearlyrejected, this);
     }
   }
 
@@ -3642,8 +3702,9 @@ class QuicSession {
         session: this,
       });
     }
-    if (this.#onversionnegotiation) {
-      safeCallbackInvoke(this.#onversionnegotiation, this,
+    const inner = this.#inner;
+    if (typeof inner.onversionnegotiation === 'function') {
+      safeCallbackInvoke(inner.onversionnegotiation, this,
                          version, requestedVersions, supportedVersions);
     }
     // Version negotiation is always a fatal event - the session must be
@@ -3656,9 +3717,9 @@ class QuicSession {
    * @param {string[]} origins
    */
   [kOrigin](origins) {
-    assert(typeof this.#onorigin === 'function',
-           'Unexpected origin event');
     if (this.destroyed) return;
+    const inner = this.#inner;
+    assert(typeof inner.onorigin === 'function', 'Unexpected origin event');
     if (onSessionOriginChannel.hasSubscribers) {
       onSessionOriginChannel.publish({
         __proto__: null,
@@ -3666,7 +3727,7 @@ class QuicSession {
         session: this,
       });
     }
-    safeCallbackInvoke(this.#onorigin, this, origins);
+    safeCallbackInvoke(inner.onorigin, this, origins);
   }
 
   /**
@@ -3679,13 +3740,15 @@ class QuicSession {
    */
   [kHandshake](servername, protocol, cipher, cipherVersion, validationErrorReason,
                validationErrorCode, earlyDataAttempted, earlyDataAccepted) {
-    if (this.destroyed || !this.#pendingOpen.resolve) return;
+    const inner = this.#inner;
+    if (this.destroyed || !inner.pendingOpen.resolve) return;
+
 
     const addr = this.#handle.getRemoteAddress();
 
     const info = {
       __proto__: null,
-      local: this.#endpoint.address,
+      local: inner.endpoint.address,
       remote: addr !== undefined ?
         new InternalSocketAddress(addr) :
         undefined,
@@ -3700,7 +3763,7 @@ class QuicSession {
     };
 
     // Stash timing-relevant handshake info for the perf entry detail.
-    this.#handshakeInfo = {
+    inner.handshakeInfo = {
       __proto__: null,
       servername,
       protocol,
@@ -3716,19 +3779,19 @@ class QuicSession {
       });
     }
 
-    if (this.#onhandshake) {
-      safeCallbackInvoke(this.#onhandshake, this, info);
+    if (typeof inner.onhandshake === 'function') {
+      safeCallbackInvoke(inner.onhandshake, this, info);
     }
 
-    this.#pendingOpen.resolve?.(info);
-    this.#pendingOpen.resolve = undefined;
-    this.#pendingOpen.reject = undefined;
-    this.#handshakeCompleted = true;
+    inner.pendingOpen.resolve?.(info);
+    inner.pendingOpen.resolve = undefined;
+    inner.pendingOpen.reject = undefined;
+    inner.handshakeCompleted = true;
   }
 
   /** @type {boolean} */
   get [kHandshakeCompleted]() {
-    return this.#handshakeCompleted;
+    return this.#inner.handshakeCompleted;
   }
 
   /**
@@ -3736,22 +3799,25 @@ class QuicSession {
    * @param {number} direction
    */
   [kNewStream](handle, direction) {
-    const stream = new QuicStream(kPrivateConstructor, handle, this, direction);
+    const inner = this.#inner;
+    const stream = new QuicStream(kPrivateConstructor, handle, this, direction,
+                                  false /* isLocal */);
 
     // Set the default high water mark for received streams.
     stream.highWaterMark = kDefaultHighWaterMark;
 
     // A new stream was received. If we don't have an onstream callback, then
     // there's nothing we can do about it. Destroy the stream in this case.
-    if (typeof this.#onstream !== 'function') {
+    if (typeof inner.onstream !== 'function') {
       process.emitWarning('A new stream was received but no onstream callback was provided');
       stream.destroy();
       return;
     }
-    this.#streams.add(stream);
+
+    inner.streams.add(stream);
     // If the session has an onerror handler, mark the stream's closed
     // promise as handled. See the onerror setter for explanation.
-    if (typeof this.#onerror === 'function') {
+    if (typeof inner.onerror === 'function') {
       markPromiseAsHandled(stream.closed);
     }
 
@@ -3774,16 +3840,17 @@ class QuicSession {
       });
     }
 
-    safeCallbackInvoke(this.#onstream, this, stream);
+    safeCallbackInvoke(inner.onstream, this, stream);
   }
 
   [kRemoveStream](stream) {
-    this.#streams.delete(stream);
+    this.#inner.streams.delete(stream);
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    if (depth < 0) {
+      return 'QuicSession { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -3791,100 +3858,54 @@ class QuicSession {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      isPendingClose: closing,
+      endpoint,
+      path,
+      state,
+      stats,
+      streams,
+    } = this.#inner;
+
     return `QuicSession ${inspect({
       closed: this.closed,
-      closing: this.#isPendingClose,
+      closing,
       destroyed: this.destroyed,
-      endpoint: this.endpoint,
-      path: this.path,
-      state: this.#state,
-      stats: this.stats,
-      streams: this.#streams,
+      endpoint,
+      path,
+      state,
+      stats,
+      streams,
     }, opts)}`;
   }
 
   async [SymbolAsyncDispose]() { await this.close(); }
 }
 
-let isQuicEndpoint;
-
 // The QuicEndpoint represents a local UDP port binding. It can act as both a
 // server for receiving peer sessions, or a client for initiating them. The
 // local UDP port will be lazily bound only when connect() or listen() are
 // called.
 class QuicEndpoint {
-  /**
-   * The local socket address on which the endpoint is listening (lazily created)
-   * @type {SocketAddress|undefined}
-   */
-  #address = undefined;
-  /**
-   * When true, the endpoint has been marked busy and is temporarily not accepting
-   * new sessions (only used when the Endpoint is acting as a server)
-   * @type {boolean}
-   */
-  #busy = false;
-  /**
-   * The underlying C++ handle for the endpoint. When undefined the endpoint is
-   * considered to be closed.
-   * @type {object}
-   */
   #handle;
-  /**
-   * True if endpoint.close() has been called and the [kFinishClose] method has
-   * not yet been called.
-   * @type {boolean}
-   */
-  #isPendingClose = false;
-  /**
-   * True if the endpoint is acting as a server and actively listening for connections.
-   * @type {boolean}
-   */
-  #listening = false;
-  /**
-   * A promise that is resolved when the endpoint has been closed (or rejected if
-   * the endpoint closes abruptly due to an error).
-   * @type {PromiseWithResolvers<void>}
-   */
-  #pendingClose = PromiseWithResolvers();
-  /**
-   * If destroy() is called with an error, the error is stored here and used to reject
-   * the pendingClose promise when [kFinishClose] is called.
-   * @type {any}
-   */
-  #pendingError = undefined;
-  /**
-   * The collection of active sessions.
-   * @type {Set<QuicSession>}
-   */
-  #sessions = new SafeSet();
-  /**
-   * The internal state of the endpoint. Used to efficiently track and update the
-   * state of the underlying c++ endpoint handle.
-   * @type {QuicEndpointState}
-   */
-  #state;
-  /**
-   * The collected statistics for the endpoint.
-   * @type {QuicEndpointStats}
-   */
-  #stats;
-  /**
-   * The user provided callback that is invoked when a new session is received.
-   * (used only when the endpoint is acting as a server)
-   * @type {OnSessionCallback}
-   */
-  #onsession = undefined;
-  #sessionCallbacks = undefined;
+  #inner = {
+    __proto__: null,
+    address: undefined,
+    busy: false,
+    isPendingClose: false,
+    listening: false,
+    pendingClose: PromiseWithResolvers(),
+    pendingError: undefined,
+    sessions: new SafeSet(),
+    stat: undefined,
+    stats: undefined,
+    onsession: undefined,
+    sessionCallbacks: undefined,
+  };
 
   static {
-    getQuicEndpointState = function(endpoint) {
-      assertIsQuicEndpoint(endpoint);
-      return endpoint.#state;
-    };
-
     isQuicEndpoint = function(val) {
-      return val != null && #handle in val;
+      return val != null && typeof val === 'object' && #handle in val;
     };
 
     assertIsQuicEndpoint = function(val) {
@@ -3893,6 +3914,11 @@ class QuicEndpoint {
       }
     };
 
+    getQuicEndpointState = function(endpoint) {
+      assertIsQuicEndpoint(endpoint);
+      return endpoint.#inner.state;
+    };
+
     assertEndpointNotClosedOrClosing = function(endpoint) {
       if (endpoint.#isClosedOrClosing) {
         throw new ERR_INVALID_STATE('Endpoint is closed');
@@ -3900,7 +3926,7 @@ class QuicEndpoint {
     };
 
     assertEndpointIsNotBusy = function(endpoint) {
-      if (endpoint.#state.isBusy) {
+      if (endpoint.#inner.state.isBusy) {
         throw new ERR_INVALID_STATE('Endpoint is busy');
       }
     };
@@ -3974,7 +4000,7 @@ class QuicEndpoint {
 
   #newSession(handle) {
     const session = new QuicSession(kPrivateConstructor, handle, this);
-    this.#sessions.add(session);
+    this.#inner.sessions.add(session);
     // Set default pending datagram queue size.
     session.maxPendingDatagrams = kDefaultMaxPendingDatagrams;
     return session;
@@ -3987,8 +4013,9 @@ class QuicEndpoint {
     const options = this.#processEndpointOptions(config);
     this.#handle = new Endpoint_(options);
     this.#handle[kOwner] = this;
-    this.#stats = new QuicEndpointStats(kPrivateConstructor, this.#handle.stats);
-    this.#state = new QuicEndpointState(kPrivateConstructor, this.#handle.state);
+    const inner = this.#inner;
+    inner.stats = new QuicEndpointStats(kPrivateConstructor, this.#handle.stats);
+    inner.state = new QuicEndpointState(kPrivateConstructor, this.#handle.state);
 
     // Connection limits are stored in the shared state buffer so they
     // can be read by C++ and mutated from JS after construction.
@@ -4023,11 +4050,11 @@ class QuicEndpoint {
    */
   get stats() {
     assertIsQuicEndpoint(this);
-    return this.#stats;
+    return this.#inner.stats;
   }
 
   get #isClosedOrClosing() {
-    return this.destroyed || this.#isPendingClose;
+    return this.destroyed || this.#inner.isPendingClose;
   }
 
   /**
@@ -4037,7 +4064,7 @@ class QuicEndpoint {
    */
   get busy() {
     assertIsQuicEndpoint(this);
-    return this.#busy;
+    return this.#inner.busy;
   }
 
   /**
@@ -4048,15 +4075,16 @@ class QuicEndpoint {
     assertEndpointNotClosedOrClosing(this);
     // The val is allowed to be any truthy value
     // Non-op if there is no change
-    if (!!val !== this.#busy) {
-      debug('toggling endpoint busy status to ', !this.#busy);
-      this.#busy = !this.#busy;
-      this.#handle.markBusy(this.#busy);
+    const inner = this.#inner;
+    if (!!val !== inner.busy) {
+      debug('toggling endpoint busy status to ', !inner.busy);
+      inner.busy = !inner.busy;
+      this.#handle.markBusy(inner.busy);
       if (onEndpointBusyChangeChannel.hasSubscribers) {
         onEndpointBusyChangeChannel.publish({
           __proto__: null,
           endpoint: this,
-          busy: this.#busy,
+          busy: inner.busy,
         });
       }
     }
@@ -4069,13 +4097,13 @@ class QuicEndpoint {
    */
   get maxConnectionsPerHost() {
     assertIsQuicEndpoint(this);
-    return this.#state.maxConnectionsPerHost;
+    return this.#inner.state.maxConnectionsPerHost;
   }
 
   set maxConnectionsPerHost(val) {
     assertIsQuicEndpoint(this);
     validateInteger(val, 'maxConnectionsPerHost', 0, 0xFFFF);
-    this.#state.maxConnectionsPerHost = val;
+    this.#inner.state.maxConnectionsPerHost = val;
   }
 
   /**
@@ -4085,13 +4113,13 @@ class QuicEndpoint {
    */
   get maxConnectionsTotal() {
     assertIsQuicEndpoint(this);
-    return this.#state.maxConnectionsTotal;
+    return this.#inner.state.maxConnectionsTotal;
   }
 
   set maxConnectionsTotal(val) {
     assertIsQuicEndpoint(this);
     validateInteger(val, 'maxConnectionsTotal', 0, 0xFFFF);
-    this.#state.maxConnectionsTotal = val;
+    this.#inner.state.maxConnectionsTotal = val;
   }
 
   /**
@@ -4101,11 +4129,11 @@ class QuicEndpoint {
   get address() {
     assertIsQuicEndpoint(this);
     if (this.#isClosedOrClosing) return undefined;
-    if (this.#address === undefined) {
+    if (this.#inner.address === undefined) {
       const addr = this.#handle.address();
-      if (addr !== undefined) this.#address = new InternalSocketAddress(addr);
+      if (addr !== undefined) this.#inner.address = new InternalSocketAddress(addr);
     }
-    return this.#address;
+    return this.#inner.address;
   }
 
   /**
@@ -4116,11 +4144,13 @@ class QuicEndpoint {
   [kListen](onsession, options) {
     assertEndpointNotClosedOrClosing(this);
     assertEndpointIsNotBusy(this);
-    if (this.#listening) {
+    const inner = this.#inner;
+    if (inner.listening) {
       throw new ERR_INVALID_STATE('Endpoint is already listening');
     }
     validateObject(options, 'options');
-    this.#onsession = FunctionPrototypeBind(onsession, this);
+    validateFunction(onsession, 'onsession');
+    this.#inner.onsession = FunctionPrototypeBind(onsession, this);
 
     const {
       onerror,
@@ -4146,7 +4176,7 @@ class QuicEndpoint {
     } = options;
 
     // Store session and stream callbacks to apply to each new incoming session.
-    this.#sessionCallbacks = {
+    inner.sessionCallbacks = {
       __proto__: null,
       onerror,
       onstream,
@@ -4168,9 +4198,9 @@ class QuicEndpoint {
       onwanttrailers,
     };
 
-    debug('endpoint listening as a server');
     this.#handle.listen(rest);
-    this.#listening = true;
+    inner.listening = true;
+    debug('endpoint listening as a server');
   }
 
   /**
@@ -4212,15 +4242,16 @@ class QuicEndpoint {
     assertIsQuicEndpoint(this);
     if (!this.#isClosedOrClosing) {
       debug('gracefully closing the endpoint');
+      const inner = this.#inner;
+      inner.isPendingClose = true;
+      this.#handle.closeGracefully();
       if (onEndpointClosingChannel.hasSubscribers) {
         onEndpointClosingChannel.publish({
           __proto__: null,
           endpoint: this,
-          hasPendingError: this.#pendingError !== undefined,
+          hasPendingError: inner.pendingError !== undefined,
         });
       }
-      this.#isPendingClose = true;
-      this.#handle.closeGracefully();
     }
     return this.closed;
   }
@@ -4233,7 +4264,7 @@ class QuicEndpoint {
    */
   get closed() {
     assertIsQuicEndpoint(this);
-    return this.#pendingClose.promise;
+    return this.#inner.pendingClose.promise;
   }
 
   /**
@@ -4242,13 +4273,13 @@ class QuicEndpoint {
    */
   get closing() {
     assertIsQuicEndpoint(this);
-    return this.#isPendingClose;
+    return this.#inner.isPendingClose;
   }
 
   /** @type {boolean} */
   get listening() {
     assertIsQuicEndpoint(this);
-    return this.#listening;
+    return this.#inner.listening;
   }
 
   /** @type {boolean} */
@@ -4268,6 +4299,7 @@ class QuicEndpoint {
   destroy(error) {
     assertIsQuicEndpoint(this);
     debug('destroying the endpoint');
+    const inner = this.#inner;
     // Record the error before deciding whether to initiate a close. If
     // `close()` was already called (e.g. the user kicked off a graceful
     // shutdown and then a fatal error was reported afterwards via
@@ -4276,7 +4308,7 @@ class QuicEndpoint {
     // last in-flight session finishes draining. Only the *first* error
     // is recorded, matching how other Node subsystems handle a
     // double-error race.
-    if (error !== undefined) this.#pendingError ??= error;
+    if (error !== undefined) inner.pendingError ??= error;
     // Force all sessions to be abruptly closed *before* signalling the
     // endpoint to close gracefully. The order matters: each session's
     // `destroy(error, options)` asks the C++ side to emit a
@@ -4293,7 +4325,7 @@ class QuicEndpoint {
     // `destroy()`, which trips the `#destroying` guard and leaves the
     // C++ side asserting an inconsistent destroyed state.
     const closeOptions = errorToCloseOptions(error);
-    for (const session of this.#sessions) {
+    for (const session of inner.sessions) {
       // Mark each cascaded session's `closed` as handled before
       // destroying it. This prevents unhandled-rejection warnings when
       // the session is collateral damage from an endpoint-level destroy
@@ -4321,7 +4353,7 @@ class QuicEndpoint {
    * replace is true, the entire SNI map is replaced. Otherwise, the
    * provided entries are merged into the existing map.
    * @param {object} entries
-   * @param {{replace?: boolean}} [options]
+   * @param {SNIContextOptions} [options]
    */
   setSNIContexts(entries, options = kEmptyObject) {
     assertIsQuicEndpoint(this);
@@ -4356,38 +4388,39 @@ class QuicEndpoint {
     debug('endpoint is finishing close', context, status);
     endpointRegistry.delete(this);
     this.#handle = undefined;
-    this.#stats[kFinishClose]();
-    this.#state[kFinishClose]();
+    const inner = this.#inner;
+    inner.stats[kFinishClose]();
+    inner.state[kFinishClose]();
     if (this[kPerfEntry] && hasObserver('quic')) {
       stopPerf(this, kPerfEntry, {
         detail: { stats: this.stats },
       });
     }
-    this.#address = undefined;
-    this.#busy = false;
-    this.#listening = false;
-    this.#isPendingClose = false;
+    inner.address = undefined;
+    inner.busy = false;
+    inner.listening = false;
+    inner.isPendingClose = false;
 
     // As QuicSessions are closed they are expected to remove themselves
     // from the sessions collection. Just in case they don't, let's force
     // it by resetting the set so we don't leak memory. Let's emit a warning,
     // tho, if the set is not empty at this point as that would indicate a
     // bug in Node.js that should be fixed.
-    if (this.#sessions.size > 0) {
+    if (inner.sessions.size > 0) {
       process.emitWarning(
-        `The endpoint is closed with ${this.#sessions.size} active sessions. ` +
+        `The endpoint is closed with ${inner.sessions.size} active sessions. ` +
         'This should not happen and indicates a bug in Node.js. Please open an ' +
         'issue in the Node.js GitHub repository at https://github.com/nodejs/node ' +
         'to report the problem.',
       );
     }
-    this.#sessions.clear();
+    inner.sessions.clear();
 
     // If destroy was called with an error, then the this.#pendingError will be
     // set. Or, if context indicates an error condition that caused the endpoint
     // to be closed, the status will indicate the error code. In either case,
     // we will reject the pending close promise at this point.
-    const maybeCloseError = maybeGetCloseError(context, status, this.#pendingError);
+    const maybeCloseError = maybeGetCloseError(context, status, inner.pendingError);
     if (maybeCloseError !== undefined) {
       if (onEndpointErrorChannel.hasSubscribers) {
         onEndpointErrorChannel.publish({
@@ -4396,33 +4429,36 @@ class QuicEndpoint {
           error: maybeCloseError,
         });
       }
-      this.#pendingClose.reject(maybeCloseError);
+      inner.pendingClose.reject(maybeCloseError);
     } else {
       // Otherwise we are good to resolve the pending close promise!
-      this.#pendingClose.resolve();
+      inner.pendingClose.resolve();
     }
     if (onEndpointClosedChannel.hasSubscribers) {
       onEndpointClosedChannel.publish({
         __proto__: null,
         endpoint: this,
-        stats: this.stats,
+        stats: inner.stats,
       });
     }
 
     // Note that we are intentionally not clearing the
     // this.#pendingClose.promise here.
-    this.#pendingClose.resolve = undefined;
-    this.#pendingClose.reject = undefined;
-    this.#pendingError = undefined;
+    inner.pendingClose.resolve = undefined;
+    inner.pendingClose.reject = undefined;
+    inner.pendingError = undefined;
   }
 
   [kNewSession](handle) {
+    const inner = this.#inner;
+    assert(typeof inner.onsession === 'function',
+           'onsession callback not specified');
     const session = this.#newSession(handle);
     // Apply session callbacks stored at listen time before notifying
     // the onsession callback, to avoid missing events that fire
     // during or immediately after the handshake.
-    if (this.#sessionCallbacks) {
-      applyCallbacks(session, this.#sessionCallbacks);
+    if (inner.sessionCallbacks) {
+      applyCallbacks(session, inner.sessionCallbacks);
     }
     if (onEndpointServerSessionChannel.hasSubscribers) {
       onEndpointServerSessionChannel.publish({
@@ -4432,25 +4468,24 @@ class QuicEndpoint {
         address: session.path?.remote,
       });
     }
-    assert(typeof this.#onsession === 'function',
-           'onsession callback not specified');
     // Route through safeCallbackInvoke so that a synchronous throw or a
     // rejected promise from the user's onsession callback destroys this
     // endpoint with the error rather than surfacing as an unhandled
     // exception or unhandled rejection coming out of the C++ -> JS
     // boundary.
-    safeCallbackInvoke(this.#onsession, this, session);
+    safeCallbackInvoke(inner.onsession, this, session);
   }
 
   // Called by the QuicSession when it closes to remove itself from
   // the active sessions tracked by the QuicEndpoint.
   [kRemoveSession](session) {
-    this.#sessions.delete(session);
+    this.#inner.sessions.delete(session);
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    if (depth < 0) {
+      return 'QuicEndpoint { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -4458,16 +4493,26 @@ class QuicEndpoint {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      address,
+      busy,
+      isPendingClose: closing,
+      listening,
+      sessions,
+      stats,
+      state,
+    } = this.#inner;
+
     return `QuicEndpoint ${inspect({
-      address: this.address,
-      busy: this.busy,
+      address,
+      busy,
       closed: this.closed,
-      closing: this.#isPendingClose,
+      closing,
       destroyed: this.destroyed,
-      listening: this.#listening,
-      sessions: this.#sessions,
-      stats: this.stats,
-      state: this.#state,
+      listening,
+      sessions,
+      stats,
+      state,
     }, opts)}`;
   }
 
@@ -4809,10 +4854,10 @@ function getPreferredAddressPolicy(policy = 'default') {
 
 /**
  * @param {SessionOptions} options
- * @param {{forServer: boolean, addressFamily: string}} [config]
+ * @param {ProcessSessionOptions} [config]
  * @returns {SessionOptions}
  */
-function processSessionOptions(options, config = { __proto__: null }) {
+function processSessionOptions(options, config = kEmptyObject) {
   validateObject(options, 'options');
   const {
     endpoint,
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index d32bbcce5c544a..82277b115d6e9a 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -5,7 +5,6 @@
 /* c8 ignore start */
 
 const {
-  ArrayBuffer,
   DataView,
   DataViewPrototypeGetBigInt64,
   DataViewPrototypeGetBigUint64,
@@ -16,21 +15,15 @@ const {
   DataViewPrototypeSetUint16,
   DataViewPrototypeSetUint32,
   DataViewPrototypeSetUint8,
-  Float32Array,
   JSONStringify,
-  Uint8Array,
+  Number,
 } = primordials;
 
-// Determine native byte order. The shared state buffer is written by
-// C++ in native byte order, so DataView reads must match.
-const kIsLittleEndian = (() => {
-  // -1 as float32 is 0xBF800000. On little-endian, the bytes are
-  // [0x00, 0x00, 0x80, 0xBF], so byte[3] is 0xBF (non-zero).
-  // On big-endian, the bytes are [0xBF, 0x80, 0x00, 0x00], so byte[3] is 0.
-  const buf = new Float32Array(1);
-  buf[0] = -1;
-  return new Uint8Array(buf.buffer)[3] !== 0;
-})();
+const {
+  isBigEndian,
+} = internalBinding('os');
+
+const kIsLittleEndian = !isBigEndian;
 
 const {
   getOptionValue,
@@ -58,8 +51,6 @@ const {
   kFinishClose,
   kInspect,
   kPrivateConstructor,
-  kWantsHeaders,
-  kWantsTrailers,
 } = require('internal/quic/symbols');
 
 // This file defines the helper objects for accessing state for
@@ -155,6 +146,11 @@ assert(IDX_STATE_STREAM_WANTS_TRAILERS !== undefined);
 assert(IDX_STATE_STREAM_WRITE_DESIRED_SIZE !== undefined);
 assert(IDX_STATE_STREAM_RESET_CODE !== undefined);
 
+const kEmptyObject = { __proto__: null };
+
+// The internal state objects for endpoints, sessions, and streams.
+// These are not exposed directly to users.
+
 class QuicEndpointState {
   /** @type {DataView} */
   #handle;
@@ -175,58 +171,67 @@ class QuicEndpointState {
 
   /** @type {boolean} */
   get isBound() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_BOUND);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, IDX_STATE_ENDPOINT_BOUND) !== 0;
   }
 
   /** @type {boolean} */
   get isReceiving() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_RECEIVING);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, IDX_STATE_ENDPOINT_RECEIVING) !== 0;
   }
 
   /** @type {boolean} */
   get isListening() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_LISTENING);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, IDX_STATE_ENDPOINT_LISTENING) !== 0;
   }
 
   /** @type {boolean} */
   get isClosing() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_CLOSING);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, IDX_STATE_ENDPOINT_CLOSING) !== 0;
   }
 
   /** @type {boolean} */
   get isBusy() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_BUSY);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, IDX_STATE_ENDPOINT_BUSY) !== 0;
   }
 
   /** @type {number} */
   get maxConnectionsPerHost() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint16(
-      this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, kIsLittleEndian);
+      handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, kIsLittleEndian);
   }
 
   set maxConnectionsPerHost(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     DataViewPrototypeSetUint16(
-      this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, val, kIsLittleEndian);
+      handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, val, kIsLittleEndian);
   }
 
   /** @type {number} */
   get maxConnectionsTotal() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint16(
-      this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, kIsLittleEndian);
+      handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, kIsLittleEndian);
   }
 
   set maxConnectionsTotal(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     DataViewPrototypeSetUint16(
-      this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, val, kIsLittleEndian);
+      handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, val, kIsLittleEndian);
   }
 
   /**
@@ -236,8 +241,9 @@ class QuicEndpointState {
    * @type {bigint}
    */
   get pendingCallbacks() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_ENDPOINT_PENDING_CALLBACKS, kIsLittleEndian);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetBigUint64(handle, IDX_STATE_ENDPOINT_PENDING_CALLBACKS, kIsLittleEndian);
   }
 
   toString() {
@@ -245,49 +251,70 @@ class QuicEndpointState {
   }
 
   toJSON() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {};
+    if (this.#handle === undefined) return kEmptyObject;
+    const {
+      isBound,
+      isReceiving,
+      isListening,
+      isClosing,
+      isBusy,
+      maxConnectionsPerHost,
+      maxConnectionsTotal,
+      pendingCallbacks,
+    } = this;
     return {
       __proto__: null,
-      isBound: this.isBound,
-      isReceiving: this.isReceiving,
-      isListening: this.isListening,
-      isClosing: this.isClosing,
-      isBusy: this.isBusy,
-      maxConnectionsPerHost: this.maxConnectionsPerHost,
-      maxConnectionsTotal: this.maxConnectionsTotal,
-      pendingCallbacks: `${this.pendingCallbacks}`,
+      isBound,
+      isReceiving,
+      isListening,
+      isClosing,
+      isBusy,
+      maxConnectionsPerHost,
+      maxConnectionsTotal,
+      pendingCallbacks: Number(pendingCallbacks),
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
-
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) {
+    if (this.#handle === undefined) {
       return 'QuicEndpointState { <Closed> }';
     }
 
+    if (depth < 0) {
+      return 'QuicEndpointState { }';
+    }
+
     const opts = {
       __proto__: null,
       ...options,
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      isBound,
+      isReceiving,
+      isListening,
+      isClosing,
+      isBusy,
+      maxConnectionsPerHost,
+      maxConnectionsTotal,
+      pendingCallbacks,
+    } = this;
+
     return `QuicEndpointState ${inspect({
-      isBound: this.isBound,
-      isReceiving: this.isReceiving,
-      isListening: this.isListening,
-      isClosing: this.isClosing,
-      isBusy: this.isBusy,
-      pendingCallbacks: this.pendingCallbacks,
+      isBound,
+      isReceiving,
+      isListening,
+      isClosing,
+      isBusy,
+      maxConnectionsPerHost,
+      maxConnectionsTotal,
+      pendingCallbacks,
     }, opts)}`;
   }
 
   [kFinishClose]() {
-    // Snapshot the state into a new DataView since the underlying
-    // buffer will be destroyed.
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    this.#handle = new DataView(new ArrayBuffer(0));
+    this.#handle = undefined;
   }
 }
 
@@ -324,17 +351,19 @@ class QuicSessionState {
   static #LISTENER_ORIGIN = 1 << 5;
 
   #getListenerFlag(flag) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!(DataViewPrototypeGetUint32(
-      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian) & flag);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return (DataViewPrototypeGetUint32(
+      handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian) & flag) !== 0;
   }
 
   #setListenerFlag(flag, val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     const current = DataViewPrototypeGetUint32(
-      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian);
     DataViewPrototypeSetUint32(
-      this.#handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS,
+      handle, this.#offset + IDX_STATE_SESSION_LISTENER_FLAGS,
       val ? (current | flag) : (current & ~flag), kIsLittleEndian);
   }
 
@@ -388,50 +417,58 @@ class QuicSessionState {
 
   /** @type {boolean} */
   get isClosing() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_CLOSING);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_CLOSING) !== 0;
   }
 
   /** @type {boolean} */
   get isGracefulClose() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_GRACEFUL_CLOSE);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_GRACEFUL_CLOSE) !== 0;
   }
 
   /** @type {boolean} */
   get isSilentClose() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_SILENT_CLOSE);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_SILENT_CLOSE) !== 0;
   }
 
   /** @type {boolean} */
   get isStatelessReset() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_STATELESS_RESET);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_STATELESS_RESET) !== 0;
   }
 
   /** @type {boolean} */
   get isHandshakeCompleted() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_COMPLETED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_COMPLETED) !== 0;
   }
 
   /** @type {boolean} */
   get isHandshakeConfirmed() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_CONFIRMED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_HANDSHAKE_CONFIRMED) !== 0;
   }
 
   /** @type {boolean} */
   get isStreamOpenAllowed() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_STREAM_OPEN_ALLOWED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_STREAM_OPEN_ALLOWED) !== 0;
   }
 
   /** @type {boolean} */
   get isPrioritySupported() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_PRIORITY_SUPPORTED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_PRIORITY_SUPPORTED) !== 0;
   }
 
   /**
@@ -440,20 +477,23 @@ class QuicSessionState {
    * @type {number}
    */
   get headersSupported() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_HEADERS_SUPPORTED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_HEADERS_SUPPORTED);
   }
 
   /** @type {boolean} */
   get isWrapped() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_WRAPPED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_WRAPPED) !== 0;
   }
 
   /** @type {number} */
   get applicationType() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
   }
 
   /**
@@ -464,9 +504,10 @@ class QuicSessionState {
    * @type {bigint}
    */
   get noErrorCode() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, this.#offset + IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
   }
 
   /**
@@ -479,38 +520,43 @@ class QuicSessionState {
    * @type {bigint}
    */
   get internalErrorCode() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, this.#offset + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
   }
 
   /** @type {number} */
   get maxDatagramSize() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint16(
-      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_DATAGRAM_SIZE,
+      handle, this.#offset + IDX_STATE_SESSION_MAX_DATAGRAM_SIZE,
       kIsLittleEndian);
   }
 
   /** @type {bigint} */
   get lastDatagramId() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, this.#offset + IDX_STATE_SESSION_LAST_DATAGRAM_ID,
+      handle, this.#offset + IDX_STATE_SESSION_LAST_DATAGRAM_ID,
       kIsLittleEndian);
   }
 
   /** @type {number} */
   get maxPendingDatagrams() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint16(
-      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, kIsLittleEndian);
   }
 
   set maxPendingDatagrams(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     DataViewPrototypeSetUint16(
-      this.#handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, val, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, val, kIsLittleEndian);
   }
 
   toString() {
@@ -518,78 +564,126 @@ class QuicSessionState {
   }
 
   toJSON() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {};
+    if (this.#handle === undefined) return kEmptyObject;
+    const {
+      hasPathValidationListener,
+      hasDatagramListener,
+      hasDatagramStatusListener,
+      hasSessionTicketListener,
+      hasNewTokenListener,
+      hasOriginListener,
+      isClosing,
+      isGracefulClose,
+      isSilentClose,
+      isStatelessReset,
+      isHandshakeCompleted,
+      isHandshakeConfirmed,
+      isStreamOpenAllowed,
+      isPrioritySupported,
+      headersSupported,
+      isWrapped,
+      applicationType,
+      noErrorCode,
+      internalErrorCode,
+      maxDatagramSize,
+      lastDatagramId,
+      maxPendingDatagrams,
+    } = this;
     return {
       __proto__: null,
-      hasPathValidationListener: this.hasPathValidationListener,
-      hasDatagramListener: this.hasDatagramListener,
-      hasDatagramStatusListener: this.hasDatagramStatusListener,
-      hasSessionTicketListener: this.hasSessionTicketListener,
-      hasNewTokenListener: this.hasNewTokenListener,
-      hasOriginListener: this.hasOriginListener,
-      isClosing: this.isClosing,
-      isGracefulClose: this.isGracefulClose,
-      isSilentClose: this.isSilentClose,
-      isStatelessReset: this.isStatelessReset,
-      isHandshakeCompleted: this.isHandshakeCompleted,
-      isHandshakeConfirmed: this.isHandshakeConfirmed,
-      isStreamOpenAllowed: this.isStreamOpenAllowed,
-      isPrioritySupported: this.isPrioritySupported,
-      headersSupported: this.headersSupported,
-      isWrapped: this.isWrapped,
-      applicationType: this.applicationType,
-      noErrorCode: `${this.noErrorCode}`,
-      internalErrorCode: `${this.internalErrorCode}`,
-      maxDatagramSize: `${this.maxDatagramSize}`,
-      lastDatagramId: `${this.lastDatagramId}`,
-      maxPendingDatagrams: this.maxPendingDatagrams,
+      hasPathValidationListener,
+      hasDatagramListener,
+      hasDatagramStatusListener,
+      hasSessionTicketListener,
+      hasNewTokenListener,
+      hasOriginListener,
+      isClosing,
+      isGracefulClose,
+      isSilentClose,
+      isStatelessReset,
+      isHandshakeCompleted,
+      isHandshakeConfirmed,
+      isStreamOpenAllowed,
+      isPrioritySupported,
+      headersSupported,
+      isWrapped,
+      applicationType,
+      noErrorCode: `${noErrorCode}`,
+      internalErrorCode: `${internalErrorCode}`,
+      maxDatagramSize: `${maxDatagramSize}`,
+      lastDatagramId: `${lastDatagramId}`,
+      maxPendingDatagrams,
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
-
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) {
+    if (this.#handle === undefined) {
       return 'QuicSessionState { <Closed> }';
     }
 
+    if (depth < 0) {
+      return 'QuicSessionState { }';
+    }
+
     const opts = {
       __proto__: null,
       ...options,
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      hasPathValidationListener,
+      hasDatagramListener,
+      hasDatagramStatusListener,
+      hasSessionTicketListener,
+      hasNewTokenListener,
+      hasOriginListener,
+      isClosing,
+      isGracefulClose,
+      isSilentClose,
+      isStatelessReset,
+      isHandshakeCompleted,
+      isHandshakeConfirmed,
+      isStreamOpenAllowed,
+      isPrioritySupported,
+      headersSupported,
+      isWrapped,
+      applicationType,
+      noErrorCode,
+      internalErrorCode,
+      maxDatagramSize,
+      lastDatagramId,
+      maxPendingDatagrams,
+    } = this;
+
     return `QuicSessionState ${inspect({
-      hasPathValidationListener: this.hasPathValidationListener,
-      hasDatagramListener: this.hasDatagramListener,
-      hasDatagramStatusListener: this.hasDatagramStatusListener,
-      hasSessionTicketListener: this.hasSessionTicketListener,
-      hasNewTokenListener: this.hasNewTokenListener,
-      hasOriginListener: this.hasOriginListener,
-      isClosing: this.isClosing,
-      isGracefulClose: this.isGracefulClose,
-      isSilentClose: this.isSilentClose,
-      isStatelessReset: this.isStatelessReset,
-      isHandshakeCompleted: this.isHandshakeCompleted,
-      isHandshakeConfirmed: this.isHandshakeConfirmed,
-      isStreamOpenAllowed: this.isStreamOpenAllowed,
-      isPrioritySupported: this.isPrioritySupported,
-      headersSupported: this.headersSupported,
-      isWrapped: this.isWrapped,
-      applicationType: this.applicationType,
-      noErrorCode: this.noErrorCode,
-      internalErrorCode: this.internalErrorCode,
-      maxDatagramSize: this.maxDatagramSize,
-      lastDatagramId: this.lastDatagramId,
+      hasPathValidationListener,
+      hasDatagramListener,
+      hasDatagramStatusListener,
+      hasSessionTicketListener,
+      hasNewTokenListener,
+      hasOriginListener,
+      isClosing,
+      isGracefulClose,
+      isSilentClose,
+      isStatelessReset,
+      isHandshakeCompleted,
+      isHandshakeConfirmed,
+      isStreamOpenAllowed,
+      isPrioritySupported,
+      headersSupported,
+      isWrapped,
+      applicationType,
+      noErrorCode,
+      internalErrorCode,
+      maxDatagramSize,
+      lastDatagramId,
+      maxPendingDatagrams,
     }, opts)}`;
   }
 
   [kFinishClose]() {
-    // Snapshot the state into a new DataView since the underlying
-    // buffer will be destroyed.
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    this.#handle = new DataView(new ArrayBuffer(0));
+    this.#handle = undefined;
   }
 }
 
@@ -598,6 +692,8 @@ class QuicStreamState {
   #handle;
   /** @type {number} */
   #offset = 0;
+  /** @type {bigint|undefined} */
+  #id = undefined;
 
   /**
    * @param {symbol} privateSymbol
@@ -618,144 +714,166 @@ class QuicStreamState {
 
   /** @type {bigint} */
   get id() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return DataViewPrototypeGetBigInt64(this.#handle, this.#offset + IDX_STATE_STREAM_ID, kIsLittleEndian);
+    const handle = this.#handle;
+    if (handle === undefined) return this.#id;
+    return DataViewPrototypeGetBigInt64(handle, this.#offset + IDX_STATE_STREAM_ID, kIsLittleEndian);
   }
 
   /** @type {boolean} */
   get pending() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_PENDING);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_PENDING) !== 0;
   }
 
   /** @type {boolean} */
   get finSent() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_FIN_SENT);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_FIN_SENT) !== 0;
   }
 
   /** @type {boolean} */
   get finReceived() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_FIN_RECEIVED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_FIN_RECEIVED) !== 0;
   }
 
   /** @type {boolean} */
   get readEnded() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_READ_ENDED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_READ_ENDED) !== 0;
   }
 
   /** @type {boolean} */
   get writeEnded() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_ENDED);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WRITE_ENDED) !== 0;
   }
 
-
   /** @type {boolean} */
   get reset() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_RESET);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_RESET) !== 0;
   }
 
   /** @type {boolean} */
   get hasOutbound() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_HAS_OUTBOUND);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_HAS_OUTBOUND) !== 0;
   }
 
   /** @type {boolean} */
   get hasReader() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_HAS_READER);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_HAS_READER) !== 0;
   }
 
   /** @type {boolean} */
   get wantsBlock() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK) !== 0;
   }
 
   /** @type {boolean} */
   set wantsBlock(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0);
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0);
   }
 
   /** @type {boolean} */
-  get [kWantsHeaders]() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS);
+  get wantsHeaders() {
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS) !== 0;
   }
 
   /** @type {boolean} */
-  set [kWantsHeaders](val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS, val ? 1 : 0);
+  set wantsHeaders(val) {
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_HEADERS, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get wantsReset() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET) !== 0;
   }
 
   /** @type {boolean} */
   set wantsReset(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET, val ? 1 : 0);
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_RESET, val ? 1 : 0);
   }
 
   /** @type {boolean} */
-  get [kWantsTrailers]() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS);
+  get wantsTrailers() {
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS) !== 0;
   }
 
   /** @type {boolean} */
-  set [kWantsTrailers](val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    DataViewPrototypeSetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS, val ? 1 : 0);
+  set wantsTrailers(val) {
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_TRAILERS, val ? 1 : 0);
   }
 
   /** @type {boolean} */
   get early() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
-    return !!DataViewPrototypeGetUint8(this.#handle, this.#offset + IDX_STATE_STREAM_RECEIVED_EARLY_DATA);
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_RECEIVED_EARLY_DATA) !== 0;
   }
 
   /** @type {bigint} */
   get resetCode() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetBigUint64(
-      this.#handle, this.#offset + IDX_STATE_STREAM_RESET_CODE, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_STREAM_RESET_CODE, kIsLittleEndian);
   }
 
   /** @type {bigint} */
   get writeDesiredSize() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint32(
-      this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, kIsLittleEndian);
   }
 
   set writeDesiredSize(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     DataViewPrototypeSetUint32(
-      this.#handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, val, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, val, kIsLittleEndian);
   }
 
   /** @type {number} */
   get highWaterMark() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined;
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint32(
-      this.#handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, kIsLittleEndian);
   }
 
   set highWaterMark(val) {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
+    const handle = this.#handle;
+    if (handle === undefined) return;
     DataViewPrototypeSetUint32(
-      this.#handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, val, kIsLittleEndian);
+      handle, this.#offset + IDX_STATE_STREAM_HIGH_WATER_MARK, val, kIsLittleEndian);
   }
 
   toString() {
@@ -763,59 +881,108 @@ class QuicStreamState {
   }
 
   toJSON() {
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {};
+    if (this.#handle === undefined) return kEmptyObject;
+    const {
+      id,
+      pending,
+      finSent,
+      finReceived,
+      readEnded,
+      writeEnded,
+      reset,
+      hasOutbound,
+      hasReader,
+      wantsBlock,
+      wantsReset,
+      wantsHeaders,
+      wantsTrailers,
+      early,
+      resetCode,
+      writeDesiredSize,
+      highWaterMark,
+    } = this;
     return {
       __proto__: null,
-      id: `${this.id}`,
-      pending: this.pending,
-      finSent: this.finSent,
-      finReceived: this.finReceived,
-      readEnded: this.readEnded,
-      writeEnded: this.writeEnded,
-      reset: this.reset,
-      hasOutbound: this.hasOutbound,
-      hasReader: this.hasReader,
-      wantsBlock: this.wantsBlock,
-      wantsReset: this.wantsReset,
-      early: this.early,
+      id: `${id}`,
+      pending,
+      finSent,
+      finReceived,
+      readEnded,
+      writeEnded,
+      reset,
+      hasOutbound,
+      hasReader,
+      wantsBlock,
+      wantsReset,
+      wantsHeaders,
+      wantsTrailers,
+      early,
+      resetCode,
+      writeDesiredSize,
+      highWaterMark,
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
-
     if (DataViewPrototypeGetByteLength(this.#handle) === 0) {
       return 'QuicStreamState { <Closed> }';
     }
 
+    if (depth < 0) {
+      return 'QuicStreamState { }';
+    }
+
     const opts = {
       __proto__: null,
       ...options,
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      id,
+      pending,
+      finSent,
+      finReceived,
+      readEnded,
+      writeEnded,
+      reset,
+      hasOutbound,
+      hasReader,
+      wantsBlock,
+      wantsReset,
+      wantsHeaders,
+      wantsTrailers,
+      early,
+      resetCode,
+      writeDesiredSize,
+      highWaterMark,
+    } = this;
+
     return `QuicStreamState ${inspect({
-      id: this.id,
-      pending: this.pending,
-      finSent: this.finSent,
-      finReceived: this.finReceived,
-      readEnded: this.readEnded,
-      writeEnded: this.writeEnded,
-      reset: this.reset,
-      hasOutbound: this.hasOutbound,
-      hasReader: this.hasReader,
-      wantsBlock: this.wantsBlock,
-      wantsReset: this.wantsReset,
-      early: this.early,
+      id,
+      pending,
+      finSent,
+      finReceived,
+      readEnded,
+      writeEnded,
+      reset,
+      hasOutbound,
+      hasReader,
+      wantsBlock,
+      wantsReset,
+      wantsHeaders,
+      wantsTrailers,
+      early,
+      resetCode,
+      writeDesiredSize,
+      highWaterMark,
     }, opts)}`;
   }
 
   [kFinishClose]() {
-    // Snapshot the state into a new DataView since the underlying
-    // buffer will be destroyed.
-    if (DataViewPrototypeGetByteLength(this.#handle) === 0) return;
-    this.#handle = new DataView(new ArrayBuffer(0));
+    // Cache the stream ID since the buffer will be zeroed out and the ID will be lost.
+    this.#id = this.id;
+    this.#handle = undefined;
   }
 }
 
diff --git a/lib/internal/quic/stats.js b/lib/internal/quic/stats.js
index 27a986f4d0549e..9ffbff8df201cb 100644
--- a/lib/internal/quic/stats.js
+++ b/lib/internal/quic/stats.js
@@ -7,6 +7,8 @@
 const {
   BigUint64Array,
   JSONStringify,
+  Symbol,
+  TypedArrayPrototypeSubarray,
 } = primordials;
 
 const {
@@ -25,6 +27,7 @@ const {
   codes: {
     ERR_ILLEGAL_CONSTRUCTOR,
     ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_THIS,
   },
 } = require('internal/errors');
 
@@ -88,11 +91,11 @@ const {
   IDX_STATS_SESSION_BYTES_LOST,
   IDX_STATS_SESSION_PING_RECV,
   IDX_STATS_SESSION_PKT_DISCARDED,
-
   IDX_STATS_SESSION_DATAGRAMS_RECEIVED,
   IDX_STATS_SESSION_DATAGRAMS_SENT,
   IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED,
   IDX_STATS_SESSION_DATAGRAMS_LOST,
+  IDX_STATS_SESSION_COUNT,
 
   IDX_STATS_STREAM_CREATED_AT,
   IDX_STATS_STREAM_OPENED_AT,
@@ -105,6 +108,7 @@ const {
   IDX_STATS_STREAM_MAX_OFFSET_ACK,
   IDX_STATS_STREAM_MAX_OFFSET_RECV,
   IDX_STATS_STREAM_FINAL_SIZE,
+  IDX_STATS_STREAM_COUNT,
 } = internalBinding('quic');
 
 assert(IDX_STATS_ENDPOINT_CREATED_AT !== undefined);
@@ -162,6 +166,23 @@ assert(IDX_STATS_STREAM_MAX_OFFSET !== undefined);
 assert(IDX_STATS_STREAM_MAX_OFFSET_ACK !== undefined);
 assert(IDX_STATS_STREAM_MAX_OFFSET_RECV !== undefined);
 assert(IDX_STATS_STREAM_FINAL_SIZE !== undefined);
+assert(IDX_STATS_STREAM_COUNT !== undefined);
+assert(IDX_STATS_SESSION_COUNT !== undefined);
+
+const kCreateDisconnected = Symbol('kCreateDisconnected');
+
+let assertIsQuicEndpointStats;
+let assertIsQuicSessionStats;
+let assertIsQuicStreamStats;
+let isQuicEndpointStats;
+let isQuicSessionStats;
+let isQuicStreamStats;
+
+function assertIsPrivateConstructor(privateSymbol) {
+  if (privateSymbol !== kPrivateConstructor) {
+    throw new ERR_ILLEGAL_CONSTRUCTOR();
+  }
+}
 
 class QuicEndpointStats {
   /** @type {BigUint64Array} */
@@ -169,6 +190,18 @@ class QuicEndpointStats {
   /** @type {boolean} */
   #disconnected = false;
 
+  static {
+    isQuicEndpointStats = function(val) {
+      return val != null && typeof val === 'object' && #handle in val;
+    };
+
+    assertIsQuicEndpointStats = function(val) {
+      if (!isQuicEndpointStats(val)) {
+        throw new ERR_INVALID_THIS('QuicEndpointStats');
+      }
+    };
+  }
+
   /**
    * @param {symbol} privateSymbol
    * @param {ArrayBuffer} buffer
@@ -176,9 +209,7 @@ class QuicEndpointStats {
   constructor(privateSymbol, buffer) {
     // We use the kPrivateConstructor symbol to restrict the ability to
     // create new instances of QuicEndpointStats to internal code.
-    if (privateSymbol !== kPrivateConstructor) {
-      throw new ERR_ILLEGAL_CONSTRUCTOR();
-    }
+    assertIsPrivateConstructor(privateSymbol);
     if (!isArrayBuffer(buffer)) {
       throw new ERR_INVALID_ARG_TYPE('buffer', ['ArrayBuffer'], buffer);
     }
@@ -187,66 +218,79 @@ class QuicEndpointStats {
 
   /** @type {bigint} */
   get createdAt() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_CREATED_AT];
   }
 
   /** @type {bigint} */
   get destroyedAt() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_DESTROYED_AT];
   }
 
   /** @type {bigint} */
   get bytesReceived() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_BYTES_RECEIVED];
   }
 
   /** @type {bigint} */
   get bytesSent() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_BYTES_SENT];
   }
 
   /** @type {bigint} */
   get packetsReceived() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_PACKETS_RECEIVED];
   }
 
   /** @type {bigint} */
   get packetsSent() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_PACKETS_SENT];
   }
 
   /** @type {bigint} */
   get serverSessions() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_SERVER_SESSIONS];
   }
 
   /** @type {bigint} */
   get clientSessions() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_CLIENT_SESSIONS];
   }
 
   /** @type {bigint} */
   get serverBusyCount() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_SERVER_BUSY_COUNT];
   }
 
   /** @type {bigint} */
   get retryCount() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_RETRY_COUNT];
   }
 
   /** @type {bigint} */
   get versionNegotiationCount() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_VERSION_NEGOTIATION_COUNT];
   }
 
   /** @type {bigint} */
   get statelessResetCount() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_STATELESS_RESET_COUNT];
   }
 
   /** @type {bigint} */
   get immediateCloseCount() {
+    assertIsQuicEndpointStats(this);
     return this.#handle[IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT];
   }
 
@@ -255,30 +299,48 @@ class QuicEndpointStats {
   }
 
   toJSON() {
+    assertIsQuicEndpointStats(this);
+    const {
+      createdAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      packetsReceived,
+      packetsSent,
+      serverSessions,
+      clientSessions,
+      serverBusyCount,
+      retryCount,
+      versionNegotiationCount,
+      statelessResetCount,
+      immediateCloseCount,
+    } = this;
     return {
       __proto__: null,
       connected: this.isConnected,
       // We need to convert the values to strings because JSON does not
       // support BigInts.
-      createdAt: `${this.createdAt}`,
-      destroyedAt: `${this.destroyedAt}`,
-      bytesReceived: `${this.bytesReceived}`,
-      bytesSent: `${this.bytesSent}`,
-      packetsReceived: `${this.packetsReceived}`,
-      packetsSent: `${this.packetsSent}`,
-      serverSessions: `${this.serverSessions}`,
-      clientSessions: `${this.clientSessions}`,
-      serverBusyCount: `${this.serverBusyCount}`,
-      retryCount: `${this.retryCount}`,
-      versionNegotiationCount: `${this.versionNegotiationCount}`,
-      statelessResetCount: `${this.statelessResetCount}`,
-      immediateCloseCount: `${this.immediateCloseCount}`,
+      createdAt: `${createdAt}`,
+      destroyedAt: `${destroyedAt}`,
+      bytesReceived: `${bytesReceived}`,
+      bytesSent: `${bytesSent}`,
+      packetsReceived: `${packetsReceived}`,
+      packetsSent: `${packetsSent}`,
+      serverSessions: `${serverSessions}`,
+      clientSessions: `${clientSessions}`,
+      serverBusyCount: `${serverBusyCount}`,
+      retryCount: `${retryCount}`,
+      versionNegotiationCount: `${versionNegotiationCount}`,
+      statelessResetCount: `${statelessResetCount}`,
+      immediateCloseCount: `${immediateCloseCount}`,
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    assertIsQuicEndpointStats(this);
+    if (depth < 0) {
+      return 'QuicEndpointStats { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -286,21 +348,37 @@ class QuicEndpointStats {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      createdAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      packetsReceived,
+      packetsSent,
+      serverSessions,
+      clientSessions,
+      serverBusyCount,
+      retryCount,
+      versionNegotiationCount,
+      statelessResetCount,
+      immediateCloseCount,
+    } = this;
+
     return `QuicEndpointStats ${inspect({
       connected: this.isConnected,
-      createdAt: this.createdAt,
-      destroyedAt: this.destroyedAt,
-      bytesReceived: this.bytesReceived,
-      bytesSent: this.bytesSent,
-      packetsReceived: this.packetsReceived,
-      packetsSent: this.packetsSent,
-      serverSessions: this.serverSessions,
-      clientSessions: this.clientSessions,
-      serverBusyCount: this.serverBusyCount,
-      retryCount: this.retryCount,
-      versionNegotiationCount: this.versionNegotiationCount,
-      statelessResetCount: this.statelessResetCount,
-      immediateCloseCount: this.immediateCloseCount,
+      createdAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      packetsReceived,
+      packetsSent,
+      serverSessions,
+      clientSessions,
+      serverBusyCount,
+      retryCount,
+      versionNegotiationCount,
+      statelessResetCount,
+      immediateCloseCount,
     }, opts)}`;
   }
 
@@ -311,12 +389,11 @@ class QuicEndpointStats {
    * @type {boolean}
    */
   get isConnected() {
+    assertIsQuicEndpointStats(this);
     return !this.#disconnected;
   }
 
   [kFinishClose]() {
-    // Snapshot the stats into a new BigUint64Array since the underlying
-    // buffer will be destroyed.
     this.#handle = new BigUint64Array(this.#handle);
     this.#disconnected = true;
   }
@@ -325,22 +402,31 @@ class QuicEndpointStats {
 class QuicSessionStats {
   /** @type {BigUint64Array} */
   #handle;
-  /** @type {boolean} */
   #disconnected = false;
+  #offset = 0;
+
+  static {
+    isQuicSessionStats = function(val) {
+      return val != null && typeof val === 'object' && #handle in val;
+    };
+
+    assertIsQuicSessionStats = function(val) {
+      if (!isQuicSessionStats(val)) {
+        throw new ERR_INVALID_THIS('QuicSessionStats');
+      }
+    };
+  }
+
 
   /**
    * @param {symbol} privateSymbol
-   * @param {ArrayBuffer} buffer
+   * @param {ArrayBuffer} view
+   * @param {number} [byteOffset]
    */
-  /** @type {number} */
-  #offset = 0;
-
   constructor(privateSymbol, view, byteOffset = 0) {
     // We use the kPrivateConstructor symbol to restrict the ability to
     // create new instances of QuicSessionStats to internal code.
-    if (privateSymbol !== kPrivateConstructor) {
-      throw new ERR_ILLEGAL_CONSTRUCTOR();
-    }
+    assertIsPrivateConstructor(privateSymbol);
     if (isArrayBuffer(view)) {
       this.#handle = new BigUint64Array(view);
     } else {
@@ -351,148 +437,179 @@ class QuicSessionStats {
 
   /** @type {bigint} */
   get createdAt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_CREATED_AT];
   }
 
   /** @type {bigint} */
   get destroyedAt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_DESTROYED_AT];
   }
 
   /** @type {bigint} */
   get closingAt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_CLOSING_AT];
   }
 
   /** @type {bigint} */
   get handshakeCompletedAt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT];
   }
 
   /** @type {bigint} */
   get handshakeConfirmedAt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT];
   }
 
   /** @type {bigint} */
   get bytesReceived() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_RECEIVED];
   }
 
   /** @type {bigint} */
   get bidiInStreamCount() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get bidiOutStreamCount() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get uniInStreamCount() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_UNI_IN_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get uniOutStreamCount() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_UNI_OUT_STREAM_COUNT];
   }
 
   /** @type {bigint} */
   get maxBytesInFlight() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT];
   }
 
   /** @type {bigint} */
   get bytesInFlight() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_IN_FLIGHT];
   }
 
   /** @type {bigint} */
   get blockCount() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BLOCK_COUNT];
   }
 
   /** @type {bigint} */
   get cwnd() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_CWND];
   }
 
   /** @type {bigint} */
   get latestRtt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_LATEST_RTT];
   }
 
   /** @type {bigint} */
   get minRtt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_MIN_RTT];
   }
 
   /** @type {bigint} */
   get rttVar() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_RTTVAR];
   }
 
   /** @type {bigint} */
   get smoothedRtt() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_SMOOTHED_RTT];
   }
 
   /** @type {bigint} */
   get ssthresh() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_SSTHRESH];
   }
 
   get pktSent() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_SENT];
   }
 
   get bytesSent() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_SENT];
   }
 
   get pktRecv() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_RECV];
   }
 
   get bytesRecv() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_RECV];
   }
 
   get pktLost() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_LOST];
   }
 
   get bytesLost() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_BYTES_LOST];
   }
 
   get pingRecv() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_PING_RECV];
   }
 
   get pktDiscarded() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_PKT_DISCARDED];
   }
 
   /** @type {bigint} */
   get datagramsReceived() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_RECEIVED];
   }
 
   /** @type {bigint} */
   get datagramsSent() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_SENT];
   }
 
   /** @type {bigint} */
   get datagramsAcknowledged() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED];
   }
 
   /** @type {bigint} */
   get datagramsLost() {
+    assertIsQuicSessionStats(this);
     return this.#handle[this.#offset + IDX_STATS_SESSION_DATAGRAMS_LOST];
   }
 
@@ -501,47 +618,81 @@ class QuicSessionStats {
   }
 
   toJSON() {
+    assertIsQuicSessionStats(this);
+    const {
+      createdAt,
+      closingAt,
+      handshakeCompletedAt,
+      handshakeConfirmedAt,
+      bytesReceived,
+      bidiInStreamCount,
+      bidiOutStreamCount,
+      uniInStreamCount,
+      uniOutStreamCount,
+      maxBytesInFlight,
+      bytesInFlight,
+      blockCount,
+      cwnd,
+      latestRtt,
+      minRtt,
+      rttVar,
+      smoothedRtt,
+      ssthresh,
+      pktSent,
+      bytesSent,
+      pktRecv,
+      bytesRecv,
+      pktLost,
+      bytesLost,
+      pingRecv,
+      pktDiscarded,
+      datagramsReceived,
+      datagramsSent,
+      datagramsAcknowledged,
+      datagramsLost,
+    } = this;
     return {
       __proto__: null,
       connected: this.isConnected,
       // We need to convert the values to strings because JSON does not
       // support BigInts.
-      createdAt: `${this.createdAt}`,
-      closingAt: `${this.closingAt}`,
-      handshakeCompletedAt: `${this.handshakeCompletedAt}`,
-      handshakeConfirmedAt: `${this.handshakeConfirmedAt}`,
-      bytesReceived: `${this.bytesReceived}`,
-      bidiInStreamCount: `${this.bidiInStreamCount}`,
-      bidiOutStreamCount: `${this.bidiOutStreamCount}`,
-      uniInStreamCount: `${this.uniInStreamCount}`,
-      uniOutStreamCount: `${this.uniOutStreamCount}`,
-      maxBytesInFlight: `${this.maxBytesInFlight}`,
-      bytesInFlight: `${this.bytesInFlight}`,
-      blockCount: `${this.blockCount}`,
-      cwnd: `${this.cwnd}`,
-      latestRtt: `${this.latestRtt}`,
-      minRtt: `${this.minRtt}`,
-      rttVar: `${this.rttVar}`,
-      smoothedRtt: `${this.smoothedRtt}`,
-      ssthresh: `${this.ssthresh}`,
-      pktSent: `${this.pktSent}`,
-      bytesSent: `${this.bytesSent}`,
-      pktRecv: `${this.pktRecv}`,
-      bytesRecv: `${this.bytesRecv}`,
-      pktLost: `${this.pktLost}`,
-      bytesLost: `${this.bytesLost}`,
-      pingRecv: `${this.pingRecv}`,
-      pktDiscarded: `${this.pktDiscarded}`,
-      datagramsReceived: `${this.datagramsReceived}`,
-      datagramsSent: `${this.datagramsSent}`,
-      datagramsAcknowledged: `${this.datagramsAcknowledged}`,
-      datagramsLost: `${this.datagramsLost}`,
+      createdAt: `${createdAt}`,
+      closingAt: `${closingAt}`,
+      handshakeCompletedAt: `${handshakeCompletedAt}`,
+      handshakeConfirmedAt: `${handshakeConfirmedAt}`,
+      bytesReceived: `${bytesReceived}`,
+      bidiInStreamCount: `${bidiInStreamCount}`,
+      bidiOutStreamCount: `${bidiOutStreamCount}`,
+      uniInStreamCount: `${uniInStreamCount}`,
+      uniOutStreamCount: `${uniOutStreamCount}`,
+      maxBytesInFlight: `${maxBytesInFlight}`,
+      bytesInFlight: `${bytesInFlight}`,
+      blockCount: `${blockCount}`,
+      cwnd: `${cwnd}`,
+      latestRtt: `${latestRtt}`,
+      minRtt: `${minRtt}`,
+      rttVar: `${rttVar}`,
+      smoothedRtt: `${smoothedRtt}`,
+      ssthresh: `${ssthresh}`,
+      pktSent: `${pktSent}`,
+      bytesSent: `${bytesSent}`,
+      pktRecv: `${pktRecv}`,
+      bytesRecv: `${bytesRecv}`,
+      pktLost: `${pktLost}`,
+      bytesLost: `${bytesLost}`,
+      pingRecv: `${pingRecv}`,
+      pktDiscarded: `${pktDiscarded}`,
+      datagramsReceived: `${datagramsReceived}`,
+      datagramsSent: `${datagramsSent}`,
+      datagramsAcknowledged: `${datagramsAcknowledged}`,
+      datagramsLost: `${datagramsLost}`,
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    if (depth < 0) {
+      return 'QuicSessionStats { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -549,38 +700,71 @@ class QuicSessionStats {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      createdAt,
+      closingAt,
+      handshakeCompletedAt,
+      handshakeConfirmedAt,
+      bytesReceived,
+      bidiInStreamCount,
+      bidiOutStreamCount,
+      uniInStreamCount,
+      uniOutStreamCount,
+      maxBytesInFlight,
+      bytesInFlight,
+      blockCount,
+      cwnd,
+      latestRtt,
+      minRtt,
+      rttVar,
+      smoothedRtt,
+      ssthresh,
+      pktSent,
+      bytesSent,
+      pktRecv,
+      bytesRecv,
+      pktLost,
+      bytesLost,
+      pingRecv,
+      pktDiscarded,
+      datagramsReceived,
+      datagramsSent,
+      datagramsAcknowledged,
+      datagramsLost,
+    } = this;
+
     return `QuicSessionStats ${inspect({
       connected: this.isConnected,
-      createdAt: this.createdAt,
-      closingAt: this.closingAt,
-      handshakeCompletedAt: this.handshakeCompletedAt,
-      handshakeConfirmedAt: this.handshakeConfirmedAt,
-      bytesReceived: this.bytesReceived,
-      bidiInStreamCount: this.bidiInStreamCount,
-      bidiOutStreamCount: this.bidiOutStreamCount,
-      uniInStreamCount: this.uniInStreamCount,
-      uniOutStreamCount: this.uniOutStreamCount,
-      maxBytesInFlight: this.maxBytesInFlight,
-      bytesInFlight: this.bytesInFlight,
-      blockCount: this.blockCount,
-      cwnd: this.cwnd,
-      latestRtt: this.latestRtt,
-      minRtt: this.minRtt,
-      rttVar: this.rttVar,
-      smoothedRtt: this.smoothedRtt,
-      ssthresh: this.ssthresh,
-      pktSent: this.pktSent,
-      bytesSent: this.bytesSent,
-      pktRecv: this.pktRecv,
-      bytesRecv: this.bytesRecv,
-      pktLost: this.pktLost,
-      bytesLost: this.bytesLost,
-      pingRecv: this.pingRecv,
-      pktDiscarded: this.pktDiscarded,
-      datagramsReceived: this.datagramsReceived,
-      datagramsSent: this.datagramsSent,
-      datagramsAcknowledged: this.datagramsAcknowledged,
-      datagramsLost: this.datagramsLost,
+      createdAt,
+      closingAt,
+      handshakeCompletedAt,
+      handshakeConfirmedAt,
+      bytesReceived,
+      bidiInStreamCount,
+      bidiOutStreamCount,
+      uniInStreamCount,
+      uniOutStreamCount,
+      maxBytesInFlight,
+      bytesInFlight,
+      blockCount,
+      cwnd,
+      latestRtt,
+      minRtt,
+      rttVar,
+      smoothedRtt,
+      ssthresh,
+      pktSent,
+      bytesSent,
+      pktRecv,
+      bytesRecv,
+      pktLost,
+      bytesLost,
+      pingRecv,
+      pktDiscarded,
+      datagramsReceived,
+      datagramsSent,
+      datagramsAcknowledged,
+      datagramsLost,
     }, opts)}`;
   }
 
@@ -595,13 +779,10 @@ class QuicSessionStats {
   }
 
   [kFinishClose]() {
-    // Snapshot this session's stats slice into a standalone BigUint64Array.
-    const count = IDX_STATS_SESSION_DATAGRAMS_LOST + 1;
-    const snapshot = new BigUint64Array(count);
-    for (let i = 0; i < count; i++) {
-      snapshot[i] = this.#handle[this.#offset + i];
-    }
-    this.#handle = snapshot;
+    const view = TypedArrayPrototypeSubarray(this.#handle,
+                                             this.#offset,
+                                             this.#offset + IDX_STATS_STREAM_COUNT);
+    this.#handle = new BigUint64Array(view);
     this.#offset = 0;
     this.#disconnected = true;
   }
@@ -610,11 +791,21 @@ class QuicSessionStats {
 class QuicStreamStats {
   /** @type {BigUint64Array} */
   #handle;
-  /** @type {number} */
   #offset = 0;
-  /** type {boolean} */
   #disconnected = false;
 
+  static {
+    isQuicStreamStats = function(val) {
+      return val != null && typeof val === 'object' && #handle in val;
+    };
+
+    assertIsQuicStreamStats = function(val) {
+      if (!isQuicStreamStats(val)) {
+        throw new ERR_INVALID_THIS('QuicStreamStats');
+      }
+    };
+  }
+
   /**
    * @param {symbol} privateSymbol
    * @param {BigUint64Array|ArrayBuffer} view
@@ -623,70 +814,78 @@ class QuicStreamStats {
   constructor(privateSymbol, view, byteOffset = 0) {
     // We use the kPrivateConstructor symbol to restrict the ability to
     // create new instances of QuicStreamStats to internal code.
-    if (privateSymbol !== kPrivateConstructor) {
-      throw new ERR_ILLEGAL_CONSTRUCTOR();
-    }
+    assertIsPrivateConstructor(privateSymbol);
     if (isArrayBuffer(view)) {
       this.#handle = new BigUint64Array(view);
     } else {
       this.#handle = view;
     }
-    // Convert byte offset to element offset (8 bytes per uint64).
     this.#offset = byteOffset / 8;
   }
 
   /** @type {bigint} */
   get createdAt() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_CREATED_AT];
   }
 
   /** @type {bigint} */
   get openedAt() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_OPENED_AT];
   }
 
   /** @type {bigint} */
   get receivedAt() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_RECEIVED_AT];
   }
 
   /** @type {bigint} */
   get ackedAt() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_ACKED_AT];
   }
 
   /** @type {bigint} */
   get destroyedAt() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_DESTROYED_AT];
   }
 
   /** @type {bigint} */
   get bytesReceived() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_BYTES_RECEIVED];
   }
 
   /** @type {bigint} */
   get bytesSent() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_BYTES_SENT];
   }
 
   /** @type {bigint} */
   get maxOffset() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET];
   }
 
   /** @type {bigint} */
   get maxOffsetAcknowledged() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET_ACK];
   }
 
   /** @type {bigint} */
   get maxOffsetReceived() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_OFFSET_RECV];
   }
 
   /** @type {bigint} */
   get finalSize() {
+    assertIsQuicStreamStats(this);
     return this.#handle[this.#offset + IDX_STATS_STREAM_FINAL_SIZE];
   }
 
@@ -695,28 +894,43 @@ class QuicStreamStats {
   }
 
   toJSON() {
+    assertIsQuicStreamStats(this);
+    const {
+      createdAt,
+      openedAt,
+      receivedAt,
+      ackedAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      maxOffset,
+      maxOffsetAcknowledged,
+      maxOffsetReceived,
+      finalSize,
+    } = this;
     return {
       __proto__: null,
       connected: this.isConnected,
       // We need to convert the values to strings because JSON does not
       // support BigInts.
-      createdAt: `${this.createdAt}`,
-      openedAt: `${this.openedAt}`,
-      receivedAt: `${this.receivedAt}`,
-      ackedAt: `${this.ackedAt}`,
-      destroyedAt: `${this.destroyedAt}`,
-      bytesReceived: `${this.bytesReceived}`,
-      bytesSent: `${this.bytesSent}`,
-      maxOffset: `${this.maxOffset}`,
-      maxOffsetAcknowledged: `${this.maxOffsetAcknowledged}`,
-      maxOffsetReceived: `${this.maxOffsetReceived}`,
-      finalSize: `${this.finalSize}`,
+      createdAt: `${createdAt}`,
+      openedAt: `${openedAt}`,
+      receivedAt: `${receivedAt}`,
+      ackedAt: `${ackedAt}`,
+      destroyedAt: `${destroyedAt}`,
+      bytesReceived: `${bytesReceived}`,
+      bytesSent: `${bytesSent}`,
+      maxOffset: `${maxOffset}`,
+      maxOffsetAcknowledged: `${maxOffsetAcknowledged}`,
+      maxOffsetReceived: `${maxOffsetReceived}`,
+      finalSize: `${finalSize}`,
     };
   }
 
   [kInspect](depth, options) {
-    if (depth < 0)
-      return this;
+    if (depth < 0) {
+      return 'QuicStreamStats { }';
+    }
 
     const opts = {
       __proto__: null,
@@ -724,19 +938,33 @@ class QuicStreamStats {
       depth: options.depth == null ? null : options.depth - 1,
     };
 
+    const {
+      createdAt,
+      openedAt,
+      receivedAt,
+      ackedAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      maxOffset,
+      maxOffsetAcknowledged,
+      maxOffsetReceived,
+      finalSize,
+    } = this;
+
     return `QuicStreamStats ${inspect({
       connected: this.isConnected,
-      createdAt: this.createdAt,
-      openedAt: this.openedAt,
-      receivedAt: this.receivedAt,
-      ackedAt: this.ackedAt,
-      destroyedAt: this.destroyedAt,
-      bytesReceived: this.bytesReceived,
-      bytesSent: this.bytesSent,
-      maxOffset: this.maxOffset,
-      maxOffsetAcknowledged: this.maxOffsetAcknowledged,
-      maxOffsetReceived: this.maxOffsetReceived,
-      finalSize: this.finalSize,
+      createdAt,
+      openedAt,
+      receivedAt,
+      ackedAt,
+      destroyedAt,
+      bytesReceived,
+      bytesSent,
+      maxOffset,
+      maxOffsetAcknowledged,
+      maxOffsetReceived,
+      finalSize,
     }, opts)}`;
   }
 
@@ -751,22 +979,29 @@ class QuicStreamStats {
   }
 
   [kFinishClose]() {
-    // Snapshot this stream's stats slice into a standalone BigUint64Array.
-    const count = IDX_STATS_STREAM_FINAL_SIZE + 1;
-    const snapshot = new BigUint64Array(count);
-    for (let i = 0; i < count; i++) {
-      snapshot[i] = this.#handle[this.#offset + i];
-    }
-    this.#handle = snapshot;
+    const view = TypedArrayPrototypeSubarray(this.#handle,
+                                             this.#offset,
+                                             this.#offset + IDX_STATS_STREAM_COUNT);
+    this.#handle = new BigUint64Array(view);
     this.#offset = 0;
     this.#disconnected = true;
   }
+
+  // Creates an immediately disconnected QuicStreamStats object. Used when
+  // lazily creating stats for a stream that has already been destroyed.
+  static [kCreateDisconnected]() {
+    const count = IDX_STATS_STREAM_FINAL_SIZE + 1;
+    const stats = new QuicStreamStats(kPrivateConstructor, new BigUint64Array(count), 0);
+    stats.#disconnected = true;
+    return stats;
+  }
 }
 
 module.exports = {
   QuicEndpointStats,
   QuicSessionStats,
   QuicStreamStats,
+  kCreateDisconnected,
 };
 
 /* c8 ignore stop */
diff --git a/lib/internal/quic/symbols.js b/lib/internal/quic/symbols.js
index 9a8e9155f0b636..75f5b72ae22669 100644
--- a/lib/internal/quic/symbols.js
+++ b/lib/internal/quic/symbols.js
@@ -57,8 +57,6 @@ const kSendHeaders = Symbol('kSendHeaders');
 const kSessionTicket = Symbol('kSessionTicket');
 const kTrailers = Symbol('kTrailers');
 const kVersionNegotiation = Symbol('kVersionNegotiation');
-const kWantsHeaders = Symbol('kWantsHeaders');
-const kWantsTrailers = Symbol('kWantsTrailers');
 
 module.exports = {
   kAttachFileHandle,
@@ -93,8 +91,6 @@ module.exports = {
   kSessionTicket,
   kTrailers,
   kVersionNegotiation,
-  kWantsHeaders,
-  kWantsTrailers,
 };
 
 /* c8 ignore stop */
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 1cc4b8b23b510b..401775355f27d6 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -3729,6 +3729,8 @@ void Session::InitPerContext(Realm* realm, Local<Object> target) {
   SESSION_STATE(V)
 #undef V
 
+  NODE_DEFINE_CONSTANT(target, IDX_STATS_SESSION_COUNT);
+
 #define V(name, _) NODE_DEFINE_CONSTANT(target, IDX_STATS_SESSION_##name);
   SESSION_STATS(V)
   NODE_DEFINE_CONSTANT(target, IDX_STATS_SESSION_COUNT);
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index abd14300487f30..634799fb5aef75 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -983,6 +983,8 @@ void Stream::InitPerContext(Realm* realm, Local<Object> target) {
   STREAM_STATE(V)
 #undef V
 
+  NODE_DEFINE_CONSTANT(target, IDX_STATS_STREAM_COUNT);
+
   constexpr int QUIC_STREAM_HEADERS_KIND_HINTS =
       static_cast<uint8_t>(HeadersKind::HINTS);
   constexpr int QUIC_STREAM_HEADERS_KIND_INITIAL =
diff --git a/test/parallel/test-quic-h3-headers-support.mjs b/test/parallel/test-quic-h3-headers-support.mjs
index 159f5ba03faccf..5439ff5fd3a7ce 100644
--- a/test/parallel/test-quic-h3-headers-support.mjs
+++ b/test/parallel/test-quic-h3-headers-support.mjs
@@ -27,43 +27,30 @@ const serverDone = Promise.withResolvers();
 const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     // Sending headers on non-H3 stream throws.
-    throws(() => {
-      stream.sendHeaders({ ':status': '200' });
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.sendHeaders({ ':status': '200' }), { code: 'ERR_INVALID_STATE' });
 
     // Setting onheaders on non-H3 stream throws.
-    throws(() => {
-      stream.onheaders = () => {};
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.onheaders = () => {}, { code: 'ERR_INVALID_STATE' });
 
     // Setting ontrailers on non-H3 stream throws.
-    throws(() => {
-      stream.ontrailers = () => {};
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.ontrailers = () => {}, { code: 'ERR_INVALID_STATE' });
 
     // Setting oninfo on non-H3 stream throws.
-    throws(() => {
-      stream.oninfo = () => {};
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.oninfo = () => {}, { code: 'ERR_INVALID_STATE' });
 
     // Setting onwanttrailers on non-H3 stream throws.
-    throws(() => {
-      stream.onwanttrailers = () => {};
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.onwanttrailers = () => {}, { code: 'ERR_INVALID_STATE' });
 
     // sendInformationalHeaders throws on non-H3.
-    throws(() => {
-      stream.sendInformationalHeaders({ ':status': '103' });
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.sendInformationalHeaders({ ':status': '103' }), {
+      code: 'ERR_INVALID_STATE',
+    });
 
     // sendTrailers throws on non-H3.
-    throws(() => {
-      stream.sendTrailers({ 'x-trailer': 'value' });
-    }, { code: 'ERR_INVALID_STATE' });
+    throws(() => stream.sendTrailers({ 'x-trailer': 'value' }), { code: 'ERR_INVALID_STATE' });
+
+    stream.writer.endSync();
 
-    try { await stream.closed; } catch {
-      // Stream may close with error.
-    }
     serverSession.close();
     serverDone.resolve();
   });
@@ -81,15 +68,9 @@ await clientSession.opened;
 const stream = await clientSession.createBidirectionalStream({
   body: encoder.encode('ping'),
 });
-stream.closed.catch(() => {});
 
 // Client side — sending headers on non-H3 stream throws.
-throws(() => {
-  stream.sendHeaders({ ':method': 'GET' });
-}, { code: 'ERR_INVALID_STATE' });
+throws(() => stream.sendHeaders({ ':method': 'GET' }), { code: 'ERR_INVALID_STATE' });
 
-try { await stream.closed; } catch {
-  // Stream may close with error.
-}
 await serverDone.promise;
 clientSession.close();
diff --git a/test/parallel/test-quic-internal-endpoint-stats-state.mjs b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
index 57044a773eb2d6..c8e6cb89beaaef 100644
--- a/test/parallel/test-quic-internal-endpoint-stats-state.mjs
+++ b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
@@ -45,7 +45,7 @@ const {
     isBusy: false,
     maxConnectionsPerHost: 100,
     maxConnectionsTotal: 10_000,
-    pendingCallbacks: '0',
+    pendingCallbacks: 0,
   });
 
   endpoint.busy = true;
diff --git a/test/parallel/test-quic-session-stream-lifecycle.mjs b/test/parallel/test-quic-session-stream-lifecycle.mjs
index f18f82994f26dd..2eb35145dfe9fe 100644
--- a/test/parallel/test-quic-session-stream-lifecycle.mjs
+++ b/test/parallel/test-quic-session-stream-lifecycle.mjs
@@ -90,8 +90,9 @@ strictEqual(clientSession.endpoint, null);
 strictEqual(clientSession.stats.isConnected, false);
 
 strictEqual(stream.destroyed, true);
-strictEqual(stream.session, null);
-strictEqual(stream.id, null);
-strictEqual(stream.direction, null);
+
+// The stream id and direction should still be available after destruction
+strictEqual(stream.id, 0n);
+strictEqual(stream.direction, 'bidi');
 
 await serverEndpoint.close();

From 5b3c053ed71d692773a2cc8de31ad47940727f18 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 13:43:25 -0700
Subject: [PATCH 59/83] quic: fix UAF in Application::OnTimeout()

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc | 14 ++++++++------
 src/quic/session.cc     |  9 +++++++++
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index a44a60f4b48cc8..1fb85a91f24765 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -369,12 +369,14 @@ void Session::Application::SendPendingData() {
     if (closed) return;
     // Flush any remaining accumulated packets before updating stats.
     flush_batch();
-    auto& s = session();
-    if (!s.is_destroyed()) [[likely]] {
-      s.UpdatePacketTxTime();
-      s.UpdateTimer();
-      s.UpdateDataStats();
-    }
+    if (session().is_destroyed()) [[unlikely]] return;
+
+    // Get a strong pointer to protect against potential destruction during
+    // updating the time and data stats.
+    BaseObjectPtr<Session> s(session_);
+    s->UpdatePacketTxTime();
+    s->UpdateTimer();
+    s->UpdateDataStats();
   });
 
   // The maximum size of packet to create.
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 401775355f27d6..8489350ebe76e8 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -3018,6 +3018,15 @@ void Session::SendConnectionClose() {
 void Session::OnTimeout() {
   if (is_destroyed()) return;
   if (!impl_->application_) return;
+  // Hold a strong reference to prevent the Session from being freed during
+  // re-entrant calls. SendPendingData's scope guard calls UpdateTimer(),
+  // which can synchronously re-enter OnTimeout() when the timer has already
+  // expired. That re-entrant path can reach FinishClose → EmitClose →
+  // Destroy → impl_.reset() → ~Impl → RemoveSession(), dropping the last
+  // BaseObjectPtr from the endpoint map and freeing the Session. Without
+  // this guard, the outer OnTimeout / SendPendingData frames would operate
+  // on a freed object.
+  BaseObjectPtr<Session> ref(this);
   HandleScope scope(env()->isolate());
   int ret;
   {

From b621fb3a18543282277c544e56824dcd1c38a531 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 14:09:27 -0700
Subject: [PATCH 60/83] quic: fixup UAFs in bindingdata, streams, and app

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/application.cc |   3 +-
 src/quic/bindingdata.cc | 113 +++++++++++++++++++++++++++++++---------
 src/quic/bindingdata.h  |  83 +++++++++++++++++++++++++++--
 src/quic/streams.cc     |   7 ++-
 4 files changed, 174 insertions(+), 32 deletions(-)

diff --git a/src/quic/application.cc b/src/quic/application.cc
index 1fb85a91f24765..96ddf6c84cbf0e 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -369,7 +369,8 @@ void Session::Application::SendPendingData() {
     if (closed) return;
     // Flush any remaining accumulated packets before updating stats.
     flush_batch();
-    if (session().is_destroyed()) [[unlikely]] return;
+    if (session().is_destroyed()) [[unlikely]]
+      return;
 
     // Get a strong pointer to protect against potential destruction during
     // updating the time and data stats.
diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index a2719d683c6e92..402e0a25af6ee6 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -149,21 +149,87 @@ void* Nghttp3Realloc(void* ptr, size_t size, void* ud) {
 }
 }  // namespace
 
+// ============================================================================
+// CheckWrap / CheckWrapHandle
+
+void CheckWrap::Start() {
+  if (check_.data == nullptr) return;
+  uv_check_start(&check_, OnCheck);
+}
+
+void CheckWrap::Stop() {
+  if (check_.data == nullptr) return;
+  uv_check_stop(&check_);
+}
+
+void CheckWrap::Close() {
+  check_.data = nullptr;
+  env_->CloseHandle(reinterpret_cast<uv_handle_t*>(&check_), CheckClosedCb);
+}
+
+void CheckWrap::Ref() {
+  if (check_.data == nullptr) return;
+  uv_ref(reinterpret_cast<uv_handle_t*>(&check_));
+}
+
+void CheckWrap::Unref() {
+  if (check_.data == nullptr) return;
+  uv_unref(reinterpret_cast<uv_handle_t*>(&check_));
+}
+
+void CheckWrap::OnCheck(uv_check_t* check) {
+  CheckWrap* wrap = ContainerOf(&CheckWrap::check_, check);
+  wrap->fn_();
+}
+
+void CheckWrap::CheckClosedCb(uv_handle_t* handle) {
+  std::unique_ptr<CheckWrap> ptr(
+      ContainerOf(&CheckWrap::check_, reinterpret_cast<uv_check_t*>(handle)));
+}
+
+void CheckWrapHandle::Start() {
+  if (check_ != nullptr) check_->Start();
+}
+
+void CheckWrapHandle::Stop() {
+  if (check_ != nullptr) check_->Stop();
+}
+
+void CheckWrapHandle::Close() {
+  if (check_ != nullptr) {
+    check_->env()->RemoveCleanupHook(CleanupHook, this);
+    check_->Close();
+  }
+  check_ = nullptr;
+}
+
+void CheckWrapHandle::Ref() {
+  if (check_ != nullptr) check_->Ref();
+}
+
+void CheckWrapHandle::Unref() {
+  if (check_ != nullptr) check_->Unref();
+}
+
+void CheckWrapHandle::MemoryInfo(MemoryTracker* tracker) const {
+  if (check_ != nullptr) tracker->TrackField("check", *check_);
+}
+
+void CheckWrapHandle::CleanupHook(void* data) {
+  static_cast<CheckWrapHandle*>(data)->Close();
+}
+
+// ============================================================================
+
 BindingData& BindingData::Get(Environment* env) {
   return *(env->principal_realm()->GetBindingData<BindingData>());
 }
 
 BindingData::~BindingData() {
   quic_alloc_state.binding = nullptr;
-  if (flush_check_initialized_) {
-    uv_check_stop(&flush_check_);
-    flush_check_started_ = false;
-    // The check handle is closed inline here. Because BindingData destruction
-    // happens during Environment cleanup, the handle will be finalized by
-    // libuv's close phase.
-    uv_close(reinterpret_cast<uv_handle_t*>(&flush_check_), nullptr);
-    flush_check_initialized_ = false;
-  }
+  // flush_check_ is cleaned up by ~CheckWrapHandle() after the destructor
+  // body completes. The inner CheckWrap (and its uv_check_t) will be freed
+  // later by the uv_close callback, after CleanupHandles() runs uv_run().
   pending_flush_sessions_.clear();
 }
 
@@ -230,13 +296,11 @@ void BindingData::RegisterExternalReferences(
 }
 
 BindingData::BindingData(Realm* realm, Local<Object> object)
-    : BaseObject(realm, object) {
+    : BaseObject(realm, object),
+      flush_check_(env(), [this]() { OnFlushCheck(); }) {
   MakeWeak();
-  CHECK_EQ(uv_check_init(env()->event_loop(), &flush_check_), 0);
-  flush_check_.data = this;
   // Unref so the check handle doesn't keep the event loop alive on its own.
-  uv_unref(reinterpret_cast<uv_handle_t*>(&flush_check_));
-  flush_check_initialized_ = true;
+  flush_check_.Unref();
 }
 
 SessionManager& BindingData::session_manager() {
@@ -249,27 +313,26 @@ SessionManager& BindingData::session_manager() {
 void BindingData::ScheduleSessionFlush(const BaseObjectPtr<Session>& session) {
   pending_flush_sessions_.push_back(session);
   if (!flush_check_started_) {
-    uv_check_start(&flush_check_, OnFlushCheck);
+    flush_check_.Start();
     flush_check_started_ = true;
   }
 }
 
-void BindingData::OnFlushCheck(uv_check_t* handle) {
-  auto* binding = static_cast<BindingData*>(handle->data);
-  if (binding->pending_flush_sessions_.empty()) {
-    uv_check_stop(&binding->flush_check_);
-    binding->flush_check_started_ = false;
+void BindingData::OnFlushCheck() {
+  if (pending_flush_sessions_.empty()) {
+    flush_check_.Stop();
+    flush_check_started_ = false;
     return;
   }
 
-  HandleScope scope(binding->env()->isolate());
+  HandleScope scope(env()->isolate());
 
   // Swap to a local vector before iterating. SendPendingData may trigger
   // MakeCallback which runs JS that could cause more packet receives via
   // re-entry (e.g., a stream data callback that synchronously writes to
   // another session). Any sessions added during the flush remain in
   // pending_flush_sessions_ and are picked up on the next check tick.
-  auto sessions = std::move(binding->pending_flush_sessions_);
+  auto sessions = std::move(pending_flush_sessions_);
   for (auto& session : sessions) {
     session->pending_flush_ = false;
     if (!session->is_destroyed()) {
@@ -279,9 +342,9 @@ void BindingData::OnFlushCheck(uv_check_t* handle) {
 
   // If no new sessions were added during the flush, stop the check
   // to avoid per-tick callback overhead when idle.
-  if (binding->pending_flush_sessions_.empty()) {
-    uv_check_stop(&binding->flush_check_);
-    binding->flush_check_started_ = false;
+  if (pending_flush_sessions_.empty()) {
+    flush_check_.Stop();
+    flush_check_started_ = false;
   }
 }
 
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index a83c2a55c19d38..ed78d154e8f9c5 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -12,6 +12,7 @@
 #include <node_mem.h>
 #include <uv.h>
 #include <v8.h>
+#include <functional>
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ -156,6 +157,81 @@ class SessionManager;
   V(verify_private_key, "verifyPrivateKey")                                    \
   V(version, "version")
 
+// =============================================================================
+// Lightweight wrappers around uv_check_t that ensure safe handle closure.
+// The check handle is embedded in a heap-allocated CheckWrap whose destruction
+// is deferred until the uv_close callback fires, preventing use-after-free
+// when the owning object is destroyed before libuv finishes closing the handle.
+// Follows the same two-layer pattern as TimerWrap / TimerWrapHandle
+// (see timer_wrap.h).
+// TODO(@jasnell): Consider moving it out to a separate file like timer_wrap.h.
+class CheckWrap final : public MemoryRetainer {
+ public:
+  using CheckCb = std::function<void()>;
+
+  template <typename... Args>
+  explicit CheckWrap(Environment* env, Args&&... args)
+      : env_(env), fn_(std::forward<Args>(args)...) {
+    uv_check_init(env->event_loop(), &check_);
+    check_.data = this;
+  }
+
+  DISALLOW_COPY_AND_MOVE(CheckWrap)
+
+  inline Environment* env() const { return env_; }
+
+  void Start();
+  void Stop();
+  void Close();
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(CheckWrap)
+  SET_SELF_SIZE(CheckWrap)
+
+ private:
+  static void OnCheck(uv_check_t* check);
+  static void CheckClosedCb(uv_handle_t* handle);
+  ~CheckWrap() = default;
+
+  Environment* env_;
+  CheckCb fn_;
+  uv_check_t check_;
+
+  friend std::unique_ptr<CheckWrap>::deleter_type;
+};
+
+class CheckWrapHandle : public MemoryRetainer {
+ public:
+  template <typename... Args>
+  explicit CheckWrapHandle(Environment* env, Args&&... args)
+      : check_(new CheckWrap(env, std::forward<Args>(args)...)) {
+    env->AddCleanupHook(CleanupHook, this);
+  }
+
+  DISALLOW_COPY_AND_MOVE(CheckWrapHandle)
+
+  ~CheckWrapHandle() { Close(); }
+
+  inline operator bool() const { return check_ != nullptr; }
+
+  void Start();
+  void Stop();
+  void Close();
+  void Ref();
+  void Unref();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(CheckWrapHandle)
+  SET_SELF_SIZE(CheckWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+  CheckWrap* check_;
+};
+
 // =============================================================================
 // The BindingState object holds state for the internalBinding('quic') binding
 // instance. It is mostly used to hold the persistent constructors, strings, and
@@ -270,16 +346,15 @@ class BindingData final
   ArenaPtr endpoint_state_arena_{nullptr, +[](void*) {}};
   ArenaPtr endpoint_stats_arena_{nullptr, +[](void*) {}};
 
-  // Deferred send flush state. The uv_check_t fires immediately after
+  // Deferred send flush state. The CheckWrapHandle fires immediately after
   // the I/O poll phase in the same event loop tick, allowing batched
   // receive processing: all packets are read during poll, then
   // SendPendingData is called once per dirty session in the check callback.
-  uv_check_t flush_check_;
+  CheckWrapHandle flush_check_;
   std::vector<BaseObjectPtr<Session>> pending_flush_sessions_;
   bool flush_check_started_ = false;
-  bool flush_check_initialized_ = false;
 
-  static void OnFlushCheck(uv_check_t* handle);
+  void OnFlushCheck();
 };
 
 JS_METHOD_IMPL(IllegalConstructor);
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 634799fb5aef75..60ce80856638f7 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -1563,8 +1563,11 @@ void Stream::Destroy(QuicError error) {
   auto session = session_;
   session_.reset();
   // EmitClose above triggers MakeCallback which can destroy the session
-  // via JS re-entrancy. The weak pointer may now be null.
-  if (session) session->RemoveStream(id());
+  // via JS re-entrancy. The weak pointer may still be non-null (the
+  // Session BaseObject can be kept alive by a BaseObjectPtr elsewhere,
+  // e.g. OnTimeout's ref) even though impl_ has been reset. We must
+  // check is_destroyed() to avoid dereferencing the null impl_.
+  if (session && !session->is_destroyed()) session->RemoveStream(id());
 
   // Critically, make sure that the RemoveStream call is the last thing
   // trying to use this stream object. Once that call is made, the stream

From 5d1ea79a832a5cfdd16583d780e377379b92147a Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 14:26:58 -0700
Subject: [PATCH 61/83] quic: fix premature unref of endpoint when listening

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/endpoint.cc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 8a61f51b088750..46dd0231c4ff7e 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -735,7 +735,9 @@ void Endpoint::RemoveSession(const CID& cid,
     }
   }
   if (primary_session_count_ > 0 && --primary_session_count_ == 0) {
-    udp_.Unref();
+    if (!is_listening()) {
+      udp_.Unref();
+    }
     session_manager().RemoveSession(cid);
     // The endpoint may be idle (no sessions, not listening). MaybeDestroy
     // handles both closing (immediate destroy) and idle timeout (start

From f1fdf91560022a00d273e87002fe39accba3eaa6 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 14:45:16 -0700
Subject: [PATCH 62/83] quic: fixup some v8:: qualifiers

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/bindingdata.cc      |  3 ++-
 src/quic/data.cc             | 33 +++++++++++++++++++++++----------
 src/quic/preferredaddress.cc |  3 ++-
 src/quic/session.cc          | 21 ++++++++++++---------
 src/quic/streams.cc          | 21 +++++++++++----------
 src/quic/tlscontext.cc       | 11 +++++++----
 6 files changed, 57 insertions(+), 35 deletions(-)

diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index 402e0a25af6ee6..d6ceb2d2c6d2b8 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -23,6 +23,7 @@ using mem::kReserveSizeAndAlign;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::HandleScope;
+using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::String;
@@ -274,7 +275,7 @@ void BindingData::DecreaseAllocatedSize(size_t size) {
 // Forwards detailed(verbose) debugging information from nghttp3. Enabled using
 // the NODE_DEBUG_NATIVE=NGHTTP3 category.
 void nghttp3_debug_log(const char* fmt, va_list args) {
-  auto isolate = v8::Isolate::GetCurrent();
+  auto isolate = Isolate::GetCurrent();
   if (isolate == nullptr) return;
   auto env = Environment::GetCurrent(isolate);
   if (env->enabled_debug_list()->enabled(DebugCategory::NGHTTP3)) {
diff --git a/src/quic/data.cc b/src/quic/data.cc
index be2bf458d28352..d56420feae1e1b 100644
--- a/src/quic/data.cc
+++ b/src/quic/data.cc
@@ -17,7 +17,10 @@ using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
+using v8::BackingStoreOnFailureMode;
 using v8::BigInt;
+using v8::Isolate;
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
@@ -89,14 +92,14 @@ Store::Store(std::unique_ptr<BackingStore> store, size_t length, size_t offset)
 }
 
 Maybe<Store> Store::From(Local<ArrayBuffer> buffer) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  Isolate* isolate = Isolate::GetCurrent();
   Environment* env = Environment::GetCurrent(isolate->GetCurrentContext());
   auto length = buffer->ByteLength();
   auto dest = ArrayBuffer::NewBackingStore(
       isolate,
       length,
-      v8::BackingStoreInitializationMode::kUninitialized,
-      v8::BackingStoreOnFailureMode::kReturnNull);
+      BackingStoreInitializationMode::kUninitialized,
+      BackingStoreOnFailureMode::kReturnNull);
   if (!dest) {
     THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
     return Nothing<Store>();
@@ -108,15 +111,15 @@ Maybe<Store> Store::From(Local<ArrayBuffer> buffer) {
 }
 
 Maybe<Store> Store::From(Local<ArrayBufferView> view) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  Isolate* isolate = Isolate::GetCurrent();
   Environment* env = Environment::GetCurrent(isolate->GetCurrentContext());
   auto length = view->ByteLength();
   auto offset = view->ByteOffset();
   auto dest = ArrayBuffer::NewBackingStore(
       isolate,
       length,
-      v8::BackingStoreInitializationMode::kUninitialized,
-      v8::BackingStoreOnFailureMode::kReturnNull);
+      BackingStoreInitializationMode::kUninitialized,
+      BackingStoreOnFailureMode::kReturnNull);
   if (!dest) {
     THROW_ERR_MEMORY_ALLOCATION_FAILED(env);
     return Nothing<Store>();
@@ -130,24 +133,34 @@ Maybe<Store> Store::From(Local<ArrayBufferView> view) {
 }
 
 Store Store::CopyFrom(Local<ArrayBuffer> buffer) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  Isolate* isolate = Isolate::GetCurrent();
   auto backing = buffer->GetBackingStore();
   auto length = buffer->ByteLength();
   auto dest = ArrayBuffer::NewBackingStore(
-      isolate, length, v8::BackingStoreInitializationMode::kUninitialized);
+      isolate, length, BackingStoreInitializationMode::kUninitialized,
+      BackingStoreOnFailureMode::kReturnNull);
+  if (!dest) {
+    THROW_ERR_MEMORY_ALLOCATION_FAILED(Environment::GetCurrent(isolate));
+    return Store();
+  }
   // copy content
   memcpy(dest->Data(), backing->Data(), length);
   return Store(std::move(dest), length, 0);
 }
 
 Store Store::CopyFrom(Local<ArrayBufferView> view) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  Isolate* isolate = Isolate::GetCurrent();
   auto backing = view->Buffer()->GetBackingStore();
   auto length = view->ByteLength();
   auto offset = view->ByteOffset();
   auto dest = ArrayBuffer::NewBackingStore(
-      isolate, length, v8::BackingStoreInitializationMode::kUninitialized);
+      isolate, length, BackingStoreInitializationMode::kUninitialized,
+      BackingStoreOnFailureMode::kReturnNull);
   // copy content
+  if (!dest) {
+    THROW_ERR_MEMORY_ALLOCATION_FAILED(Environment::GetCurrent(isolate));
+    return Store();
+  }
   memcpy(dest->Data(), static_cast<char*>(backing->Data()) + offset, length);
   return Store(std::move(dest), length, 0);
 }
diff --git a/src/quic/preferredaddress.cc b/src/quic/preferredaddress.cc
index 3d584be2d74811..ca7908dda35c59 100644
--- a/src/quic/preferredaddress.cc
+++ b/src/quic/preferredaddress.cc
@@ -17,6 +17,7 @@ namespace node {
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
+using v8::Object;
 using v8::Value;
 
 namespace quic {
@@ -131,7 +132,7 @@ Maybe<PreferredAddress::Policy> PreferredAddress::tryGetPolicy(
                               : Just(FromV8Value<Policy>(value));
 }
 
-void PreferredAddress::Initialize(Environment* env, Local<v8::Object> target) {
+void PreferredAddress::Initialize(Environment* env, Local<Object> target) {
   // The QUIC_* constants are expected to be exported out to be used on
   // the JavaScript side of the API.
   static constexpr auto PREFERRED_ADDRESS_USE =
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 8489350ebe76e8..7737f97e98af27 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -40,7 +40,9 @@ using v8::Array;
 using v8::ArrayBufferView;
 using v8::BigInt;
 using v8::Boolean;
+using v8::Function;
 using v8::FunctionCallbackInfo;
+using v8::Global;
 using v8::HandleScope;
 using v8::Int32;
 using v8::Integer;
@@ -54,6 +56,7 @@ using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::String;
+using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
 
@@ -420,9 +423,9 @@ bool SetOption(Environment* env,
 template <typename Opt, uint8_t Opt::*member>
 bool SetOption(Environment* env,
                Opt* options,
-               const v8::Local<v8::Object>& object,
-               const v8::Local<v8::String>& name) {
-  v8::Local<v8::Value> value;
+               const Local<Object>& object,
+               const Local<String>& name) {
+  Local<Value> value;
   if (!object->Get(env->context(), name).ToLocal(&value)) return false;
   if (!value->IsUndefined()) {
     if (!value->IsUint32()) {
@@ -431,7 +434,7 @@ bool SetOption(Environment* env,
           env, "The %s option must be an uint8", *nameStr);
       return false;
     }
-    uint32_t val = value.As<v8::Uint32>()->Value();
+    uint32_t val = value.As<Uint32>()->Value();
     if (val > 255) {
       Utf8Value nameStr(env->isolate(), name);
       THROW_ERR_INVALID_ARG_VALUE(
@@ -1718,7 +1721,7 @@ Session::Session(Endpoint* endpoint,
   Debug(this, "Session created.");
 
   {
-    const v8::HandleScope handle_scope(env()->isolate());
+    const HandleScope handle_scope(env()->isolate());
     JS_DEFINE_READONLY_PROPERTY(
         env(),
         object,
@@ -1728,7 +1731,7 @@ Session::Session(Endpoint* endpoint,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(impl_->state_slot_.GetByteOffset())));
     JS_DEFINE_READONLY_PROPERTY(
@@ -1740,7 +1743,7 @@ Session::Session(Endpoint* endpoint,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(impl_->stats_slot_.GetByteOffset())));
   }
@@ -2127,8 +2130,8 @@ void Session::EmitQlog(uint32_t flags, std::string_view data) {
   // ngtcp2_conn is mid-destruction. Defer the final chunk via SetImmediate.
   if (is_destroyed()) {
     auto isolate = env()->isolate();
-    v8::Global<v8::Object> recv(isolate, object());
-    v8::Global<v8::Function> cb(
+    Global<Object> recv(isolate, object());
+    Global<Function> cb(
         isolate, BindingData::Get(env()).session_qlog_callback());
     std::string buf(data);
     env()->SetImmediate([recv = std::move(recv),
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 60ce80856638f7..3bcfd544abf995 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -26,6 +26,7 @@ using v8::BackingStore;
 using v8::BigInt;
 using v8::FunctionCallbackInfo;
 using v8::Global;
+using v8::HandleScope;
 using v8::Integer;
 using v8::Just;
 using v8::Local;
@@ -34,6 +35,7 @@ using v8::Nothing;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::SharedArrayBuffer;
+using v8::String;
 using v8::Uint32;
 using v8::Uint8Array;
 using v8::Value;
@@ -277,7 +279,7 @@ Maybe<std::shared_ptr<DataQueue>> Stream::GetDataQueueFromSource(
   // object's constructor name is "FileHandle".
   if (value->IsObject()) {
     auto obj = value.As<Object>();
-    Local<v8::String> ctor_name;
+    Local<String> ctor_name;
     auto maybe_name = obj->GetConstructorName();
     if (!maybe_name.IsEmpty()) {
       ctor_name = maybe_name;
@@ -287,9 +289,8 @@ Maybe<std::shared_ptr<DataQueue>> Stream::GetDataQueueFromSource(
         ASSIGN_OR_RETURN_UNWRAP(
             &file_handle, value, Nothing<std::shared_ptr<DataQueue>>());
         Local<Value> path;
-        if (!v8::String::NewFromUtf8(env->isolate(),
-                                     file_handle->original_name().c_str())
-                 .ToLocal(&path)) {
+        if (!ToV8Value(env->context(), file_handle->original_name())
+            .ToLocal(&path)) {
           return Nothing<std::shared_ptr<DataQueue>>();
         }
         auto entry = DataQueue::CreateFdEntry(env, path);
@@ -1048,7 +1049,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
   inbound_->addBackpressureListener(this);
 
   {
-    const v8::HandleScope handle_scope(env()->isolate());
+    const HandleScope handle_scope(env()->isolate());
     // Pass the page's shared views and this slot's byte offset. JS uses
     // the offset to index into the shared view — no per-stream V8 object
     // creation.
@@ -1060,7 +1061,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(state_slot_.GetByteOffset())));
     JS_DEFINE_READONLY_PROPERTY(
@@ -1072,7 +1073,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(stats_slot_.GetByteOffset())));
   }
@@ -1107,7 +1108,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
   inbound_->addBackpressureListener(this);
 
   {
-    const v8::HandleScope handle_scope(env()->isolate());
+    const HandleScope handle_scope(env()->isolate());
     JS_DEFINE_READONLY_PROPERTY(env(),
                                 object,
                                 env()->state_string(),
@@ -1116,7 +1117,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "stateByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(state_slot_.GetByteOffset())));
     JS_DEFINE_READONLY_PROPERTY(
@@ -1128,7 +1129,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
         env(),
         object,
         FIXED_ONE_BYTE_STRING(env()->isolate(), "statsByteOffset"),
-        v8::Integer::NewFromUnsigned(
+        Integer::NewFromUnsigned(
             env()->isolate(),
             static_cast<uint32_t>(stats_slot_.GetByteOffset())));
   }
diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc
index 08ce7f9acd1c4c..6b708315c972f0 100644
--- a/src/quic/tlscontext.cc
+++ b/src/quic/tlscontext.cc
@@ -30,13 +30,16 @@ using ncrypto::SSLCtxPointer;
 using ncrypto::SSLPointer;
 using ncrypto::SSLSessionPointer;
 using ncrypto::X509Pointer;
+using v8::Array;
 using v8::ArrayBuffer;
+using v8::ArrayBufferView;
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::String;
 using v8::Undefined;
 using v8::Value;
 
@@ -95,7 +98,7 @@ template <typename T, typename Opt, std::vector<T> Opt::*member>
 bool SetOption(Environment* env,
                Opt* options,
                const Local<Object>& object,
-               const Local<v8::String>& name) {
+               const Local<String>& name) {
   Local<Value> value;
   if (!object->Get(env->context(), name).ToLocal(&value)) return false;
 
@@ -105,7 +108,7 @@ bool SetOption(Environment* env,
 
   if (value->IsArray()) {
     auto context = env->context();
-    auto values = value.As<v8::Array>();
+    auto values = value.As<Array>();
     uint32_t count = values->Length();
     for (uint32_t n = 0; n < count; n++) {
       Local<Value> item;
@@ -125,7 +128,7 @@ bool SetOption(Environment* env,
         }
       } else if constexpr (std::is_same<T, Store>::value) {
         if (item->IsArrayBufferView()) {
-          Store store = Store::CopyFrom(item.As<v8::ArrayBufferView>());
+          Store store = Store::CopyFrom(item.As<ArrayBufferView>());
           (options->*member).push_back(std::move(store));
         } else if (item->IsArrayBuffer()) {
           Store store = Store::CopyFrom(item.As<ArrayBuffer>());
@@ -154,7 +157,7 @@ bool SetOption(Environment* env,
       }
     } else if constexpr (std::is_same<T, Store>::value) {
       if (value->IsArrayBufferView()) {
-        Store store = Store::CopyFrom(value.As<v8::ArrayBufferView>());
+        Store store = Store::CopyFrom(value.As<ArrayBufferView>());
         (options->*member).push_back(std::move(store));
       } else if (value->IsArrayBuffer()) {
         Store store = Store::CopyFrom(value.As<ArrayBuffer>());

From 137f7aecaba3c34fcca78c1d6158607e6bf2fd39 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Thu, 14 May 2026 15:37:09 -0700
Subject: [PATCH 63/83] quic: fix tests that are missing serverEndpoint close

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/parallel/test-quic-alpn-h3.mjs                      | 3 ++-
 test/parallel/test-quic-alpn-mismatch.mjs                | 1 +
 test/parallel/test-quic-alpn.mjs                         | 1 +
 test/parallel/test-quic-callback-error-onblocked.mjs     | 1 +
 .../test-quic-callback-error-ondatagram-async.mjs        | 3 +--
 .../test-quic-callback-error-ondatagramstatus.mjs        | 1 +
 .../parallel/test-quic-callback-error-onerror-option.mjs | 1 +
 .../test-quic-callback-error-onerror-validation.mjs      | 1 +
 test/parallel/test-quic-callback-error-onerror.mjs       | 3 +--
 test/parallel/test-quic-callback-error-suppressed.mjs    | 1 +
 test/parallel/test-quic-enable-early-data.mjs            | 1 +
 test/parallel/test-quic-endpoint-onsession-throws.mjs    | 2 ++
 test/parallel/test-quic-h3-concurrent-requests.mjs       | 3 ++-
 test/parallel/test-quic-h3-datagram.mjs                  | 4 +++-
 test/parallel/test-quic-h3-error-codes.mjs               | 5 +++--
 test/parallel/test-quic-h3-goaway-non-h3.mjs             | 4 ++--
 test/parallel/test-quic-h3-goaway.mjs                    | 3 ++-
 test/parallel/test-quic-h3-header-validation.mjs         | 6 ++++--
 test/parallel/test-quic-h3-headers-support.mjs           | 3 ++-
 test/parallel/test-quic-h3-informational-headers.mjs     | 3 ++-
 test/parallel/test-quic-h3-origin.mjs                    | 6 ++++--
 test/parallel/test-quic-h3-pending-stream.mjs            | 3 ++-
 test/parallel/test-quic-h3-post-request.mjs              | 3 ++-
 test/parallel/test-quic-h3-priority.mjs                  | 6 ++++--
 test/parallel/test-quic-h3-qpack-settings.mjs            | 6 ++++--
 test/parallel/test-quic-h3-request-response.mjs          | 3 ++-
 test/parallel/test-quic-h3-settings.mjs                  | 9 ++++++---
 .../test-quic-h3-stream-destroy-with-headers.mjs         | 3 ++-
 test/parallel/test-quic-h3-trailing-headers.mjs          | 3 ++-
 test/parallel/test-quic-handshake-ipv6-only.mjs          | 3 ++-
 test/parallel/test-quic-handshake.mjs                    | 3 ++-
 test/parallel/test-quic-new-token.mjs                    | 3 ++-
 test/parallel/test-quic-stream-iteration-double.mjs      | 1 +
 33 files changed, 69 insertions(+), 33 deletions(-)

diff --git a/test/parallel/test-quic-alpn-h3.mjs b/test/parallel/test-quic-alpn-h3.mjs
index ba76d138b99673..431175a743d502 100644
--- a/test/parallel/test-quic-alpn-h3.mjs
+++ b/test/parallel/test-quic-alpn-h3.mjs
@@ -43,4 +43,5 @@ async function checkClient() {
 }
 
 await Promise.all([serverOpened.promise, checkClient()]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-alpn-mismatch.mjs b/test/parallel/test-quic-alpn-mismatch.mjs
index 252095f4d6b3bc..14c9dfe39bf2f3 100644
--- a/test/parallel/test-quic-alpn-mismatch.mjs
+++ b/test/parallel/test-quic-alpn-mismatch.mjs
@@ -52,3 +52,4 @@ await rejects(clientSession.opened, expected);
 // The handshake should fail — opened may reject or never resolve.
 // The session should close with an error.
 await rejects(clientSession.closed, expected);
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-alpn.mjs b/test/parallel/test-quic-alpn.mjs
index a077d1cfb610d2..babb945d9d0c33 100644
--- a/test/parallel/test-quic-alpn.mjs
+++ b/test/parallel/test-quic-alpn.mjs
@@ -45,3 +45,4 @@ const clientSession = await connect(serverEndpoint.address, {
 
 await Promise.all([serverOpened.promise, checkSession(clientSession)]);
 await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-onblocked.mjs b/test/parallel/test-quic-callback-error-onblocked.mjs
index 11aad4017a699f..db61c378f46ad0 100644
--- a/test/parallel/test-quic-callback-error-onblocked.mjs
+++ b/test/parallel/test-quic-callback-error-onblocked.mjs
@@ -43,3 +43,4 @@ stream.setBody(new Uint8Array(4096));
 
 // The stream's closed promise should reject with the error from the throw.
 await rejects(stream.closed, testError);
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-ondatagram-async.mjs b/test/parallel/test-quic-callback-error-ondatagram-async.mjs
index eebe2e0629522c..23eade07161c2c 100644
--- a/test/parallel/test-quic-callback-error-ondatagram-async.mjs
+++ b/test/parallel/test-quic-callback-error-ondatagram-async.mjs
@@ -39,5 +39,4 @@ await clientSession.sendDatagram(new Uint8Array([1, 2, 3]));
 
 await serverDone.promise;
 await clientSession.closed;
-serverEndpoint.close();
-await serverEndpoint.closed;
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-ondatagramstatus.mjs b/test/parallel/test-quic-callback-error-ondatagramstatus.mjs
index 17e2b500720cc3..c03cacdefb03b4 100644
--- a/test/parallel/test-quic-callback-error-ondatagramstatus.mjs
+++ b/test/parallel/test-quic-callback-error-ondatagramstatus.mjs
@@ -38,3 +38,4 @@ await clientSession.sendDatagram(new Uint8Array([1, 2, 3]));
 
 // The session's closed should reject with the error from the throw.
 await rejects(clientSession.closed, testError);
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-onerror-option.mjs b/test/parallel/test-quic-callback-error-onerror-option.mjs
index 29b9e707d52845..ecee9c3f81ed07 100644
--- a/test/parallel/test-quic-callback-error-onerror-option.mjs
+++ b/test/parallel/test-quic-callback-error-onerror-option.mjs
@@ -34,3 +34,4 @@ await clientSession.opened;
 clientSession.destroy(testError);
 
 await rejects(clientSession.closed, testError);
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-onerror-validation.mjs b/test/parallel/test-quic-callback-error-onerror-validation.mjs
index e695c1d761ac78..f44d8c4830ad55 100644
--- a/test/parallel/test-quic-callback-error-onerror-validation.mjs
+++ b/test/parallel/test-quic-callback-error-onerror-validation.mjs
@@ -60,3 +60,4 @@ stream.onerror = undefined;
 strictEqual(stream.onerror, undefined);
 
 await clientSession.closed;
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-onerror.mjs b/test/parallel/test-quic-callback-error-onerror.mjs
index 536efdc92c7cd4..6306d36acf5f12 100644
--- a/test/parallel/test-quic-callback-error-onerror.mjs
+++ b/test/parallel/test-quic-callback-error-onerror.mjs
@@ -72,5 +72,4 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   await clientSession.closed;
 }
 
-serverEndpoint.close();
-await serverEndpoint.closed;
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-callback-error-suppressed.mjs b/test/parallel/test-quic-callback-error-suppressed.mjs
index fcc4d0fcc7f304..38e932f281fcdc 100644
--- a/test/parallel/test-quic-callback-error-suppressed.mjs
+++ b/test/parallel/test-quic-callback-error-suppressed.mjs
@@ -50,3 +50,4 @@ clientSession.destroy(originalError);
 
 // Closed rejects with the original error (not the SuppressedError).
 await rejects(clientSession.closed, originalError);
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-enable-early-data.mjs b/test/parallel/test-quic-enable-early-data.mjs
index d2b140c20d6cbd..90524aaf19d1da 100644
--- a/test/parallel/test-quic-enable-early-data.mjs
+++ b/test/parallel/test-quic-enable-early-data.mjs
@@ -56,3 +56,4 @@ clientSession.opened.then(mustCall((info) => {
 
 await Promise.all([serverOpened.promise, clientOpened.promise]);
 clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-endpoint-onsession-throws.mjs b/test/parallel/test-quic-endpoint-onsession-throws.mjs
index aa6e5722534642..7f9a5483820f09 100644
--- a/test/parallel/test-quic-endpoint-onsession-throws.mjs
+++ b/test/parallel/test-quic-endpoint-onsession-throws.mjs
@@ -49,6 +49,7 @@ const transportParams = { maxIdleTimeout: 1 };
   // robust to network-dropped close packets and stops the event loop
   // from waiting on the client's idle timer to expire.
   clientSession.destroy();
+  await rejects(serverEndpoint.close(), sessionError);
 }
 
 // -------------------------------------------------------------------
@@ -71,4 +72,5 @@ const transportParams = { maxIdleTimeout: 1 };
   await closedAssertion;
 
   clientSession.destroy();
+  await rejects(serverEndpoint.close(), sessionError);
 }
diff --git a/test/parallel/test-quic-h3-concurrent-requests.mjs b/test/parallel/test-quic-h3-concurrent-requests.mjs
index a52137e5cb9362..69ab450cb7e445 100644
--- a/test/parallel/test-quic-h3-concurrent-requests.mjs
+++ b/test/parallel/test-quic-h3-concurrent-requests.mjs
@@ -87,4 +87,5 @@ const requests = paths.map(mustCall(async (path) => {
 }, REQUEST_COUNT));
 
 await Promise.all([...requests, serverDone.promise]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-datagram.mjs b/test/parallel/test-quic-h3-datagram.mjs
index cdc4ac65529610..2c3ea0aad77138 100644
--- a/test/parallel/test-quic-h3-datagram.mjs
+++ b/test/parallel/test-quic-h3-datagram.mjs
@@ -105,7 +105,8 @@ const decoder = new TextDecoder();
   await Promise.all([serverGotDatagram.promise, clientGotDatagram.promise]);
 
   await serverDone.promise;
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // Test 2: Server has enableDatagrams: false. The peer's H3 SETTINGS
@@ -168,4 +169,5 @@ const decoder = new TextDecoder();
 
   await Promise.all([stream.closed, serverDone.promise]);
   clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-error-codes.mjs b/test/parallel/test-quic-h3-error-codes.mjs
index aaea8f93e880a9..f8d520d3fdbffe 100644
--- a/test/parallel/test-quic-h3-error-codes.mjs
+++ b/test/parallel/test-quic-h3-error-codes.mjs
@@ -70,7 +70,7 @@ const decoder = new TextDecoder();
     code: 'ERR_QUIC_APPLICATION_ERROR',
   });
 
-  serverEndpoint.close();
+  await serverEndpoint.close();
 }
 
 // Graceful close with no explicit error code.
@@ -118,5 +118,6 @@ const decoder = new TextDecoder();
   // Graceful close - session close promise resolves
   // because H3_NO_ERROR is a clean close.
   await serverDone.promise;
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-goaway-non-h3.mjs b/test/parallel/test-quic-h3-goaway-non-h3.mjs
index d0956625cf995f..86931ec46fb51a 100644
--- a/test/parallel/test-quic-h3-goaway-non-h3.mjs
+++ b/test/parallel/test-quic-h3-goaway-non-h3.mjs
@@ -61,5 +61,5 @@ await Promise.all([stream.closed, serverDone.promise]);
 
 // Wait a tick for any deferred callbacks to fire.
 await setImmediate();
-
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-goaway.mjs b/test/parallel/test-quic-h3-goaway.mjs
index ef9564fc084754..c8a597b6f2e115 100644
--- a/test/parallel/test-quic-h3-goaway.mjs
+++ b/test/parallel/test-quic-h3-goaway.mjs
@@ -144,5 +144,6 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
 
   // Both streams close cleanly.
   await Promise.all([stream1.closed, stream2.closed]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-header-validation.mjs b/test/parallel/test-quic-h3-header-validation.mjs
index 57e6981f35fea7..0388137148b0a1 100644
--- a/test/parallel/test-quic-h3-header-validation.mjs
+++ b/test/parallel/test-quic-h3-header-validation.mjs
@@ -108,7 +108,8 @@ const decoder = new TextDecoder();
   const body = await bytes(stream);
   strictEqual(decoder.decode(body), 'ok');
   await Promise.all([stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // Verify multiple pseudo-header combinations work correctly.
@@ -153,5 +154,6 @@ const decoder = new TextDecoder();
   });
 
   await Promise.all([bytes(stream), stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-headers-support.mjs b/test/parallel/test-quic-h3-headers-support.mjs
index 5439ff5fd3a7ce..d513fb15978c93 100644
--- a/test/parallel/test-quic-h3-headers-support.mjs
+++ b/test/parallel/test-quic-h3-headers-support.mjs
@@ -73,4 +73,5 @@ const stream = await clientSession.createBidirectionalStream({
 throws(() => stream.sendHeaders({ ':method': 'GET' }), { code: 'ERR_INVALID_STATE' });
 
 await serverDone.promise;
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-informational-headers.mjs b/test/parallel/test-quic-h3-informational-headers.mjs
index 8fbbd73d12ccd4..0f05d08c9bf0ae 100644
--- a/test/parallel/test-quic-h3-informational-headers.mjs
+++ b/test/parallel/test-quic-h3-informational-headers.mjs
@@ -112,4 +112,5 @@ strictEqual(decoder.decode(body), responseBody);
 strictEqual(stream.headers[':status'], '200');
 
 await Promise.all([stream.closed, serverDone.promise]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-origin.mjs b/test/parallel/test-quic-h3-origin.mjs
index 39fcdc2d49b1a7..0e801b8e54408b 100644
--- a/test/parallel/test-quic-h3-origin.mjs
+++ b/test/parallel/test-quic-h3-origin.mjs
@@ -87,7 +87,8 @@ const decoder = new TextDecoder();
   strictEqual(decoder.decode(body), 'ok');
 
   await Promise.all([originReceived.promise, stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // port: 8443 produces origin "https://hostname:8443"
@@ -181,5 +182,6 @@ const decoder = new TextDecoder();
   strictEqual(decoder.decode(body), 'ok');
 
   await Promise.all([originReceived.promise, stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-pending-stream.mjs b/test/parallel/test-quic-h3-pending-stream.mjs
index ab414a559182e3..39f5a4d833d89e 100644
--- a/test/parallel/test-quic-h3-pending-stream.mjs
+++ b/test/parallel/test-quic-h3-pending-stream.mjs
@@ -83,5 +83,6 @@ const decoder = new TextDecoder();
   const body = await bytes(stream);
   strictEqual(decoder.decode(body), 'ok');
   await Promise.all([stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-post-request.mjs b/test/parallel/test-quic-h3-post-request.mjs
index 6cd9e047481d4d..1bd9100810aa58 100644
--- a/test/parallel/test-quic-h3-post-request.mjs
+++ b/test/parallel/test-quic-h3-post-request.mjs
@@ -98,4 +98,5 @@ const responseBody = await bytes(stream);
 strictEqual(decoder.decode(responseBody), 'echo:' + requestBody);
 
 await Promise.all([stream.closed, serverDone.promise]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-priority.mjs b/test/parallel/test-quic-h3-priority.mjs
index 8ddcab23a69d54..9aac69bd6d2f22 100644
--- a/test/parallel/test-quic-h3-priority.mjs
+++ b/test/parallel/test-quic-h3-priority.mjs
@@ -151,7 +151,8 @@ const decoder = new TextDecoder();
                      stream3.closed,
                      stream4.closed,
                      serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // Server priority getter reflects peer's PRIORITY_UPDATE.
@@ -235,5 +236,6 @@ const decoder = new TextDecoder();
   await Promise.all([serverSawHighPriority.promise,
                      stream.closed,
                      serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-qpack-settings.mjs b/test/parallel/test-quic-h3-qpack-settings.mjs
index 547e70f8c2d8a5..6d059b4cbee175 100644
--- a/test/parallel/test-quic-h3-qpack-settings.mjs
+++ b/test/parallel/test-quic-h3-qpack-settings.mjs
@@ -81,7 +81,8 @@ async function makeRequest(clientSession, path) {
   await makeRequest(clientSession, '/second');
 
   await serverDone.promise;
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // Custom qpackMaxDTableCapacity = 8192 (larger than default).
@@ -115,5 +116,6 @@ async function makeRequest(clientSession, path) {
   await makeRequest(clientSession, '/beta');
 
   await serverDone.promise;
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-request-response.mjs b/test/parallel/test-quic-h3-request-response.mjs
index 309489f2f16634..817f620c89f8ee 100644
--- a/test/parallel/test-quic-h3-request-response.mjs
+++ b/test/parallel/test-quic-h3-request-response.mjs
@@ -111,4 +111,5 @@ strictEqual(decoder.decode(body), responseBody);
 strictEqual(stream.headers[':status'], '200');
 
 await Promise.all([stream.closed, serverDone.promise]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-settings.mjs b/test/parallel/test-quic-h3-settings.mjs
index d132f628a404e7..2b3b9a628f1c15 100644
--- a/test/parallel/test-quic-h3-settings.mjs
+++ b/test/parallel/test-quic-h3-settings.mjs
@@ -81,7 +81,8 @@ const decoder = new TextDecoder();
   strictEqual(decoder.decode(body), 'ok');
   await stream.closed;
   await serverDone.promise;
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // maxHeaderLength enforcement.
@@ -136,7 +137,8 @@ const decoder = new TextDecoder();
   const body = await bytes(stream);
   strictEqual(decoder.decode(body), 'ok');
   await Promise.all([stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
 
 // enableConnectProtocol and enableDatagrams settings.
@@ -181,5 +183,6 @@ const decoder = new TextDecoder();
   const body = await bytes(stream);
   strictEqual(decoder.decode(body), 'settings-ok');
   await Promise.all([stream.closed, serverDone.promise]);
-  clientSession.close();
+  await clientSession.close();
+  await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
index a15668beae7dea..135d0301b00386 100644
--- a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
+++ b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
@@ -54,5 +54,6 @@ stream.destroy();
 strictEqual(stream.destroyed, true);
 
 // Close everything cleanly.
-clientSession.close();
+await clientSession.close();
 await serverDone.promise;
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-trailing-headers.mjs b/test/parallel/test-quic-h3-trailing-headers.mjs
index 99e23e01545b59..c620488a920798 100644
--- a/test/parallel/test-quic-h3-trailing-headers.mjs
+++ b/test/parallel/test-quic-h3-trailing-headers.mjs
@@ -119,4 +119,5 @@ await clientTrailersReceived.promise;
 strictEqual(stream.headers[':status'], '200');
 
 await Promise.all([stream.closed, serverDone.promise]);
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-handshake-ipv6-only.mjs b/test/parallel/test-quic-handshake-ipv6-only.mjs
index 2101b769f4bbf0..03531b6ce42ca0 100644
--- a/test/parallel/test-quic-handshake-ipv6-only.mjs
+++ b/test/parallel/test-quic-handshake-ipv6-only.mjs
@@ -72,4 +72,5 @@ const info = await clientSession.opened;
 partialDeepStrictEqual(info, check);
 
 await serverOpened.promise;
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-handshake.mjs b/test/parallel/test-quic-handshake.mjs
index 3ff6af08b868be..1779ceaa23fbf8 100644
--- a/test/parallel/test-quic-handshake.mjs
+++ b/test/parallel/test-quic-handshake.mjs
@@ -60,4 +60,5 @@ const info = await clientSession.opened;
 partialDeepStrictEqual(info, check);
 
 await serverOpened.promise;
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-new-token.mjs b/test/parallel/test-quic-new-token.mjs
index 6351b154b39d00..cafff1146e0da0 100644
--- a/test/parallel/test-quic-new-token.mjs
+++ b/test/parallel/test-quic-new-token.mjs
@@ -52,4 +52,5 @@ const clientSession = await connect(serverEndpoint.address, {
 
 await Promise.all([clientSession.opened, clientToken.promise]);
 
-clientSession.close();
+await clientSession.close();
+await serverEndpoint.close();
diff --git a/test/parallel/test-quic-stream-iteration-double.mjs b/test/parallel/test-quic-stream-iteration-double.mjs
index 76b88a529a444e..e667d5910bf701 100644
--- a/test/parallel/test-quic-stream-iteration-double.mjs
+++ b/test/parallel/test-quic-stream-iteration-double.mjs
@@ -57,3 +57,4 @@ const stream = await clientSession.createBidirectionalStream({
 for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars
 await Promise.all([stream.closed, serverDone.promise]);
 await clientSession.close();
+await serverEndpoint.close();

From 016384726e04e5e13efecffcccf8561a6845237d Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 06:36:11 -0700
Subject: [PATCH 64/83] quic: apply multiple additional minor improvements

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/bindingdata.cc | 22 ++++++++--------
 src/quic/data.cc        |  8 ++++--
 src/quic/endpoint.cc    | 24 ++++++++---------
 src/quic/endpoint.h     |  9 ++++---
 src/quic/quic.cc        | 10 +++++---
 src/quic/session.cc     | 20 +++++++--------
 src/quic/session.h      | 43 +++++++++++++++++--------------
 src/quic/streams.cc     | 57 +++++++++++++++++++++--------------------
 src/quic/tlscontext.cc  |  6 ++---
 src/quic/tlscontext.h   |  2 +-
 10 files changed, 109 insertions(+), 92 deletions(-)

diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index d6ceb2d2c6d2b8..d37cab805de39b 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -335,7 +335,7 @@ void BindingData::OnFlushCheck() {
   // pending_flush_sessions_ and are picked up on the next check tick.
   auto sessions = std::move(pending_flush_sessions_);
   for (auto& session : sessions) {
-    session->pending_flush_ = false;
+    session->flags_.pending_flush = false;
     if (!session->is_destroyed()) {
       session->FlushPendingData();
     }
@@ -437,28 +437,28 @@ JS_METHOD_IMPL(BindingData::SetCallbacks) {
 }
 
 NgTcp2CallbackScope::NgTcp2CallbackScope(Session* session) : session(session) {
-  CHECK(!session->in_ngtcp2_callback_scope_);
-  session->in_ngtcp2_callback_scope_ = true;
+  CHECK(!session->flags_.in_ngtcp2_callback_scope);
+  session->flags_.in_ngtcp2_callback_scope = true;
 }
 
 NgTcp2CallbackScope::~NgTcp2CallbackScope() {
-  session->in_ngtcp2_callback_scope_ = false;
-  if (session->destroy_deferred_) {
-    session->destroy_deferred_ = false;
+  session->flags_.in_ngtcp2_callback_scope = false;
+  if (session->flags_.destroy_deferred) {
+    session->flags_.destroy_deferred = false;
     session->Destroy();
   }
 }
 
 NgHttp3CallbackScope::NgHttp3CallbackScope(Session* session)
     : session(session) {
-  CHECK(!session->in_nghttp3_callback_scope_);
-  session->in_nghttp3_callback_scope_ = true;
+  CHECK(!session->flags_.in_nghttp3_callback_scope);
+  session->flags_.in_nghttp3_callback_scope = true;
 }
 
 NgHttp3CallbackScope::~NgHttp3CallbackScope() {
-  session->in_nghttp3_callback_scope_ = false;
-  if (session->destroy_deferred_) {
-    session->destroy_deferred_ = false;
+  session->flags_.in_nghttp3_callback_scope = false;
+  if (session->flags_.destroy_deferred) {
+    session->flags_.destroy_deferred = false;
     session->Destroy();
   }
 }
diff --git a/src/quic/data.cc b/src/quic/data.cc
index d56420feae1e1b..aebae9099a2b5f 100644
--- a/src/quic/data.cc
+++ b/src/quic/data.cc
@@ -137,7 +137,9 @@ Store Store::CopyFrom(Local<ArrayBuffer> buffer) {
   auto backing = buffer->GetBackingStore();
   auto length = buffer->ByteLength();
   auto dest = ArrayBuffer::NewBackingStore(
-      isolate, length, BackingStoreInitializationMode::kUninitialized,
+      isolate,
+      length,
+      BackingStoreInitializationMode::kUninitialized,
       BackingStoreOnFailureMode::kReturnNull);
   if (!dest) {
     THROW_ERR_MEMORY_ALLOCATION_FAILED(Environment::GetCurrent(isolate));
@@ -154,7 +156,9 @@ Store Store::CopyFrom(Local<ArrayBufferView> view) {
   auto length = view->ByteLength();
   auto offset = view->ByteOffset();
   auto dest = ArrayBuffer::NewBackingStore(
-      isolate, length, BackingStoreInitializationMode::kUninitialized,
+      isolate,
+      length,
+      BackingStoreInitializationMode::kUninitialized,
       BackingStoreOnFailureMode::kReturnNull);
   // copy content
   if (!dest) {
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 46dd0231c4ff7e..dfeb53402a74b9 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -378,7 +378,7 @@ Endpoint::UDP::~UDP() {
 }
 
 int Endpoint::UDP::Bind(const Options& options) {
-  if (is_bound_) return UV_EALREADY;
+  if (flags_.is_bound) return UV_EALREADY;
   if (is_closed_or_closing()) return UV_EBADF;
 
   int flags = 0;
@@ -388,7 +388,7 @@ int Endpoint::UDP::Bind(const Options& options) {
   int size;
 
   if (!err) {
-    is_bound_ = true;
+    flags_.is_bound = true;
     size = static_cast<int>(options.udp_receive_buffer_size);
     if (size > 0) {
       err = uv_recv_buffer_size(reinterpret_cast<uv_handle_t*>(&impl_->handle_),
@@ -427,34 +427,34 @@ void Endpoint::UDP::Unref() {
 
 int Endpoint::UDP::Start() {
   if (is_closed_or_closing()) return UV_EBADF;
-  if (is_started_) return 0;
+  if (flags_.is_started) return 0;
   int err = uv_udp_recv_start(&impl_->handle_, Impl::OnAlloc, Impl::OnReceive);
-  is_started_ = (err == 0);
+  flags_.is_started = (err == 0);
   return err;
 }
 
 void Endpoint::UDP::Stop() {
-  if (is_closed_or_closing() || !is_started_) return;
+  if (is_closed_or_closing() || !flags_.is_started) return;
   USE(uv_udp_recv_stop(&impl_->handle_));
-  is_started_ = false;
+  flags_.is_started = false;
 }
 
 void Endpoint::UDP::Close() {
   if (is_closed_or_closing()) return;
   DCHECK(impl_);
   Stop();
-  is_bound_ = false;
-  is_closed_ = true;
+  flags_.is_bound = false;
+  flags_.is_closed = true;
   impl_->Close();
   impl_.reset();
 }
 
 bool Endpoint::UDP::is_bound() const {
-  return is_bound_;
+  return flags_.is_bound;
 }
 
 bool Endpoint::UDP::is_closed() const {
-  return is_closed_;
+  return flags_.is_closed;
 }
 
 bool Endpoint::UDP::is_closed_or_closing() const {
@@ -1294,8 +1294,8 @@ void Endpoint::Receive(const uint8_t* data,
     }
     // Schedule the session for deferred SendPendingData if it hasn't
     // been scheduled already in this burst.
-    if (!session->is_destroyed() && !session->pending_flush_) {
-      session->pending_flush_ = true;
+    if (!session->is_destroyed() && !session->flags_.pending_flush) {
+      session->flags_.pending_flush = true;
       BindingData::Get(env()).ScheduleSessionFlush(
           BaseObjectPtr<Session>(session));
     }
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index a9f020e0328eff..1a31a89b2d13eb 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -343,9 +343,12 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
     class Impl;
 
     BaseObjectWeakPtr<Impl> impl_;
-    bool is_bound_ = false;
-    bool is_started_ = false;
-    bool is_closed_ = false;
+    struct Flags {
+      uint8_t is_bound : 1 = 0;
+      uint8_t is_started : 1 = 0;
+      uint8_t is_closed : 1 = 0;
+    };
+    Flags flags_;
   };
 
   bool is_closed() const;
diff --git a/src/quic/quic.cc b/src/quic/quic.cc
index d39215a06827d3..36e781f1d700b7 100644
--- a/src/quic/quic.cc
+++ b/src/quic/quic.cc
@@ -13,7 +13,7 @@
 #include "node_external_reference.h"
 
 #include <ngtcp2/ngtcp2_crypto_ossl.h>
-#include <mutex>
+
 namespace node {
 
 using v8::Context;
@@ -25,7 +25,11 @@ using v8::Value;
 namespace quic {
 
 namespace {
-std::once_flag crypto_init_flag;
+uv_once_t crypto_init_flag = UV_ONCE_INIT;
+
+void InitNgtcp2CryptoOnce() {
+  ngtcp2_crypto_ossl_init();
+}
 }  // namespace
 
 void CreatePerIsolateProperties(IsolateData* isolate_data,
@@ -39,8 +43,8 @@ void CreatePerContextProperties(Local<Object> target,
                                 Local<Value> unused,
                                 Local<Context> context,
                                 void* priv) {
+  uv_once(&crypto_init_flag, InitNgtcp2CryptoOnce);
   Realm* realm = Realm::GetCurrent(context);
-  std::call_once(crypto_init_flag, ngtcp2_crypto_ossl_init);
   BindingData::InitPerContext(realm, target);
   Endpoint::InitPerContext(realm, target);
   Session::InitPerContext(realm, target);
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 7737f97e98af27..de17cff0c2f07b 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -1810,7 +1810,7 @@ bool Session::is_server() const {
 }
 
 bool Session::is_destroyed() const {
-  return !impl_ || destroy_deferred_;
+  return !impl_ || flags_.destroy_deferred;
 }
 
 bool Session::is_destroyed_or_closing() const {
@@ -1988,9 +1988,9 @@ void Session::Destroy() {
   // destroy impl_ now because the callback is executing methods on
   // objects owned by impl_ (e.g., the Application). Defer the
   // destruction until the scope exits.
-  if (in_ngtcp2_callback_scope_ || in_nghttp3_callback_scope_) {
+  if (flags_.in_ngtcp2_callback_scope || flags_.in_nghttp3_callback_scope) {
     Debug(this, "Session destroy deferred (in callback scope)");
-    destroy_deferred_ = true;
+    flags_.destroy_deferred = true;
     return;
   }
 
@@ -2131,8 +2131,8 @@ void Session::EmitQlog(uint32_t flags, std::string_view data) {
   if (is_destroyed()) {
     auto isolate = env()->isolate();
     Global<Object> recv(isolate, object());
-    Global<Function> cb(
-        isolate, BindingData::Get(env()).session_qlog_callback());
+    Global<Function> cb(isolate,
+                        BindingData::Get(env()).session_qlog_callback());
     std::string buf(data);
     env()->SetImmediate([recv = std::move(recv),
                          cb = std::move(cb),
@@ -2381,7 +2381,7 @@ void Session::SendBatch(Packet::Ptr* packets,
   if (primary_count == 0) return;
 
   // Use batched send for the primary endpoint.
-  if (prefer_try_send_) {
+  if (flags_.prefer_try_send) {
     endpoint().SendBatch(primary_packets, primary_count);
   } else {
     // Non-flush path: send individually via async uv_udp_send.
@@ -2396,9 +2396,9 @@ void Session::FlushPendingData() {
   if (impl_->application_) {
     // Prefer synchronous sends during the deferred flush to avoid the
     // one-tick latency of async uv_udp_send from the uv_check callback.
-    prefer_try_send_ = true;
+    flags_.prefer_try_send = true;
     application().SendPendingData();
-    prefer_try_send_ = false;
+    flags_.prefer_try_send = false;
   }
 }
 
@@ -2422,7 +2422,7 @@ void Session::Send(Packet::Ptr packet) {
   // prefer synchronous send to avoid the one-tick latency of async
   // uv_udp_send. SendOrTrySend uses uv_udp_try_send first, falling
   // back to uv_udp_send on EAGAIN.
-  if (prefer_try_send_) {
+  if (flags_.prefer_try_send) {
     Debug(this, "Session is sending (try_send) %s", packet->ToString());
     endpoint().SendOrTrySend(std::move(packet));
     return;
@@ -2857,7 +2857,7 @@ bool Session::can_send_packets() const {
   // or closing period. The callback scope check is per-session so that
   // one session's ngtcp2 callback does not block unrelated sessions
   // from sending.
-  return !is_destroyed() && !in_ngtcp2_callback_scope_ &&
+  return !is_destroyed() && !flags_.in_ngtcp2_callback_scope &&
          !is_in_draining_period() && !is_in_closing_period();
 }
 
diff --git a/src/quic/session.h b/src/quic/session.h
index 472079984f313a..a7b01ef5e0e190 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -606,25 +606,30 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   Side side_;
   const ngtcp2_mem* allocator_;
   std::unique_ptr<Impl> impl_;
-  // These flags live on Session (not Impl) so that the NgTcp2CallbackScope
-  // and NgHttp3CallbackScope destructors can safely clear them even after
-  // Impl has been destroyed via MakeCallback re-entrancy during a callback.
-  // The scope is placed at the ngtcp2/nghttp3 entry point (e.g. Receive,
-  // OnTimeout) rather than on individual callbacks, so the deferred destroy
-  // only fires after all callbacks for that entry point have completed.
-  bool in_ngtcp2_callback_scope_ = false;
-  bool in_nghttp3_callback_scope_ = false;
-  bool destroy_deferred_ = false;
-  // Set when this session is in BindingData's pending_flush_sessions_ vector.
-  // Cleared by the flush callback before calling SendPendingData.
-  // Provides O(1) dedup so a session receiving multiple packets in one I/O
-  // burst is only scheduled for flush once.
-  bool pending_flush_ = false;
-  // When true, Session::Send prefers synchronous delivery via
-  // Endpoint::SendOrTrySend (uv_udp_try_send with async fallback).
-  // Set during FlushPendingData to avoid the one-tick latency of
-  // async-only sends from the uv_check callback.
-  bool prefer_try_send_ = false;
+
+  struct Flags {
+    // These flags live on Session (not Impl) so that the NgTcp2CallbackScope
+    // and NgHttp3CallbackScope destructors can safely clear them even after
+    // Impl has been destroyed via MakeCallback re-entrancy during a callback.
+    // The scope is placed at the ngtcp2/nghttp3 entry point (e.g. Receive,
+    // OnTimeout) rather than on individual callbacks, so the deferred destroy
+    // only fires after all callbacks for that entry point have completed.
+    uint8_t in_ngtcp2_callback_scope : 1 = 0;
+    uint8_t in_nghttp3_callback_scope : 1 = 0;
+    uint8_t destroy_deferred : 1 = 0;
+    // Set when this session is in BindingData's pending_flush_sessions_ vector.
+    // Cleared by the flush callback before calling SendPendingData.
+    // Provides O(1) dedup so a session receiving multiple packets in one I/O
+    // burst is only scheduled for flush once.
+    uint8_t pending_flush : 1 = 0;
+    // When true, Session::Send prefers synchronous delivery via
+    // Endpoint::SendOrTrySend (uv_udp_try_send with async fallback).
+    // Set during FlushPendingData to avoid the one-tick latency of
+    // async-only sends from the uv_check callback.
+    uint8_t prefer_try_send : 1 = 0;
+  };
+  Flags flags_;
+
   QuicConnectionPointer connection_;
   std::unique_ptr<TLSSession> tls_session_;
   friend struct NgTcp2CallbackScope;
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 3bcfd544abf995..255ce5bb13a2cd 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -290,7 +290,7 @@ Maybe<std::shared_ptr<DataQueue>> Stream::GetDataQueueFromSource(
             &file_handle, value, Nothing<std::shared_ptr<DataQueue>>());
         Local<Value> path;
         if (!ToV8Value(env->context(), file_handle->original_name())
-            .ToLocal(&path)) {
+                 .ToLocal(&path)) {
           return Nothing<std::shared_ptr<DataQueue>>();
         }
         auto entry = DataQueue::CreateFdEntry(env, path);
@@ -529,8 +529,9 @@ class Stream::Outbound final : public MemoryRetainer {
   explicit Outbound(Stream* stream)
       : stream_(stream),
         queue_(DataQueue::Create()),
-        reader_(queue_->get_reader()),
-        streaming_(true) {}
+        reader_(queue_->get_reader()) {
+    flags_.streaming = true;
+  }
 
   void Acknowledge(size_t amount) {
     size_t remaining = std::min(amount, total_ - uncommitted_);
@@ -603,7 +604,7 @@ class Stream::Outbound final : public MemoryRetainer {
     if (queue_) queue_->cap();
   }
 
-  bool is_streaming() const { return streaming_; }
+  bool is_streaming() const { return flags_.streaming; }
   size_t total() const { return total_; }
   size_t uncommitted() const { return uncommitted_; }
 
@@ -615,7 +616,7 @@ class Stream::Outbound final : public MemoryRetainer {
   // Appends an entry to the underlying DataQueue. Only valid when
   // the Outbound was created in streaming mode.
   bool AppendEntry(std::unique_ptr<DataQueue::Entry> entry) {
-    if (!streaming_ || !queue_) return false;
+    if (!flags_.streaming || !queue_) return false;
     auto size = entry->size();
     auto result = queue_->append(std::move(entry));
     if (result.has_value() && result.value()) {
@@ -630,7 +631,7 @@ class Stream::Outbound final : public MemoryRetainer {
            ngtcp2_vec* data,
            size_t count,
            size_t max_count_hint) {
-    if (next_pending_) {
+    if (flags_.next_pending) {
       // An async read is in flight, but there may be uncommitted bytes
       // from a previous read that ngtcp2 didn't accept (nwrite=0 due
       // to pacing/congestion). Return those bytes so the send loop can
@@ -643,14 +644,14 @@ class Stream::Outbound final : public MemoryRetainer {
       return bob::Status::STATUS_BLOCK;
     }
 
-    if (errored_) {
+    if (flags_.errored) {
       std::move(next)(UV_EBADF, nullptr, 0, [](int) {});
       return UV_EBADF;
     }
 
     // If eos_ is true and there are no uncommitted bytes we'll return eos,
     // otherwise, return whatever is in the uncommitted queue.
-    if (eos_) {
+    if (flags_.eos) {
       if (uncommitted_ > 0) {
         PullUncommitted(std::move(next));
         return bob::Status::STATUS_CONTINUE;
@@ -683,8 +684,8 @@ class Stream::Outbound final : public MemoryRetainer {
             // If next_pending_ is true then a pull from the reader ended up
             // being asynchronous, our stream is blocking waiting for the data,
             // but we have an error! oh no! We need to error the stream.
-            if (next_pending_) {
-              next_pending_ = false;
+            if (flags_.next_pending) {
+              flags_.next_pending = false;
               stream_->Destroy(
                   QuicError::ForNgtcp2Error(NGTCP2_INTERNAL_ERROR));
               // We do not need to worry about calling MarkErrored in this case
@@ -705,8 +706,8 @@ class Stream::Outbound final : public MemoryRetainer {
             // session will try to read from it again.
             // We must clear next_pending_ before calling ResumeStream because
             // ResumeStream can synchronously re-enter Outbound::Pull.
-            if (next_pending_) {
-              next_pending_ = false;
+            if (flags_.next_pending) {
+              flags_.next_pending = false;
               stream_->session().ResumeStream(stream_->id());
             }
             return;
@@ -732,8 +733,8 @@ class Stream::Outbound final : public MemoryRetainer {
           // pull from it again.
           // We must clear next_pending_ before calling ResumeStream because
           // ResumeStream can synchronously re-enter Outbound::Pull.
-          if (next_pending_) {
-            next_pending_ = false;
+          if (flags_.next_pending) {
+            flags_.next_pending = false;
             stream_->session().ResumeStream(stream_->id());
           }
         },
@@ -795,7 +796,7 @@ class Stream::Outbound final : public MemoryRetainer {
     // rather than blocking — the async callback will resume the stream when
     // more data arrives.
     if (ret == bob::Status::STATUS_WAIT) {
-      next_pending_ = true;
+      flags_.next_pending = true;
       if (uncommitted_ > 0) {
         PullUncommitted(std::move(next));
         return bob::Status::STATUS_CONTINUE;
@@ -843,7 +844,7 @@ class Stream::Outbound final : public MemoryRetainer {
   }
 
   void MarkErrored() {
-    errored_ = true;
+    flags_.errored = true;
     head_.reset();
     tail_ = nullptr;
     commit_head_ = nullptr;
@@ -854,7 +855,7 @@ class Stream::Outbound final : public MemoryRetainer {
   }
 
   void MarkEnded() {
-    eos_ = true;
+    flags_.eos = true;
     queue_.reset();
     reader_.reset();
   }
@@ -894,17 +895,17 @@ class Stream::Outbound final : public MemoryRetainer {
   std::shared_ptr<DataQueue> queue_;
   std::shared_ptr<DataQueue::Reader> reader_;
 
-  bool errored_ = false;
-
-  // True when in streaming mode (non-idempotent queue, appendable).
-  bool streaming_ = false;
-
-  // Will be set to true if the reader_ ends up providing a pull result
-  // asynchronously.
-  bool next_pending_ = false;
-
-  // Will be set to true once reader_ has returned eos.
-  bool eos_ = false;
+  struct Flags {
+    uint8_t errored : 1 = 0;
+    // True when in streaming mode (non-idempotent queue, appendable).
+    uint8_t streaming : 1 = 0;
+    // Will be set to true if the reader_ ends up providing a pull result
+    // asynchronously.
+    uint8_t next_pending : 1 = 0;
+    // Will be set to true once reader_ has returned eos.
+    uint8_t eos : 1 = 0;
+  };
+  Flags flags_;
 
   // The collection of buffers that we have pulled from reader_ and that we
   // are holding onto until they are acknowledged.
diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc
index 6b708315c972f0..2eba97ab8ad2a2 100644
--- a/src/quic/tlscontext.cc
+++ b/src/quic/tlscontext.cc
@@ -50,7 +50,7 @@ namespace quic {
 namespace {
 
 // Temporarily wraps an SSL pointer but does not take ownership.
-// Use by a few of the TLSSession methods that need access to the SSL*
+// Used by a few of the TLSSession methods that need access to the SSL*
 // pointer held by the OSSLContext but cannot take ownership of it.
 class SSLPointerRef final {
  public:
@@ -188,7 +188,7 @@ void OSSLContext::reset() {
   if (ctx_) {
     // The SSL object inside the ngtcp2 ctx may not have been set if
     // SSL creation failed. Guard against null before clearing app data.
-    if (SSL* ssl = ngtcp2_crypto_ossl_ctx_get_ssl(ctx_); ssl != nullptr) {
+    if (SSL* ssl = *this; ssl != nullptr) {
       SSL_set_app_data(ssl, nullptr);
     }
     // connection_ is set during Initialize(). If Initialize() was
@@ -225,7 +225,7 @@ void OSSLContext::Initialize(SSL* ssl,
   connection_ = connection;
 }
 
-std::string OSSLContext::get_cipher_name() const {
+std::string_view OSSLContext::get_cipher_name() const {
   return SSL_get_cipher_name(*this);
 }
 
diff --git a/src/quic/tlscontext.h b/src/quic/tlscontext.h
index 335f577e3994c5..c1d9b95d5613b4 100644
--- a/src/quic/tlscontext.h
+++ b/src/quic/tlscontext.h
@@ -45,7 +45,7 @@ class OSSLContext final {
                   ngtcp2_conn* connection,
                   SSL_CTX* ssl_ctx);
 
-  std::string get_cipher_name() const;
+  std::string_view get_cipher_name() const;
   std::string get_selected_alpn() const;
   std::string_view get_negotiated_group() const;
 

From 3c42f780f771dfd2f943c6a90a00256139005483 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 09:52:56 -0700
Subject: [PATCH 65/83] quic: coalesce received data into fewer buffers

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/quic.md                               |  28 +++
 lib/internal/quic/stats.js                    |  26 ++-
 src/dataqueue/queue.cc                        |  10 +
 src/dataqueue/queue.h                         |   5 +
 src/quic/streams.cc                           | 200 +++++++++++++++++-
 src/quic/streams.h                            |  56 +++++
 .../test-quic-stream-recv-coalescing.mjs      | 130 ++++++++++++
 7 files changed, 446 insertions(+), 9 deletions(-)
 create mode 100644 test/parallel/test-quic-stream-recv-coalescing.mjs

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 7e765f21083bea..1ee7877c28909d 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -2096,6 +2096,20 @@ added: v23.8.0
 
 * Type: {bigint}
 
+### `streamStats.bytesAccumulated`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint}
+
+The current number of bytes sitting in the stream's receive accumulation
+buffer, awaiting delivery to the application. A value near zero indicates
+the reader is keeping up with incoming data. A value near the stream's
+flow control window indicates the application is not consuming data fast
+enough.
+
 ### `streamStats.bytesReceived`
 
 <!-- YAML
@@ -2144,6 +2158,20 @@ added: v23.8.0
 
 * Type: {bigint}
 
+### `streamStats.maxBytesAccumulated`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint}
+
+The peak number of bytes that were accumulated in the stream's receive
+buffer at any point during the stream's lifetime. This value only
+increases monotonically. It is useful for diagnosing whether a stream
+experienced backpressure episodes and whether the accumulation buffer
+sizing is appropriate for the workload.
+
 ### `streamStats.maxOffset`
 
 <!-- YAML
diff --git a/lib/internal/quic/stats.js b/lib/internal/quic/stats.js
index 9ffbff8df201cb..b6500e6700713e 100644
--- a/lib/internal/quic/stats.js
+++ b/lib/internal/quic/stats.js
@@ -108,6 +108,8 @@ const {
   IDX_STATS_STREAM_MAX_OFFSET_ACK,
   IDX_STATS_STREAM_MAX_OFFSET_RECV,
   IDX_STATS_STREAM_FINAL_SIZE,
+  IDX_STATS_STREAM_BYTES_ACCUMULATED,
+  IDX_STATS_STREAM_MAX_BYTES_ACCUMULATED,
   IDX_STATS_STREAM_COUNT,
 } = internalBinding('quic');
 
@@ -166,6 +168,8 @@ assert(IDX_STATS_STREAM_MAX_OFFSET !== undefined);
 assert(IDX_STATS_STREAM_MAX_OFFSET_ACK !== undefined);
 assert(IDX_STATS_STREAM_MAX_OFFSET_RECV !== undefined);
 assert(IDX_STATS_STREAM_FINAL_SIZE !== undefined);
+assert(IDX_STATS_STREAM_BYTES_ACCUMULATED !== undefined);
+assert(IDX_STATS_STREAM_MAX_BYTES_ACCUMULATED !== undefined);
 assert(IDX_STATS_STREAM_COUNT !== undefined);
 assert(IDX_STATS_SESSION_COUNT !== undefined);
 
@@ -889,6 +893,18 @@ class QuicStreamStats {
     return this.#handle[this.#offset + IDX_STATS_STREAM_FINAL_SIZE];
   }
 
+  /** @type {bigint} Current bytes in the receive accumulation buffer. */
+  get bytesAccumulated() {
+    assertIsQuicStreamStats(this);
+    return this.#handle[this.#offset + IDX_STATS_STREAM_BYTES_ACCUMULATED];
+  }
+
+  /** @type {bigint} Peak bytes accumulated over the stream's lifetime. */
+  get maxBytesAccumulated() {
+    assertIsQuicStreamStats(this);
+    return this.#handle[this.#offset + IDX_STATS_STREAM_MAX_BYTES_ACCUMULATED];
+  }
+
   toString() {
     return JSONStringify(this.toJSON());
   }
@@ -907,6 +923,8 @@ class QuicStreamStats {
       maxOffsetAcknowledged,
       maxOffsetReceived,
       finalSize,
+      bytesAccumulated,
+      maxBytesAccumulated,
     } = this;
     return {
       __proto__: null,
@@ -924,6 +942,8 @@ class QuicStreamStats {
       maxOffsetAcknowledged: `${maxOffsetAcknowledged}`,
       maxOffsetReceived: `${maxOffsetReceived}`,
       finalSize: `${finalSize}`,
+      bytesAccumulated: `${bytesAccumulated}`,
+      maxBytesAccumulated: `${maxBytesAccumulated}`,
     };
   }
 
@@ -950,6 +970,8 @@ class QuicStreamStats {
       maxOffsetAcknowledged,
       maxOffsetReceived,
       finalSize,
+      bytesAccumulated,
+      maxBytesAccumulated,
     } = this;
 
     return `QuicStreamStats ${inspect({
@@ -965,6 +987,8 @@ class QuicStreamStats {
       maxOffsetAcknowledged,
       maxOffsetReceived,
       finalSize,
+      bytesAccumulated,
+      maxBytesAccumulated,
     }, opts)}`;
   }
 
@@ -990,7 +1014,7 @@ class QuicStreamStats {
   // Creates an immediately disconnected QuicStreamStats object. Used when
   // lazily creating stats for a stream that has already been destroyed.
   static [kCreateDisconnected]() {
-    const count = IDX_STATS_STREAM_FINAL_SIZE + 1;
+    const count = IDX_STATS_STREAM_COUNT;
     const stats = new QuicStreamStats(kPrivateConstructor, new BigUint64Array(count), 0);
     stats.#disconnected = true;
     return stats;
diff --git a/src/dataqueue/queue.cc b/src/dataqueue/queue.cc
index 283d441e9e6336..8516362b7a8788 100644
--- a/src/dataqueue/queue.cc
+++ b/src/dataqueue/queue.cc
@@ -179,6 +179,11 @@ class DataQueueImpl final : public DataQueue,
     for (auto& listener : backpressure_listeners_) listener->EntryRead(amount);
   }
 
+  void NotifyBeforePull() {
+    if (idempotent_) return;
+    for (auto& listener : backpressure_listeners_) listener->BeforePull();
+  }
+
   bool HasBackpressureListeners() const noexcept {
     return !backpressure_listeners_.empty();
   }
@@ -381,6 +386,11 @@ class NonIdempotentDataQueueReader final
            size_t max_count_hint = bob::kMaxCountHint) override {
     std::shared_ptr<DataQueue::Reader> self = shared_from_this();
 
+    // Let listeners flush pending data before we check the entries list.
+    // This allows, for example, the QUIC Stream to flush its receive
+    // accumulation buffer into the queue before the pull proceeds.
+    data_queue_->NotifyBeforePull();
+
     // If ended is true, this reader has already reached the end and cannot
     // provide any more data.
     if (ended_) {
diff --git a/src/dataqueue/queue.h b/src/dataqueue/queue.h
index a37bd27549986e..190c54111b3e01 100644
--- a/src/dataqueue/queue.h
+++ b/src/dataqueue/queue.h
@@ -147,6 +147,11 @@ class DataQueue : public MemoryRetainer {
   class BackpressureListener {
    public:
     virtual void EntryRead(size_t amount) = 0;
+
+    // Called before the reader pulls from the DataQueue. Gives
+    // the listener a chance to flush pending data into the queue
+    // before the pull checks the entries list.
+    virtual void BeforePull() {}
   };
 
   // A DataQueue::Entry represents a logical chunk of data in the queue.
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 255ce5bb13a2cd..50ce784da09f68 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -23,6 +23,7 @@ using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::BigInt;
 using v8::FunctionCallbackInfo;
 using v8::Global;
@@ -85,7 +86,11 @@ namespace quic {
   V(MAX_OFFSET, max_offset)                                                    \
   V(MAX_OFFSET_ACK, max_offset_ack)                                            \
   V(MAX_OFFSET_RECV, max_offset_received)                                      \
-  V(FINAL_SIZE, final_size)
+  V(FINAL_SIZE, final_size)                                                    \
+  /* Bytes in the receive accumulation buffer */                               \
+  V(BYTES_ACCUMULATED, bytes_accumulated)                                      \
+  /* Peak bytes accumulated over stream lifetime */                            \
+  V(MAX_BYTES_ACCUMULATED, max_bytes_accumulated)
 
 #define STREAM_JS_METHODS(V)                                                   \
   V(AttachSource, attachSource, false)                                         \
@@ -100,6 +105,91 @@ namespace quic {
   V(Write, write, false)                                                       \
   V(EndWrite, endWrite, false)
 
+// ============================================================================
+// RecvAccumulator implementation
+
+RecvAccumulator::RecvAccumulator(size_t max_capacity)
+    : buf_(kMinCapacity), max_capacity_(std::max(max_capacity, kMinCapacity)) {}
+
+size_t RecvAccumulator::Write(const uint8_t* data, size_t len) {
+  if (len == 0) return 0;
+
+  size_t capacity = buf_.size();
+
+  // If the buffer is full, caller must flush or grow first.
+  size_t space = remaining();
+  if (space == 0) return 0;
+
+  size_t to_write = std::min(len, space);
+
+  // Write into the buffer, handling wrap-around.
+  size_t physical_write = write_pos_ % capacity;
+  size_t first_chunk = std::min(to_write, capacity - physical_write);
+  memcpy(buf_.data() + physical_write, data, first_chunk);
+  if (first_chunk < to_write) {
+    memcpy(buf_.data(), data + first_chunk, to_write - first_chunk);
+  }
+
+  write_pos_ += to_write;
+  len_ += to_write;
+  return to_write;
+}
+
+std::unique_ptr<DataQueue::Entry> RecvAccumulator::Flush(Environment* env) {
+  if (len_ == 0) return nullptr;
+
+  size_t capacity = buf_.size();
+
+  auto store = ArrayBuffer::NewBackingStore(
+      env->isolate(), len_, BackingStoreInitializationMode::kUninitialized);
+  auto* dest = static_cast<uint8_t*>(store->Data());
+
+  // Copy from the ring buffer. Handle the wrap-around case.
+  size_t physical_read = read_pos_ % capacity;
+  size_t first_chunk = std::min(len_, capacity - physical_read);
+  memcpy(dest, buf_.data() + physical_read, first_chunk);
+  if (first_chunk < len_) {
+    memcpy(dest + first_chunk, buf_.data(), len_ - first_chunk);
+  }
+
+  size_t flushed = len_;
+
+  // Reset cursors.
+  read_pos_ = 0;
+  write_pos_ = 0;
+  len_ = 0;
+
+  // Shrink back toward kMinCapacity if we had expanded.
+  if (capacity > kMinCapacity) {
+    buf_.resize(kMinCapacity);
+    buf_.shrink_to_fit();
+  }
+
+  return DataQueue::CreateInMemoryEntryFromBackingStore(
+      std::move(store), 0, flushed);
+}
+
+void RecvAccumulator::Grow() {
+  size_t capacity = buf_.size();
+  size_t new_capacity = std::min(capacity * 2, max_capacity_);
+  if (new_capacity <= capacity) return;  // already at max
+
+  // Linearize the data and grow in one step.
+  std::vector<uint8_t> new_buf(new_capacity);
+  if (len_ > 0) {
+    size_t physical_read = read_pos_ % capacity;
+    size_t first_chunk = std::min(len_, capacity - physical_read);
+    memcpy(new_buf.data(), buf_.data() + physical_read, first_chunk);
+    if (first_chunk < len_) {
+      memcpy(new_buf.data() + first_chunk, buf_.data(), len_ - first_chunk);
+    }
+  }
+
+  buf_ = std::move(new_buf);
+  read_pos_ = 0;
+  write_pos_ = len_;
+}
+
 // ============================================================================
 
 PendingStream::PendingStream(Direction direction,
@@ -1421,6 +1511,28 @@ void Stream::EntryRead(size_t amount) {
   session().ExtendOffset(amount);
 }
 
+void Stream::BeforePull() {
+  // Called before the DataQueue reader pulls. Flush any accumulated
+  // receive data into the DataQueue so the pull finds it immediately.
+  if (recv_accumulator_ && recv_accumulator_->available() > 0) {
+    FlushAccumulation();
+  }
+}
+
+void Stream::FlushAccumulation() {
+  if (!recv_accumulator_ || recv_accumulator_->available() == 0) return;
+  auto entry = recv_accumulator_->Flush(env());
+  if (entry) {
+    inbound_->append(std::move(entry));
+    // Notify the reader that data is now available in the DataQueue.
+    // This is the only place we notify — not on every ReceiveData call —
+    // so the reader only wakes up when there is a well-sized entry to
+    // consume.
+    if (reader_) reader_->NotifyPull();
+  }
+  STAT_SET(Stats, bytes_accumulated, 0);
+}
+
 int Stream::DoPull(bob::Next<ngtcp2_vec> next,
                    int options,
                    ngtcp2_vec* data,
@@ -1513,6 +1625,8 @@ void Stream::EndWritable() {
 void Stream::EndReadable(std::optional<uint64_t> maybe_final_size) {
   if (!is_readable()) return;
   state()->read_ended = 1;
+  // Flush any accumulated data before capping so the reader can see it.
+  FlushAccumulation();
   set_final_size(maybe_final_size.value_or(STAT_GET(Stats, bytes_received)));
   inbound_->cap(STAT_GET(Stats, final_size));
   // Notify the JS reader so it can see EOS. Pass fin=true so the
@@ -1548,6 +1662,10 @@ void Stream::Destroy(QuicError error) {
   // We are going to release our reference to the outbound_ queue here.
   outbound_.reset();
 
+  // EndReadable() above already flushed accumulated data. Just release
+  // the ring buffer memory.
+  recv_accumulator_.reset();
+
   // We reset the inbound here also. However, it's important to note that
   // the JavaScript side could still have a reader on the inbound DataQueue,
   // which may keep that data alive a bit longer.
@@ -1594,15 +1712,81 @@ void Stream::ReceiveData(const uint8_t* data,
   STAT_INCREMENT_N(Stats, bytes_received, len);
   STAT_SET(Stats, max_offset_received, STAT_GET(Stats, bytes_received));
   STAT_RECORD_TIMESTAMP(Stats, received_at);
-  JS_TRY_ALLOCATE_BACKING(env(), backing, len)
-  memcpy(backing->Data(), data, len);
-  inbound_->append(DataQueue::CreateInMemoryEntryFromBackingStore(
-      std::move(backing), 0, len));
 
-  // Notify the JS reader that data is available.
-  if (reader_) reader_->NotifyPull();
+  // Lazy-allocate the receive accumulation buffer on first data-carrying
+  // call. Streams that never receive data (write-only, immediately reset)
+  // pay zero cost.
+  if (!recv_accumulator_) {
+    // Use the per-stream flow control window as the max capacity. The
+    // peer cannot send more than this without the JS side consuming and
+    // extending the window, so the ring buffer can never overflow.
+    auto params = ngtcp2_conn_get_local_transport_params(session());
+    size_t max_cap;
+    if (direction() == Direction::BIDIRECTIONAL) {
+      max_cap =
+          ngtcp2_conn_is_local_stream(session(), id())
+              ? static_cast<size_t>(params->initial_max_stream_data_bidi_local)
+              : static_cast<size_t>(
+                    params->initial_max_stream_data_bidi_remote);
+    } else {
+      max_cap = static_cast<size_t>(params->initial_max_stream_data_uni);
+    }
+    recv_accumulator_ = std::make_unique<RecvAccumulator>(max_cap);
+  }
 
-  if (flags.fin) EndReadable();
+  // Track whether the accumulator was empty before this call. Used to
+  // notify the reader exactly once per accumulation cycle (empty → non-empty
+  // transition) rather than on every callback.
+  bool was_empty = recv_accumulator_->available() == 0;
+
+  // Accumulate into the ring buffer. When the buffer reaches the flush
+  // threshold (64 KB of accumulated data), flush it into the DataQueue as
+  // a single entry and continue writing the remainder. If the reader is
+  // not consuming (no reader, or reader hasn't pulled), allow the buffer
+  // to grow beyond 64 KB up to the flow control window instead of
+  // flushing — keeping data in cheap C++ memory rather than creating
+  // V8 BackingStore entries nobody is reading yet.
+  while (len > 0) {
+    size_t written = recv_accumulator_->Write(data, len);
+    data += written;
+    len -= written;
+
+    if (len > 0) {
+      // Buffer is full. Decide whether to flush or grow.
+      if (recv_accumulator_->should_flush() && reader_) {
+        // Reader exists and we've hit the flush threshold — produce a
+        // well-sized DataQueue entry for the reader to consume.
+        FlushAccumulation();
+      } else if (recv_accumulator_->remaining() == 0) {
+        // No reader yet, or below flush threshold but physically full.
+        // Try to grow the buffer to absorb more data.
+        recv_accumulator_->Grow();
+        // If Grow() couldn't expand (already at max), flush as fallback.
+        if (recv_accumulator_->remaining() == 0) {
+          FlushAccumulation();
+        }
+      }
+    }
+  }
+
+  // Update accumulation stats.
+  STAT_SET(Stats, bytes_accumulated, recv_accumulator_->available());
+  if (recv_accumulator_->available() > STAT_GET(Stats, max_bytes_accumulated)) {
+    STAT_SET(Stats, max_bytes_accumulated, recv_accumulator_->available());
+  }
+
+  if (flags.fin) {
+    FlushAccumulation();
+    EndReadable();
+  } else if (reader_ && was_empty) {
+    // Notify the reader once when the accumulator transitions from empty
+    // to non-empty. This wakes the reader exactly once per accumulation
+    // cycle. When the reader wakes and calls pull(), BeforePull() flushes
+    // the accumulated data, and the subsequent EntryRead() extends the
+    // flow control window. We do NOT notify on every callback — that
+    // would defeat coalescing by flushing tiny amounts each time.
+    reader_->NotifyPull();
+  }
 }
 
 void Stream::ReceiveStopSending(QuicError error) {
diff --git a/src/quic/streams.h b/src/quic/streams.h
index b72298f16636ae..b4e075287f63ec 100644
--- a/src/quic/streams.h
+++ b/src/quic/streams.h
@@ -15,11 +15,61 @@
 #include "bindingdata.h"
 #include "data.h"
 
+#include <vector>
+
 namespace node::quic {
 
 class Session;
 class Stream;
 
+// An elastic ring buffer used by Stream to coalesce received data before
+// flushing it into the DataQueue. This avoids creating many small V8
+// BackingStore allocations from per-QUIC-frame ngtcp2 callbacks. Data is
+// memcpy'd into the ring buffer and flushed as a single right-sized
+// BackingStore when the reader pulls or the buffer reaches its flush
+// threshold. The buffer starts at kMinCapacity and can grow up to a
+// configured maximum (typically the stream flow control window).
+class RecvAccumulator final {
+ public:
+  static constexpr size_t kMinCapacity = 64 * 1024;        // 64 KB
+  static constexpr size_t kFlushThreshold = kMinCapacity;  // flush at 64 KB
+
+  explicit RecvAccumulator(size_t max_capacity);
+  ~RecvAccumulator() = default;
+
+  DISALLOW_COPY_AND_MOVE(RecvAccumulator)
+
+  // Append data. Returns the number of bytes written (may be less than
+  // len if the buffer is full). The caller should flush and retry with
+  // the remaining bytes.
+  size_t Write(const uint8_t* data, size_t len);
+
+  // Flush accumulated data as a single DataQueue entry backed by a
+  // right-sized V8 BackingStore. Returns nullptr if nothing is
+  // accumulated. Resets the read/write cursors and shrinks the buffer
+  // back toward kMinCapacity if it was expanded.
+  std::unique_ptr<DataQueue::Entry> Flush(Environment* env);
+
+  // Current number of bytes awaiting flush.
+  size_t available() const { return len_; }
+
+  // Number of bytes that can still be written before the buffer is full.
+  size_t remaining() const { return buf_.size() - len_; }
+
+  // True if accumulated data has reached the flush threshold.
+  bool should_flush() const { return len_ >= kFlushThreshold; }
+
+  // Grow the buffer capacity (doubles, up to max_capacity_).
+  void Grow();
+
+ private:
+  std::vector<uint8_t> buf_;
+  size_t max_capacity_;
+  size_t read_pos_ = 0;
+  size_t write_pos_ = 0;
+  size_t len_ = 0;  // write_pos_ - read_pos_, accounting for wrap
+};
+
 using Ngtcp2Source = bob::SourceImpl<ngtcp2_vec>;
 
 // When a request to open a stream is made before a Session is able to actually
@@ -253,6 +303,7 @@ class Stream final : public AsyncWrap,
   void EndWritable();
   void EndReadable(std::optional<uint64_t> maybe_final_size = std::nullopt);
   void EntryRead(size_t amount) override;
+  void BeforePull() override;
 
   // Pulls data from the internal outbound DataQueue configured for this stream.
   // This is called by the session/application when it is preparing to send
@@ -321,6 +372,10 @@ class Stream final : public AsyncWrap,
 
   class Outbound;
 
+  // Flushes any data accumulated in the receive ring buffer into the
+  // inbound DataQueue as a single right-sized entry.
+  void FlushAccumulation();
+
   // Gets a reader for the data received for this stream from the peer,
   BaseObjectPtr<Blob::Reader> get_reader();
 
@@ -379,6 +434,7 @@ class Stream final : public AsyncWrap,
   std::unique_ptr<Outbound> outbound_;
   std::shared_ptr<DataQueue> inbound_;
   BaseObjectWeakPtr<Blob::Reader> reader_;
+  std::unique_ptr<RecvAccumulator> recv_accumulator_;
 
   // If the stream cannot be opened yet, it will be created in a pending state.
   // Once the owning session is able to, it will complete opening of the stream
diff --git a/test/parallel/test-quic-stream-recv-coalescing.mjs b/test/parallel/test-quic-stream-recv-coalescing.mjs
new file mode 100644
index 00000000000000..4029ac50f9e3f7
--- /dev/null
+++ b/test/parallel/test-quic-stream-recv-coalescing.mjs
@@ -0,0 +1,130 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: receive-side coalescing produces reasonably-sized chunks.
+// Sends multiple payloads of varying sizes through a bidi stream and
+// verifies that the received chunks are coalesced rather than
+// delivered as ~1154-byte QUIC frame fragments.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+
+const { ok, strictEqual } = assert;
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('../common/quic.mjs');
+const { drainableProtocol: dp } = await import('stream/iter');
+
+// Payloads of varying sizes. Exercises different coalescing paths:
+//   Small (below frame size), medium (a few frames), large (many frames).
+const payloadSizes = [
+  100,       // Small: fits in a single frame
+  5_000,     // Medium: a few frames
+  64_000,    // Large: triggers buffer-full flush
+  1_000,     // Small again after large
+  200_000,   // Very large: well beyond 64 KB buffer
+  500,       // Small tail
+];
+const totalBytes = payloadSizes.reduce((a, b) => a + b, 0);
+
+// Build deterministic payloads for integrity checking.
+function buildPayload(size, seed) {
+  const buf = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    buf[i] = (seed + i) & 0xff;
+  }
+  return buf;
+}
+
+function checksum(data) {
+  let sum = 0;
+  for (let i = 0; i < data.byteLength; i++) {
+    sum = (sum + data[i]) | 0;
+  }
+  return sum;
+}
+
+// Compute expected checksum across all payloads.
+let expectedChecksum = 0;
+for (let i = 0; i < payloadSizes.length; i++) {
+  expectedChecksum = (expectedChecksum +
+    checksum(buildPayload(payloadSizes[i], i))) | 0;
+}
+
+// --- Server side ---
+
+const serverDone = Promise.withResolvers();
+
+const serverEndpoint = await listen(mustCall((serverSession) => {
+  serverSession.onstream = mustCall(async (stream) => {
+    const receivedChunkSizes = [];
+    let receivedBytes = 0;
+    let receivedChecksum = 0;
+
+    for await (const chunks of stream) {
+      for (const chunk of chunks) {
+        receivedChunkSizes.push(chunk.byteLength);
+        receivedBytes += chunk.byteLength;
+        receivedChecksum = (receivedChecksum + checksum(chunk)) | 0;
+      }
+    }
+
+    // Data integrity.
+    strictEqual(receivedBytes, totalBytes);
+    strictEqual(receivedChecksum, expectedChecksum);
+
+    // Coalescing effectiveness: verify that at least some chunks are larger
+    // than the ~1154-byte QUIC frame payload, showing that the accumulator
+    // is combining callbacks. On localhost, round-trip latency is near
+    // zero so coalescing opportunities are limited to I/O bursts where
+    // multiple packets arrive in the same event loop iteration. Under
+    // real network conditions the effect is much more pronounced.
+    const maxChunkSize = Math.max(...receivedChunkSizes);
+    ok(
+      maxChunkSize > 1154,
+      `Expected at least one chunk larger than a single QUIC frame ` +
+      `(1154 bytes), but max was ${maxChunkSize}`
+    );
+
+    // Stats: after full drain, bytes_accumulated should be 0.
+    strictEqual(stream.stats.bytesAccumulated, 0n);
+
+    // max_bytes_accumulated should be nonzero — data passed through
+    // the accumulator.
+    ok(
+      stream.stats.maxBytesAccumulated > 0n,
+      'maxBytesAccumulated should be nonzero'
+    );
+
+    stream.writer.endSync();
+    await stream.closed;
+    serverSession.close();
+    serverDone.resolve();
+  });
+}));
+
+// --- Client side ---
+
+const clientSession = await connect(serverEndpoint.address);
+await clientSession.opened;
+
+const stream = await clientSession.createBidirectionalStream();
+const w = stream.writer;
+
+for (let i = 0; i < payloadSizes.length; i++) {
+  const payload = buildPayload(payloadSizes[i], i);
+  while (!w.writeSync(payload)) {
+    const drainable = w[dp]();
+    if (drainable) await drainable;
+  }
+}
+w.endSync();
+
+// Drain the server's empty response to let the stream close cleanly.
+// eslint-disable-next-line no-unused-vars
+for await (const _ of stream) { /* drain response */ }
+await Promise.all([stream.closed, serverDone.promise]);
+await clientSession.close();
+await serverEndpoint.close();

From add5210c7393f8080eef7b5532ab4067a0951741 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 19:46:56 -0700
Subject: [PATCH 66/83] quic: add reusePort option to QuicEndpoint

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/quic.md           | 17 +++++++++++++++++
 lib/internal/quic/quic.js |  3 +++
 src/quic/bindingdata.h    |  1 +
 src/quic/endpoint.cc      |  4 +++-
 src/quic/endpoint.h       |  6 ++++++
 5 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 1ee7877c28909d..259fe89916bafd 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -2288,6 +2288,23 @@ added: v23.8.0
 
 When `true`, indicates that the endpoint should bind only to IPv6 addresses.
 
+#### `endpointOptions.reusePort`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+* Default: `false`
+
+When `true`, allows multiple endpoints (across separate processes) to bind to
+the same address and port. The kernel will load-balance incoming UDP datagrams
+across all sockets bound with this option. This enables horizontal scaling of
+QUIC servers by running multiple Node.js processes on the same port.
+
+Supported on Linux 3.9+ and DragonFlyBSD 3.6+. On unsupported platforms, the
+bind will fail with an error.
+
 #### `endpointOptions.maxConnectionsPerHost`
 
 <!-- YAML
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 0ae04441ea19ce..ef733e2ed06ee6 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -304,6 +304,7 @@ const endpointRegistry = new SafeSet();
  * @property {boolean} [disableStatelessReset] When true, the endpoint will not send stateless resets
  * @property {bigint|number} [idleTimeout] The default idle timeout for sessions on this endpoint
  * @property {boolean} [ipv6Only] Use IPv6 only
+ * @property {boolean} [reusePort] Enable SO_REUSEPORT for multi-process load balancing
  * @property {bigint|number} [maxConnectionsPerHost] The maximum number of connections per host
  * @property {bigint|number} [maxConnectionsTotal] The maximum number of total connections
  * @property {bigint|number} [maxRetries] The maximum number of retries
@@ -3956,6 +3957,7 @@ class QuicEndpoint {
       idleTimeout,
       validateAddress,
       ipv6Only,
+      reusePort,
       cc,
       resetTokenSecret,
       tokenSecret,
@@ -3992,6 +3994,7 @@ class QuicEndpoint {
       idleTimeout,
       validateAddress,
       ipv6Only,
+      reusePort,
       cc,
       resetTokenSecret,
       tokenSecret,
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index ed78d154e8f9c5..d4c7c545a715de 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -101,6 +101,7 @@ class SessionManager;
   V(initial_max_streams_bidi, "initialMaxStreamsBidi")                         \
   V(initial_max_streams_uni, "initialMaxStreamsUni")                           \
   V(ipv6_only, "ipv6Only")                                                     \
+  V(reuse_port, "reusePort")                                                   \
   V(keylog, "keylog")                                                          \
   V(keys, "keys")                                                              \
   V(lost, "lost")                                                              \
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index dfeb53402a74b9..1827acc09e3488 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -197,7 +197,7 @@ Maybe<Endpoint::Options> Endpoint::Options::From(Environment* env,
   if (!SET(retry_token_expiration) || !SET(token_expiration) ||
       !SET(max_stateless_resets) || !SET(address_lru_size) ||
       !SET(max_retries) || !SET(validate_address) ||
-      !SET(disable_stateless_reset) || !SET(ipv6_only) ||
+      !SET(disable_stateless_reset) || !SET(ipv6_only) || !SET(reuse_port) ||
 #ifdef DEBUG
       !SET(rx_loss) || !SET(tx_loss) ||
 #endif
@@ -265,6 +265,7 @@ std::string Endpoint::Options::ToString() const {
   res += prefix + "reset token secret: " + reset_token_secret.ToString();
   res += prefix + "token secret: " + token_secret.ToString();
   res += prefix + "ipv6 only: " + boolToString(ipv6_only);
+  res += prefix + "reuse port: " + boolToString(reuse_port);
   res += prefix +
          "udp receive buffer size: " + std::to_string(udp_receive_buffer_size);
   res +=
@@ -384,6 +385,7 @@ int Endpoint::UDP::Bind(const Options& options) {
   int flags = 0;
   if (options.local_address->family() == AF_INET6 && options.ipv6_only)
     flags |= UV_UDP_IPV6ONLY;
+  if (options.reuse_port) flags |= UV_UDP_REUSEPORT;
   int err = uv_udp_bind(&impl_->handle_, options.local_address->data(), flags);
   int size;
 
diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h
index 1a31a89b2d13eb..da2ea253dd8d88 100644
--- a/src/quic/endpoint.h
+++ b/src/quic/endpoint.h
@@ -148,6 +148,12 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
     // flag on the underlying uv_udp_t.
     bool ipv6_only = false;
 
+    // When true, multiple endpoints (across separate processes) can bind to
+    // the same address:port and the kernel will load-balance incoming UDP
+    // datagrams across them. This sets the UV_UDP_REUSEPORT flag on the
+    // underlying uv_udp_t. Supported on Linux 3.9+ and DragonFlyBSD 3.6+.
+    bool reuse_port = false;
+
     uint32_t udp_receive_buffer_size = 0;
     uint32_t udp_send_buffer_size = 0;
 

From 320a3a22719e34c42bf7b92724fed4a895bed3a7 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 21:48:50 -0700
Subject: [PATCH 67/83] quic: improve stream header collection performance

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/http3.cc   | 26 ++++++++++++-----------
 src/quic/streams.cc | 52 ++++++++++++++++++++++++---------------------
 src/quic/streams.h  | 10 +++++----
 3 files changed, 48 insertions(+), 40 deletions(-)

diff --git a/src/quic/http3.cc b/src/quic/http3.cc
index 6717ac064801cb..da96b776668ba0 100644
--- a/src/quic/http3.cc
+++ b/src/quic/http3.cc
@@ -333,9 +333,7 @@ class Http3ApplicationImpl final : public Session::Application {
     // We cannot add the header if we've either reached
     // * the max number of header pairs or
     // * the max number of header bytes (name + value combined)
-    // current_count is the number of entries in the headers vector
-    // (each pair = name entry + value entry = 2 entries).
-    return (current_count / 2 < options_.max_header_pairs) &&
+    return (current_count < options_.max_header_pairs) &&
            (current_headers_length + this_header_length) <=
                options_.max_header_length;
   }
@@ -825,12 +823,12 @@ class Http3ApplicationImpl final : public Session::Application {
     stream->BeginHeaders(HeadersKind::INITIAL);
   }
 
-  void OnReceiveHeader(stream_id id, Http3Header&& header) {
+  void OnReceiveHeader(stream_id id, std::unique_ptr<Http3Header> header) {
     auto stream = session().FindStream(id);
 
     if (!stream) [[unlikely]]
       return;
-    if (header.name() == ":status" && header.value()[0] == '1') {
+    if (header->name() == ":status" && header->value()[0] == '1') {
       Debug(&session(),
             "HTTP/3 application switching to hints headers for stream %" PRIi64,
             stream->id());
@@ -839,8 +837,8 @@ class Http3ApplicationImpl final : public Session::Application {
     IF_QUIC_DEBUG(env()) {
       Debug(&session(),
             "Received header \"%s: %s\"",
-            header.name(),
-            header.value());
+            header->name(),
+            header->value());
     }
     stream->AddHeader(std::move(header));
   }
@@ -874,15 +872,15 @@ class Http3ApplicationImpl final : public Session::Application {
     stream->BeginHeaders(HeadersKind::TRAILING);
   }
 
-  void OnReceiveTrailer(stream_id id, Http3Header&& header) {
+  void OnReceiveTrailer(stream_id id, std::unique_ptr<Http3Header> header) {
     auto stream = session().FindStream(id);
     if (!stream) [[unlikely]]
       return;
     IF_QUIC_DEBUG(env()) {
       Debug(&session(),
             "Received header \"%s: %s\"",
-            header.name(),
-            header.value());
+            header->name(),
+            header->value());
     }
     stream->AddHeader(std::move(header));
   }
@@ -1239,7 +1237,9 @@ class Http3ApplicationImpl final : public Session::Application {
       return NGHTTP3_ERR_CALLBACK_FAILURE;
     }
     if (Http3Header::IsZeroLength(token, name, value)) return NGTCP2_SUCCESS;
-    app.OnReceiveHeader(id, Http3Header(app.env(), token, name, value, flags));
+    app.OnReceiveHeader(
+        id,
+        std::make_unique<Http3Header>(app.env(), token, name, value, flags));
     return NGTCP2_SUCCESS;
   }
 
@@ -1281,7 +1281,9 @@ class Http3ApplicationImpl final : public Session::Application {
       return NGHTTP3_ERR_CALLBACK_FAILURE;
     }
     if (Http3Header::IsZeroLength(token, name, value)) return NGTCP2_SUCCESS;
-    app.OnReceiveTrailer(id, Http3Header(app.env(), token, name, value, flags));
+    app.OnReceiveTrailer(
+        id,
+        std::make_unique<Http3Header>(app.env(), token, name, value, flags));
     return NGTCP2_SUCCESS;
   }
 
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index 50ce784da09f68..a48b5243f26b03 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -31,6 +31,7 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Just;
 using v8::Local;
+using v8::LocalVector;
 using v8::Maybe;
 using v8::Nothing;
 using v8::Object;
@@ -1126,8 +1127,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
                std::shared_ptr<DataQueue> source)
     : AsyncWrap(session->env(), object, PROVIDER_QUIC_STREAM),
       session_(std::move(session)),
-      inbound_(DataQueue::Create()),
-      headers_(env()->isolate()) {
+      inbound_(DataQueue::Create()) {
   auto& binding = BindingData::Get(env());
   stats_slot_ = GetStreamStatsArena(binding).Allocate(env()->isolate());
   state_slot_ = GetStreamStateArena(binding).Allocate(env()->isolate());
@@ -1185,8 +1185,7 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
       session_(std::move(session)),
       inbound_(DataQueue::Create()),
       maybe_pending_stream_(
-          std::make_unique<PendingStream>(direction, this, session_)),
-      headers_(env()->isolate()) {
+          std::make_unique<PendingStream>(direction, this, session_)) {
   auto& binding = BindingData::Get(env());
   stats_slot_ = GetStreamStatsArena(binding).Allocate(env()->isolate());
   state_slot_ = GetStreamStateArena(binding).Allocate(env()->isolate());
@@ -1567,27 +1566,16 @@ void Stream::set_headers_kind(HeadersKind kind) {
   headers_kind_ = kind;
 }
 
-bool Stream::AddHeader(const Header& header) {
-  size_t len = header.length();
+bool Stream::AddHeader(std::unique_ptr<Header> header) {
+  size_t len = header->length();
   if (!session_->application().CanAddHeader(
           headers_.size(), headers_length_, len)) {
     return false;
   }
 
   headers_length_ += len;
-
-  auto& state = BindingData::Get(env());
-
-  const auto push = [&](auto raw) {
-    Local<Value> value;
-    if (!raw.ToLocal(&value)) [[unlikely]] {
-      return false;
-    }
-    headers_.push_back(value);
-    return true;
-  };
-
-  return push(header.GetName(&state)) && push(header.GetValue(&state));
+  headers_.push_back(std::move(header));
+  return true;
 }
 
 void Stream::Acknowledge(size_t datalen) {
@@ -1899,19 +1887,35 @@ void Stream::EmitHeaders() {
   // state()->wants_headers will be set from the javascript side if the
   // stream object has a handler for the headers event.
   if (!env()->can_call_into_js() || !state()->wants_headers) {
+    headers_.clear();
     return;
   }
   CallbackScope<Stream> cb_scope(this);
 
+  auto& binding = BindingData::Get(env());
+  size_t count = headers_.size() * 2;
+  LocalVector<Value> values(env()->isolate(), count);
+
+  for (size_t i = 0; i < headers_.size(); i++) {
+    Local<Value> name;
+    Local<Value> value;
+    if (!headers_[i]->GetName(&binding).ToLocal(&name) ||
+        !headers_[i]->GetValue(&binding).ToLocal(&value)) [[unlikely]] {
+      headers_.clear();
+      return;
+    }
+    values[i * 2] = name;
+    values[i * 2 + 1] = value;
+  }
+
+  headers_.clear();
+
   Local<Value> argv[] = {
-      Array::New(env()->isolate(), headers_.data(), headers_.size()),
+      Array::New(env()->isolate(), values.data(), count),
       Integer::NewFromUnsigned(env()->isolate(),
                                static_cast<uint32_t>(headers_kind_))};
 
-  headers_.clear();
-
-  MakeCallback(
-      BindingData::Get(env()).stream_headers_callback(), arraysize(argv), argv);
+  MakeCallback(binding.stream_headers_callback(), arraysize(argv), argv);
 }
 
 void Stream::EmitReset(const QuicError& error) {
diff --git a/src/quic/streams.h b/src/quic/streams.h
index b4e075287f63ec..775ba6a33c9168 100644
--- a/src/quic/streams.h
+++ b/src/quic/streams.h
@@ -344,7 +344,7 @@ class Stream final : public AsyncWrap,
   // Returns false if the header cannot be added. This will typically happen
   // if the application does not support headers, a maximum number of headers
   // have already been added, or the maximum total header length is reached.
-  bool AddHeader(const Header& header);
+  bool AddHeader(std::unique_ptr<Header> header);
 
   // TODO(@jasnell): Implement MemoryInfo to track outbound_, inbound_,
   // reader_, headers_, and pending_headers_queue_.
@@ -455,9 +455,11 @@ class Stream final : public AsyncWrap,
   const StoredPriority& stored_priority() const { return priority_; }
 
   // The headers_ field holds a block of headers that have been received and
-  // are being buffered for delivery to the JavaScript side.
-  // TODO(@jasnell): Use v8::Global instead of v8::Local here.
-  v8::LocalVector<v8::Value> headers_;
+  // are being buffered for delivery to the JavaScript side. Headers are
+  // stored as C++ objects during collection (AddHeader) and converted to
+  // V8 strings only when emitted (EmitHeaders), avoiding StrongRootAllocator
+  // mutex contention on the per-header hot path.
+  std::vector<std::unique_ptr<Header>> headers_;
 
   // The headers_kind_ field indicates the kind of headers that are being
   // buffered.

From 1776f3fabd1bedb9b219fb5ae1c3fdf2d4ff0f00 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 22:14:04 -0700
Subject: [PATCH 68/83] quic: enable recvmmsg batching in Endpoint

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/quic/endpoint.cc | 37 +++++++++++++++++++++++++++++--------
 1 file changed, 29 insertions(+), 8 deletions(-)

diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 1827acc09e3488..1a72113dc7bea4 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -303,7 +303,10 @@ class Endpoint::UDP::Impl final : public HandleWrap {
                    reinterpret_cast<uv_handle_t*>(&handle_),
                    PROVIDER_QUIC_UDP),
         endpoint_(endpoint) {
-    CHECK_EQ(uv_udp_init(endpoint->env()->event_loop(), &handle_), 0);
+    CHECK_EQ(uv_udp_init_ex(endpoint->env()->event_loop(),
+                            &handle_,
+                            AF_UNSPEC | UV_UDP_RECVMMSG),
+             0);
     handle_.data = this;
   }
 
@@ -312,18 +315,26 @@ class Endpoint::UDP::Impl final : public HandleWrap {
   SET_SELF_SIZE(Impl)
 
  private:
-  // Pre-allocated receive buffer. Reused across all datagrams because
-  // ngtcp2_conn_read_pkt is synchronous — it copies what it needs and
-  // does not retain a reference to the buffer after returning. This
-  // eliminates a malloc(64KB)/free(64KB) cycle per received datagram.
-  static constexpr size_t kRecvBufferSize = 65536;  // UV__UDP_DGRAM_MAXSIZE
-  char recv_buf_[kRecvBufferSize];
+  // Pre-allocated receive buffer sized for recvmmsg batching. libuv's
+  // recvmmsg path partitions the alloc buffer into 64KB chunks (one per
+  // datagram). With kRecvBatchSize chunks we can receive up to that many
+  // packets in a single recvmmsg syscall. ngtcp2_conn_read_pkt is
+  // synchronous — it copies what it needs — so the buffer is safely
+  // reused across batches.
+  // libuv's recvmmsg partitions the buffer into UV__UDP_DGRAM_MAXSIZE (64KB)
+  // chunks regardless of actual packet size. QUIC packets are ~1200 bytes,
+  // so most of each 64KB chunk is wasted. We use a modest batch size to
+  // balance syscall reduction against memory usage.
+  static constexpr size_t kDgramMaxSize = 65536;  // UV__UDP_DGRAM_MAXSIZE
+  static constexpr size_t kRecvBatchSize = 5;
+  static constexpr size_t kRecvBufferSize = kDgramMaxSize * kRecvBatchSize;
+  std::array<char, kRecvBufferSize> recv_buf_ = {};
 
   static void OnAlloc(uv_handle_t* handle,
                       size_t suggested_size,
                       uv_buf_t* buf) {
     auto* impl = From(handle);
-    *buf = uv_buf_init(impl->recv_buf_, kRecvBufferSize);
+    *buf = uv_buf_init(impl->recv_buf_.data(), kRecvBufferSize);
   }
 
   static void OnReceive(uv_udp_t* handle,
@@ -335,6 +346,13 @@ class Endpoint::UDP::Impl final : public HandleWrap {
     DCHECK_NOT_NULL(impl);
     DCHECK_NOT_NULL(impl->endpoint_);
 
+    // UV_UDP_MMSG_FREE signals the end of a recvmmsg batch — the
+    // buffer can be reused. Since our buffer is pre-allocated and
+    // persistent, there is nothing to free.
+    if (flags & UV_UDP_MMSG_FREE) {
+      return;
+    }
+
     // Nothing to do in these cases. Specifically, if the nread
     // is zero or we have received a partial packet, we are just
     // going to ignore it. No buffer release needed — recv_buf_
@@ -349,6 +367,9 @@ class Endpoint::UDP::Impl final : public HandleWrap {
       return;
     }
 
+    // UV_UDP_MMSG_CHUNK is set for each packet in a recvmmsg batch.
+    // Processing is the same as for a single-message receive — ngtcp2
+    // copies what it needs synchronously from the buf slice.
     impl->endpoint_->Receive(reinterpret_cast<const uint8_t*>(buf->base),
                              static_cast<size_t>(nread),
                              SocketAddress(addr));

From 8a598fd0231476c1daba6e5bc15bb9bf72dec12e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 15 May 2026 22:55:06 -0700
Subject: [PATCH 69/83] quic: add initial RTT option to session options

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: OpenCode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/quic.md                               | 17 ++++++
 lib/internal/quic/quic.js                     |  5 ++
 src/quic/bindingdata.h                        |  1 +
 src/quic/session.cc                           | 21 +++++--
 src/quic/session.h                            |  9 +++
 .../test-quic-session-initial-rtt.mjs         | 60 +++++++++++++++++++
 6 files changed, 109 insertions(+), 4 deletions(-)
 create mode 100644 test/parallel/test-quic-session-initial-rtt.mjs

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 259fe89916bafd..65c0591b22e300 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -2747,6 +2747,23 @@ added: v23.8.0
 Specifies the maximum number of milliseconds a TLS handshake is permitted to take
 to complete before timing out.
 
+#### `sessionOptions.initialRtt`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {bigint|number}
+* **Default:** `0` (use ngtcp2 default of 333ms)
+
+Specifies the initial round-trip time estimate in milliseconds. This value is
+used for probe timeout (PTO) computation, initial pacing, and early loss
+detection before the first actual RTT sample is collected from the connection.
+The default of 333ms is appropriate for the general internet. For low-latency
+environments such as loopback or same-rack deployments, setting a value closer
+to the actual RTT (e.g., `1`) avoids unnecessarily conservative initial
+behavior.
+
 #### `sessionOptions.keepAlive`
 
 <!-- YAML
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index ef733e2ed06ee6..d29b1666130bbd 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -404,6 +404,9 @@ const endpointRegistry = new SafeSet();
  * @property {ArrayBufferView} [token] An opaque address validation token
  *   previously received from the server via `onnewtoken` (client only).
  * @property {bigint|number} [handshakeTimeout] The handshake timeout
+ * @property {bigint|number} [initialRtt] The initial round-trip time estimate in milliseconds.
+ *   Used for PTO computation and initial pacing before the first RTT sample. Default uses
+ *   ngtcp2's built-in default of 333ms. Set lower for low-latency environments.
  * @property {bigint|number} [keepAlive] The keep-alive timeout in milliseconds. When set,
  *   PING frames will be sent automatically to prevent idle timeout.
  * @property {bigint|number} [maxStreamWindow] The maximum stream window
@@ -4875,6 +4878,7 @@ function processSessionOptions(options, config = kEmptyObject) {
     maxPayloadSize,
     unacknowledgedPacketThreshold = 0,
     handshakeTimeout,
+    initialRtt,
     keepAlive,
     maxStreamWindow,
     maxWindow,
@@ -4982,6 +4986,7 @@ function processSessionOptions(options, config = kEmptyObject) {
     maxPayloadSize,
     unacknowledgedPacketThreshold,
     handshakeTimeout,
+    initialRtt,
     keepAlive,
     maxStreamWindow,
     maxWindow,
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index d4c7c545a715de..5fb7fb1fb0ab8e 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -93,6 +93,7 @@ class SessionManager;
   V(groups, "groups")                                                          \
   V(handshake_timeout, "handshakeTimeout")                                     \
   V(http3_alpn, &NGHTTP3_ALPN_H3[1])                                           \
+  V(initial_rtt, "initialRtt")                                                 \
   V(keep_alive_timeout, "keepAlive")                                           \
   V(initial_max_data, "initialMaxData")                                        \
   V(initial_max_stream_data_bidi_local, "initialMaxStreamDataBidiLocal")       \
diff --git a/src/quic/session.cc b/src/quic/session.cc
index de17cff0c2f07b..1386e36d1bce0f 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -513,6 +513,12 @@ Session::Config::Config(Environment* env,
       options.handshake_timeout == UINT64_MAX
           ? UINT64_MAX
           : options.handshake_timeout * NGTCP2_MILLISECONDS;
+
+  // The initial_rtt option is in milliseconds; ngtcp2 expects nanoseconds.
+  // A value of 0 leaves the ngtcp2 default (333ms) unchanged.
+  if (options.initial_rtt > 0)
+    settings.initial_rtt = options.initial_rtt * NGTCP2_MILLISECONDS;
+
   settings.max_stream_window = options.max_stream_window;
   settings.max_window = options.max_window;
   settings.ack_thresh = options.unacknowledged_packet_threshold;
@@ -604,10 +610,11 @@ Maybe<Session::Options> Session::Options::From(Environment* env,
 
   if (!SET(version) || !SET(min_version) || !SET(preferred_address_strategy) ||
       !SET(transport_params) || !SET(tls_options) || !SET(qlog) ||
-      !SET(handshake_timeout) || !SET(keep_alive_timeout) ||
-      !SET(max_stream_window) || !SET(max_window) || !SET(max_payload_size) ||
-      !SET(unacknowledged_packet_threshold) || !SET(cc_algorithm) ||
-      !SET(draining_period_multiplier) || !SET(max_datagram_send_attempts)) {
+      !SET(handshake_timeout) || !SET(initial_rtt) ||
+      !SET(keep_alive_timeout) || !SET(max_stream_window) || !SET(max_window) ||
+      !SET(max_payload_size) || !SET(unacknowledged_packet_threshold) ||
+      !SET(cc_algorithm) || !SET(draining_period_multiplier) ||
+      !SET(max_datagram_send_attempts)) {
     return Nothing<Options>();
   }
 
@@ -726,6 +733,12 @@ std::string Session::Options::ToString() const {
     res += prefix + "handshake timeout: " + std::to_string(handshake_timeout) +
            " nanoseconds";
   }
+  if (initial_rtt > 0) {
+    res += prefix + "initial rtt: " + std::to_string(initial_rtt) +
+           " milliseconds";
+  } else {
+    res += prefix + "initial rtt: <default>";
+  }
   res += prefix + "max stream window: " + std::to_string(max_stream_window);
   res += prefix + "max window: " + std::to_string(max_window);
   res += prefix + "max payload size: " + std::to_string(max_payload_size);
diff --git a/src/quic/session.h b/src/quic/session.h
index a7b01ef5e0e190..48383672f03a73 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -163,6 +163,15 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     static constexpr uint64_t DEFAULT_HANDSHAKE_TIMEOUT = 10'000;
     uint64_t handshake_timeout = DEFAULT_HANDSHAKE_TIMEOUT;
 
+    // The initial round-trip time estimate in milliseconds. ngtcp2 uses this
+    // for PTO computation, initial pacing, and early loss detection before
+    // the first RTT sample is collected. The default of 0 uses ngtcp2's
+    // built-in default of 333ms, which is appropriate for the general
+    // internet. For low-latency environments (e.g., loopback or same-rack
+    // deployments), setting a value closer to the actual RTT avoids
+    // unnecessarily conservative initial behavior.
+    uint64_t initial_rtt = 0;
+
     // The keep-alive timeout in milliseconds. When set to a non-zero value,
     // ngtcp2 will automatically send PING frames to keep the connection alive
     // before the idle timeout fires. Set to 0 to disable (default).
diff --git a/test/parallel/test-quic-session-initial-rtt.mjs b/test/parallel/test-quic-session-initial-rtt.mjs
new file mode 100644
index 00000000000000..5044cc5f7bcdb5
--- /dev/null
+++ b/test/parallel/test-quic-session-initial-rtt.mjs
@@ -0,0 +1,60 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: initialRtt session option is accepted and the session functions
+// correctly with a custom initial RTT estimate.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+
+const { ok } = assert;
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('../common/quic.mjs');
+const { bytes } = await import('stream/iter');
+
+const encoder = new TextEncoder();
+const payload = encoder.encode('hello rtt');
+const serverDone = Promise.withResolvers();
+
+// Use a low initialRtt (1ms) to simulate a low-latency environment.
+// The session should complete successfully and the smoothed RTT in
+// stats should converge to a value well below the default 333ms.
+const serverEndpoint = await listen(mustCall((serverSession) => {
+  serverSession.onstream = mustCall(async (stream) => {
+    const data = await bytes(stream);
+    ok(data.byteLength > 0);
+    stream.writer.endSync();
+    await stream.closed;
+    serverSession.close();
+    serverDone.resolve();
+  });
+}), {
+  initialRtt: 1,  // 1ms
+});
+
+const clientSession = await connect(serverEndpoint.address, {
+  initialRtt: 1,  // 1ms
+});
+await clientSession.opened;
+
+const stream = await clientSession.createBidirectionalStream({
+  body: payload,
+});
+
+for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars
+await stream.closed;
+await serverDone.promise;
+
+// After data exchange, the smoothed RTT should have converged to a
+// realistic value. On loopback it should be well under 10ms (10,000,000ns).
+// The stat is in nanoseconds.
+const smoothedRtt = clientSession.stats.smoothedRtt;
+ok(smoothedRtt > 0n, 'smoothedRtt should be non-zero after data exchange');
+ok(smoothedRtt < 10_000_000n,
+   `smoothedRtt should be under 10ms on loopback, got ${smoothedRtt}ns`);
+
+await clientSession.close();
+await serverEndpoint.close();

From 1d9b4499b70c9d3221928967107edc49f339eeae Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 16 May 2026 06:49:50 -0700
Subject: [PATCH 70/83] quic: improve recv coalescing test sizes

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode:Opus 4.6
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 .../test-quic-stream-recv-coalescing.mjs       | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/test/parallel/test-quic-stream-recv-coalescing.mjs b/test/parallel/test-quic-stream-recv-coalescing.mjs
index 4029ac50f9e3f7..0eb2814c1d0d26 100644
--- a/test/parallel/test-quic-stream-recv-coalescing.mjs
+++ b/test/parallel/test-quic-stream-recv-coalescing.mjs
@@ -17,15 +17,17 @@ if (!hasQuic) {
 const { listen, connect } = await import('../common/quic.mjs');
 const { drainableProtocol: dp } = await import('stream/iter');
 
-// Payloads of varying sizes. Exercises different coalescing paths:
-//   Small (below frame size), medium (a few frames), large (many frames).
+// Payloads of varying sizes with diverse prime factors to exercise
+// different flow control boundary alignments. Avoids round multiples
+// of 1000 so that frame boundaries, accumulation buffer thresholds,
+// and flow control windows are hit at irregular offsets.
 const payloadSizes = [
-  100,       // Small: fits in a single frame
-  5_000,     // Medium: a few frames
-  64_000,    // Large: triggers buffer-full flush
-  1_000,     // Small again after large
-  200_000,   // Very large: well beyond 64 KB buffer
-  500,       // Small tail
+  97,        // Small prime: fits in a single frame
+  4_999,     // Medium prime: a few frames
+  65_521,    // Largest prime below 64 KB buffer flush threshold
+  1_153,     // Small prime after large
+  196_613,   // Large prime: well beyond 64 KB buffer
+  509,       // Small prime tail
 ];
 const totalBytes = payloadSizes.reduce((a, b) => a + b, 0);
 

From 4aea61d1ea75ae201efbcb2203747f4b61f37bc4 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 16 May 2026 08:28:01 -0700
Subject: [PATCH 71/83] quic: add getters for local and remote transport
 parameters

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/quic.md                               |  68 ++++++++
 lib/internal/quic/quic.js                     |  41 +++++
 src/quic/bindingdata.cc                       |  11 ++
 src/quic/bindingdata.h                        |   5 +
 src/quic/session.cc                           |  34 +++-
 src/quic/transportparams.cc                   | 165 ++++++++++++++++++
 src/quic/transportparams.h                    |   3 +
 .../test-quic-session-transport-params.mjs    | 139 +++++++++++++++
 8 files changed, 465 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-quic-session-transport-params.mjs

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 65c0591b22e300..8d86829421096a 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -853,6 +853,17 @@ added: v23.8.0
 
 True if `session.destroy()` has been called. Read only.
 
+### `session.localTransportParams`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.TransportParams|null}
+
+The transport parameters advertised by the local endpoint during the handshake.
+Returns `null` if the session has been destroyed. Read only.
+
 ### `session.endpoint`
 
 <!-- YAML
@@ -1146,6 +1157,19 @@ added: v23.8.0
 
 The local and remote socket addresses associated with the session. Read only.
 
+### `session.remoteTransportParams`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.TransportParams|null|undefined}
+
+The transport parameters advertised by the remote peer during the handshake.
+Returns `null` if the session has been destroyed, `undefined` if the handshake
+has not yet completed and the remote parameters are not yet available. Read
+only.
+
 ### `session.sendDatagram(datagram[, encoding])`
 
 <!-- YAML
@@ -2953,6 +2977,37 @@ won't have need to specify.
 added: v23.8.0
 -->
 
+The `TransportParams` type represents the QUIC transport parameters that are
+negotiated during session establishment. These parameters are used when
+creating a session. The negotiated values can be observed via the
+`session.localTransportParams` and `session.remoteTransportParams` properties.
+
+#### `transportParams.initialSCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The initial source connection ID (SCID) specified. This field is ignored on
+creation of the session and is provided for informational purposes only when
+available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
+#### `transportParams.originalDCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The original destination connection ID (DCID) specified. This field is
+ignored on creation of the session and is provided for informational
+purposes only when available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
 #### `transportParams.preferredAddressIpv4`
 
 <!-- YAML
@@ -3066,6 +3121,19 @@ will not send datagrams larger than this value. The actual maximum size of
 a datagram that can be _sent_ is determined by the peer's
 `maxDatagramFrameSize`, not this endpoint's value.
 
+#### `transportParams.retrySCID`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string}
+
+The retry connection ID specified. This field is ignored on creation
+of the session and is provided for informational purposes only when
+available in the `session.localTransportParams` and
+`session.remoteTransportParams` properties.
+
 ## Callbacks
 
 ### Callback error handling
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index d29b1666130bbd..cc70062765bbaa 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -2626,6 +2626,8 @@ class QuicSession {
     certificate: undefined,
     peerCertificate: undefined,
     ephemeralKeyInfo: undefined,
+    localTransportParams: undefined,
+    remoteTransportParams: undefined,
   };
 
   static {
@@ -2676,6 +2678,45 @@ class QuicSession {
     debug('session created');
   }
 
+  get localTransportParams() {
+    if (this.#inner.localTransportParams !== undefined) {
+      return this.#inner.localTransportParams;
+    }
+    // If the handle is already gone, we cannot retrieve the transport params.
+    if (this.destroyed) return null;
+    const params = this.#handle.localTransportParams();
+    if (params.preferredAddressIpv4 !== undefined) {
+      params.preferredAddressIpv4 = new InternalSocketAddress(params.preferredAddressIpv4);
+    }
+    if (params.preferredAddressIpv6 !== undefined) {
+      params.preferredAddressIpv6 = new InternalSocketAddress(params.preferredAddressIpv6);
+    }
+    return this.#inner.localTransportParams = params;
+  }
+
+  get remoteTransportParams() {
+    if (this.#inner.remoteTransportParams !== undefined) {
+      return this.#inner.remoteTransportParams;
+    }
+    // If the handle is already gone, we cannot retrieve the transport params.
+    if (this.destroyed) return null;
+    const params = this.#handle.remoteTransportParams();
+    // If params is undefined, the transport parameters have not yet been received.
+    // Note the distinction between this and the case where the handle is gone.
+    // If the handle is gone, we return null because we know the transport
+    // parameters will be unavailable. If the transport parameters have not yet
+    // been received, we return undefined to indicate that they may still become
+    // available in the future.
+    if (params === undefined) return undefined;
+    if (params.preferredAddressIpv4 !== undefined) {
+      params.preferredAddressIpv4 = new InternalSocketAddress(params.preferredAddressIpv4);
+    }
+    if (params.preferredAddressIpv6 !== undefined) {
+      params.preferredAddressIpv6 = new InternalSocketAddress(params.preferredAddressIpv6);
+    }
+    return this.#inner.remoteTransportParams = params;
+  }
+
   /** @type {boolean} */
   get #isClosedOrClosing() {
     return this.#handle === undefined || this.#inner.isPendingClose;
diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index d37cab805de39b..a2a1921c087a25 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -20,6 +20,7 @@
 namespace node {
 
 using mem::kReserveSizeAndAlign;
+using v8::DictionaryTemplate;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::HandleScope;
@@ -377,6 +378,16 @@ QUIC_CONSTRUCTORS(V)
 
 #undef V
 
+void BindingData::set_transport_params_template(
+    Local<DictionaryTemplate> tmpl) {
+  transport_params_template_.Reset(env()->isolate(), tmpl);
+}
+
+Local<DictionaryTemplate> BindingData::transport_params_template() const {
+  return PersistentToLocal::Default(env()->isolate(),
+    transport_params_template_);
+}
+
 #define V(name, _)                                                             \
   void BindingData::set_##name##_callback(Local<Function> fn) {                \
     name##_callback_.Reset(env()->isolate(), fn);                              \
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index 5fb7fb1fb0ab8e..51d2035824bfa6 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -303,6 +303,9 @@ class BindingData final
   QUIC_CONSTRUCTORS(V)
 #undef V
 
+  void set_transport_params_template(v8::Local<v8::DictionaryTemplate> tmpl);
+  v8::Local<v8::DictionaryTemplate> transport_params_template() const;
+
 #define V(name, _)                                                             \
   void set_##name##_callback(v8::Local<v8::Function> fn);                      \
   v8::Local<v8::Function> name##_callback() const;
@@ -321,6 +324,8 @@ class BindingData final
   QUIC_CONSTRUCTORS(V)
 #undef V
 
+  v8::Global<v8::DictionaryTemplate> transport_params_template_;
+
 #define V(name, _) v8::Global<v8::Function> name##_callback_;
   QUIC_JS_CALLBACKS(V)
 #undef V
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 1386e36d1bce0f..4ffb3d7f7bb1ac 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -190,7 +190,9 @@ uint64_t MaxDatagramPayload(uint64_t max_frame_size) {
   V(SilentClose, silentClose, SIDE_EFFECT)                                     \
   V(UpdateKey, updateKey, SIDE_EFFECT)                                         \
   V(OpenStream, openStream, SIDE_EFFECT)                                       \
-  V(SendDatagram, sendDatagram, SIDE_EFFECT)
+  V(SendDatagram, sendDatagram, SIDE_EFFECT)                                   \
+  V(LocalTransportParams, localTransportParams, NO_SIDE_EFFECT)                \
+  V(RemoteTransportParams, remoteTransportParams, NO_SIDE_EFFECT)              \
 
 struct Session::State final {
 #define V(_, name, type) type name;
@@ -1163,6 +1165,36 @@ struct Session::Impl final : public MemoryRetainer {
         BigInt::New(env->isolate(), session->SendDatagram(std::move(store))));
   }
 
+  JS_METHOD(LocalTransportParams) {
+    auto env = Environment::GetCurrent(args);
+    Session* session;
+    ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+    ngtcp2_conn* conn = *session;
+    TransportParams params(ngtcp2_conn_get_local_transport_params(conn));
+    Local<Object> obj;
+    if (params.ToObject(env).ToLocal(&obj)) {
+      args.GetReturnValue().Set(obj);
+    }
+  }
+
+  JS_METHOD(RemoteTransportParams) {
+    auto env = Environment::GetCurrent(args);
+    Session* session;
+    ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+    ngtcp2_conn* conn = *session;
+    auto params = ngtcp2_conn_get_remote_transport_params(conn);
+    if (params == nullptr) {
+      // Remote transport parameters are not yet available.
+      return args.GetReturnValue().SetUndefined();
+    }
+    TransportParams tp(params);
+    Local<Object> obj;
+    if (tp.ToObject(env).ToLocal(&obj)) {
+      args.GetReturnValue().Set(obj);
+    }
+  }
   // Internal ngtcp2 callbacks
 
   static int on_acknowledge_stream_data_offset(ngtcp2_conn* conn,
diff --git a/src/quic/transportparams.cc b/src/quic/transportparams.cc
index 372e9dc0828a10..27d855cddf67e0 100644
--- a/src/quic/transportparams.cc
+++ b/src/quic/transportparams.cc
@@ -18,9 +18,13 @@
 
 namespace node {
 
+using v8::BigInt;
+using v8::Boolean;
+using v8::DictionaryTemplate;
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
+using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
 using v8::Value;
@@ -339,6 +343,167 @@ void TransportParams::GeneratePreferredAddressToken(Session* session) {
   }
 }
 
+v8::MaybeLocal<v8::Object> TransportParams::ToObject(Environment* env) const {
+  auto& binding_data = BindingData::Get(env);
+  auto tmpl = binding_data.transport_params_template();
+  static constexpr std::string_view names[] = {
+    "preferredAddressIpv4",
+    "preferredAddressIpv6",
+    "originalDCID",
+    "initialSCID",
+    "retrySCID",
+    "initialMaxStreamDataBidiLocal",
+    "initialMaxStreamDataBidiRemote",
+    "initialMaxStreamDataUni",
+    "initialMaxData",
+    "initialMaxStreamsBidi",
+    "initialMaxStreamsUni",
+    "maxIdleTimeout",
+    "activeConnectionIDLimit",
+    "ackDelayExponent",
+    "maxAckDelay",
+    "maxDatagramFrameSize",
+    "disableActiveMigration",
+  };
+  if (tmpl.IsEmpty()) {
+    tmpl = DictionaryTemplate::New(env->isolate(), names);
+    binding_data.set_transport_params_template(tmpl);
+  }
+
+  MaybeLocal<Value> values[] = {
+      Undefined(env->isolate()),  // preferredAddressIpv4
+      Undefined(env->isolate()),  // preferredAddressIpv6
+      Undefined(env->isolate()),  // originalDCID
+      Undefined(env->isolate()),  // initialSCID
+      Undefined(env->isolate()),  // retrySCID
+      Undefined(env->isolate()),  // initialMaxStreamDataBidiLocal
+      Undefined(env->isolate()),  // initialMaxStreamDataBidiRemote
+      Undefined(env->isolate()),  // initialMaxStreamDataUni
+      Undefined(env->isolate()),  // initialMaxData
+      Undefined(env->isolate()),  // initialMaxStreamsBidi
+      Undefined(env->isolate()),  // initialMaxStreamsUni
+      Undefined(env->isolate()),  // maxIdleTimeout
+      Undefined(env->isolate()),  // activeConnectionIDLimit
+      Undefined(env->isolate()),  // ackDelayExponent
+      Undefined(env->isolate()),  // maxAckDelay
+      Undefined(env->isolate()),  // maxDatagramFrameSize
+      Undefined(env->isolate()),  // disableActiveMigration
+  };
+
+  static_assert(std::size(values) == std::size(names));
+
+  static constexpr size_t kPreferredAddressIpv4Index = 0;
+  static constexpr size_t kPreferredAddressIpv6Index = 1;
+  static constexpr size_t kOriginalDCIDIndex = 2;
+  static constexpr size_t kInitialSCIDIndex = 3;
+  static constexpr size_t kRetrySCIDIndex = 4;
+  static constexpr size_t kInitialMaxStreamDataBidiLocalIndex = 5;
+  static constexpr size_t kInitialMaxStreamDataBidiRemoteIndex = 6;
+  static constexpr size_t kInitialMaxStreamDataUniIndex = 7;
+  static constexpr size_t kInitialMaxDataIndex = 8;
+  static constexpr size_t kInitialMaxStreamsBidiIndex = 9;
+  static constexpr size_t kInitialMaxStreamsUniIndex = 10;
+  static constexpr size_t kMaxIdleTimeoutIndex = 11;
+  static constexpr size_t kActiveConnectionIDLimitIndex = 12;
+  static constexpr size_t kAckDelayExponentIndex = 13;
+  static constexpr size_t kMaxAckDelayIndex = 14;
+  static constexpr size_t kMaxDatagramFrameSizeIndex = 15;
+  static constexpr size_t kDisableActiveMigrationIndex = 16;
+
+  if (ptr_ != nullptr) {
+    if (ptr_->preferred_addr_present) {
+      if (ptr_->preferred_addr.ipv4_present) {
+        auto address = std::make_shared<SocketAddress>(
+            reinterpret_cast<const sockaddr*>(&ptr_->preferred_addr.ipv4));
+        auto addr = SocketAddressBase::Create(env, std::move(address));
+        if (!addr) return {};
+        values[kPreferredAddressIpv4Index] = addr->object();
+      }
+
+      if (ptr_->preferred_addr.ipv6_present) {
+        auto address = std::make_shared<SocketAddress>(
+            reinterpret_cast<const sockaddr*>(&ptr_->preferred_addr.ipv6));
+        auto addr = SocketAddressBase::Create(env, std::move(address));
+        if (!addr) return {};
+        values[kPreferredAddressIpv6Index] = addr->object();
+      }
+      // ngtcp2_preferred_addr preferred_addr;
+    }
+
+    if (ptr_->original_dcid_present) {
+      CID cid(ptr_->original_dcid);
+      Local<Value> value;
+      if (!ToV8Value(env->context(), cid.ToString()).ToLocal(&value)) {
+        return {};
+      }
+      values[kOriginalDCIDIndex] = value;
+    }
+
+    if (ptr_->initial_scid_present) {
+      CID cid(ptr_->initial_scid);
+      Local<Value> value;
+      if (!ToV8Value(env->context(), cid.ToString()).ToLocal(&value)) {
+        return {};
+      }
+      values[kInitialSCIDIndex] = value;
+    }
+
+    if (ptr_->retry_scid_present) {
+      CID cid(ptr_->retry_scid);
+      Local<Value> value;
+      if (!ToV8Value(env->context(), cid.ToString()).ToLocal(&value)) {
+        return {};
+      }
+      values[kRetrySCIDIndex] = value;
+    }
+
+    values[kInitialMaxStreamDataBidiLocalIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_stream_data_bidi_local);
+    values[kInitialMaxStreamDataBidiRemoteIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_stream_data_bidi_remote);
+    values[kInitialMaxStreamDataUniIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_stream_data_uni);
+    values[kInitialMaxDataIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_data);
+    values[kInitialMaxStreamsBidiIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_streams_bidi);
+    values[kInitialMaxStreamsUniIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->initial_max_streams_uni);
+    values[kMaxIdleTimeoutIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->max_idle_timeout / NGTCP2_SECONDS);
+    values[kActiveConnectionIDLimitIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->active_connection_id_limit);
+    values[kAckDelayExponentIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->ack_delay_exponent);
+    values[kMaxAckDelayIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->ack_delay_exponent);
+    values[kMaxAckDelayIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->max_ack_delay);
+    values[kMaxDatagramFrameSizeIndex] =
+        BigInt::NewFromUnsigned(env->isolate(),
+            ptr_->max_datagram_frame_size);
+    values[kDisableActiveMigrationIndex] =
+        Boolean::New(env->isolate(), ptr_->disable_active_migration);
+  }
+
+  auto obj = tmpl->NewInstance(env->context(), values);
+  if (obj->SetPrototypeV2(env->context(), Null(env->isolate())).IsNothing()) {
+    return {};
+  }
+  return obj;
+}
+
 TransportParams::operator const ngtcp2_transport_params&() const {
   DCHECK_NOT_NULL(ptr_);
   return *ptr_;
diff --git a/src/quic/transportparams.h b/src/quic/transportparams.h
index 1f3cd545cdd209..46724574611aff 100644
--- a/src/quic/transportparams.h
+++ b/src/quic/transportparams.h
@@ -164,6 +164,9 @@ class TransportParams final {
                      size_t len,
                      Version version = Version::V1) const;
 
+  // Returns a JavaScript object representing the transport parameters.
+  v8::MaybeLocal<v8::Object> ToObject(Environment* env) const;
+
  private:
   void SetPreferredAddress(const SocketAddress& address);
   void GeneratePreferredAddressToken(Session* session);
diff --git a/test/parallel/test-quic-session-transport-params.mjs b/test/parallel/test-quic-session-transport-params.mjs
new file mode 100644
index 00000000000000..cd0d51838d24d0
--- /dev/null
+++ b/test/parallel/test-quic-session-transport-params.mjs
@@ -0,0 +1,139 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: session.localTransportParams and session.remoteTransportParams
+// Verifies that local transport params are available immediately after
+// session creation, remote transport params are available after the
+// handshake completes, and values match what was configured.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+
+const { ok, strictEqual } = assert;
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('../common/quic.mjs');
+
+const serverTransportParams = {
+  initialMaxStreamsBidi: 200,
+  initialMaxData: 2 * 1024 * 1024,
+};
+
+const clientTransportParams = {
+  initialMaxStreamsBidi: 500,
+  initialMaxData: 8 * 1024 * 1024,
+};
+
+const serverDone = Promise.withResolvers();
+let serverLocalParams;
+let serverRemoteParams;
+
+const serverEndpoint = await listen(mustCall((serverSession) => {
+  // localTransportParams should be available immediately.
+  serverLocalParams = serverSession.localTransportParams;
+  ok(serverLocalParams != null, 'server localTransportParams should be available immediately');
+  strictEqual(typeof serverLocalParams, 'object');
+  strictEqual(Object.getPrototypeOf(serverLocalParams), null);
+
+  // Verify server's configured values are reflected.
+  strictEqual(serverLocalParams.initialMaxStreamsBidi,
+              BigInt(serverTransportParams.initialMaxStreamsBidi));
+  strictEqual(serverLocalParams.initialMaxData,
+              BigInt(serverTransportParams.initialMaxData));
+
+  // Verify defaults are present and reasonable.
+  ok(serverLocalParams.activeConnectionIDLimit > 0n,
+     'activeConnectionIDLimit should be positive');
+  ok(serverLocalParams.ackDelayExponent > 0n,
+     'ackDelayExponent should be positive');
+  ok(serverLocalParams.maxAckDelay > 0n,
+     'maxAckDelay should be positive');
+  strictEqual(serverLocalParams.disableActiveMigration, false);
+
+  serverSession.onstream = mustCall(async (stream) => {
+    // After the stream arrives, the handshake is complete and
+    // remoteTransportParams should be available.
+    serverRemoteParams = serverSession.remoteTransportParams;
+    ok(serverRemoteParams != null,
+       'server remoteTransportParams should be available after handshake');
+    strictEqual(typeof serverRemoteParams, 'object');
+    strictEqual(Object.getPrototypeOf(serverRemoteParams), null);
+
+    // Remote params should reflect the client's configured values.
+    strictEqual(serverRemoteParams.initialMaxStreamsBidi,
+                BigInt(clientTransportParams.initialMaxStreamsBidi));
+    strictEqual(serverRemoteParams.initialMaxData,
+                BigInt(clientTransportParams.initialMaxData));
+
+    // CID fields should be present.
+    strictEqual(typeof serverRemoteParams.initialSCID, 'string');
+    ok(serverRemoteParams.initialSCID.length > 0,
+       'remote initialSCID should be non-empty');
+
+    stream.writer.endSync();
+    await stream.closed;
+    serverSession.close();
+    serverDone.resolve();
+  });
+}), {
+  transportParams: serverTransportParams,
+});
+
+const clientSession = await connect(serverEndpoint.address, {
+  transportParams: clientTransportParams,
+});
+await clientSession.opened;
+
+// After opened, the handshake is complete. Both local and remote
+// transport params should be available on the client session.
+const clientLocalParams = clientSession.localTransportParams;
+ok(clientLocalParams != null, 'client localTransportParams should be available');
+strictEqual(typeof clientLocalParams, 'object');
+strictEqual(Object.getPrototypeOf(clientLocalParams), null);
+
+// Verify client's configured values.
+strictEqual(clientLocalParams.initialMaxStreamsBidi,
+            BigInt(clientTransportParams.initialMaxStreamsBidi));
+strictEqual(clientLocalParams.initialMaxData,
+            BigInt(clientTransportParams.initialMaxData));
+
+const clientRemoteParams = clientSession.remoteTransportParams;
+ok(clientRemoteParams != null,
+   'client remoteTransportParams should be available after handshake');
+strictEqual(typeof clientRemoteParams, 'object');
+strictEqual(Object.getPrototypeOf(clientRemoteParams), null);
+
+// Remote params should reflect the server's configured values.
+strictEqual(clientRemoteParams.initialMaxStreamsBidi,
+            BigInt(serverTransportParams.initialMaxStreamsBidi));
+strictEqual(clientRemoteParams.initialMaxData,
+            BigInt(serverTransportParams.initialMaxData));
+
+// CID fields should be present on the client's view of server params.
+strictEqual(typeof clientRemoteParams.initialSCID, 'string');
+ok(clientRemoteParams.initialSCID.length > 0,
+   'remote initialSCID should be non-empty');
+
+// Cross-validation: server's remote matches client's local and vice versa.
+const stream = await clientSession.createBidirectionalStream();
+stream.writer.endSync();
+
+// eslint-disable-next-line no-unused-vars
+for await (const _ of stream) { /* drain */ }
+await stream.closed;
+await serverDone.promise;
+
+// Cross-validate after both sides have captured params.
+strictEqual(serverRemoteParams.initialMaxStreamsBidi,
+            clientLocalParams.initialMaxStreamsBidi);
+strictEqual(serverRemoteParams.initialMaxData,
+            clientLocalParams.initialMaxData);
+strictEqual(clientRemoteParams.initialMaxStreamsBidi,
+            serverLocalParams.initialMaxStreamsBidi);
+strictEqual(clientRemoteParams.initialMaxData,
+            serverLocalParams.initialMaxData);
+
+await clientSession.close();
+await serverEndpoint.close();

From 2f56cd275ec3fded8bb379e4bc979b60495b929b Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 16 May 2026 09:20:31 -0700
Subject: [PATCH 72/83] quic: add applicationOptions to session

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63267
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/quic.md                               | 101 +++++++++++++----
 lib/internal/quic/quic.js                     |   8 ++
 src/quic/application.cc                       |  49 +++++++-
 src/quic/application.h                        |   4 +
 src/quic/bindingdata.cc                       |  12 +-
 src/quic/bindingdata.h                        |   4 +
 src/quic/http3.cc                             |   2 +
 src/quic/session.cc                           |  23 ++++
 src/quic/session.h                            |   3 +
 src/quic/transportparams.cc                   |  80 ++++++-------
 .../test-quic-session-application-options.mjs | 105 ++++++++++++++++++
 11 files changed, 320 insertions(+), 71 deletions(-)
 create mode 100644 test/parallel/test-quic-session-application-options.mjs

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 8d86829421096a..ad400bf225b974 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -744,6 +744,18 @@ added: v23.8.0
 
 A `QuicSession` represents the local side of a QUIC connection.
 
+### `session.applicationOptions`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.ApplicationOptions}
+
+The current application-level options for this session. These include settings
+that are specific to the negotiated application protocol (e.g. HTTP/3) and may
+be negotiated separately from the transport parameters. Read only.
+
 ### `session.close([options])`
 
 <!-- YAML
@@ -2238,6 +2250,70 @@ added: v23.8.0
 
 ## Types
 
+### type: `ApplicationOptions`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {Object}
+
+The application specific options.
+
+#### `applicationOptions.maxHeaderPairs`
+
+* Type: {bigint|number}
+
+Maximum number of header name-value pairs accepted per header block.
+Headers beyond this limit are silently dropped. **Default:** `128`
+
+#### `applicationOptions.maxHeaderLength`
+
+* Type: {bigint|number}
+
+Maximum total byte length of all header names and values combined per header
+block. Headers that would push the total over this limit are silently
+dropped. **Default:** `8192`
+
+#### `applicationOptions.maxFieldSectionSize`
+
+* Type: {bigint|number}
+
+Maximum size of a compressed header field section (QPACK). `0` means
+unlimited. **Default:** `0`
+
+#### `applicationOptions.qpackMaxDTableCapacity`
+
+* Type: {bigint|number}
+
+QPACK dynamic table capacity in bytes. Set to `0` to disable the dynamic
+table. **Default:** `4096`
+
+#### `applicationOptions.qpackEncoderMaxDTableCapacity`
+
+* Type: {bigint|number}
+
+QPACK encoder maximum dynamic table capacity. **Default:** `4096`
+
+#### `applicationOptions.qpackBlockedStreams`
+
+* Type: {bigint|number}
+
+Maximum number of streams that can e blocked waiting for QPACK dynamic table
+updates. **Default:** `100`
+
+#### `applicationOptions.enableConnectProtocol`
+
+* Type: {boolean}
+
+Enable the extended CONNECT protocol (RFC 9220). **Default:** `false`
+
+#### `applicationOptions.enableDatagrams`
+
+* Type: {boolean}
+
+Enable HTTP/3 datagrams (RFC 9297). **Default:** `false`
+
 ### Type: `EndpointOptions`
 
 <!-- YAML
@@ -2496,30 +2572,9 @@ Default: `'h3'`
 added: v26.2.0
 -->
 
-* Type: {Object}
+* Type: {quic.ApplicationOptions}
 
-HTTP/3 application-specific options. These only apply when the negotiated
-ALPN selects the HTTP/3 application (`'h3'`).
-
-* `maxHeaderPairs` {number} Maximum number of header name-value pairs
-  accepted per header block. Headers beyond this limit are silently
-  dropped. **Default:** `128`
-* `maxHeaderLength` {number} Maximum total byte length of all header
-  names and values combined per header block. Headers that would push
-  the total over this limit are silently dropped. **Default:** `8192`
-* `maxFieldSectionSize` {number} Maximum size of a compressed header
-  field section (QPACK). `0` means unlimited. **Default:** `0`
-* `qpackMaxDTableCapacity` {number} QPACK dynamic table capacity in
-  bytes. Set to `0` to disable the dynamic table. **Default:** `4096`
-* `qpackEncoderMaxDTableCapacity` {number} QPACK encoder maximum
-  dynamic table capacity. **Default:** `4096`
-* `qpackBlockedStreams` {number} Maximum number of streams that can
-  be blocked waiting for QPACK dynamic table updates.
-  **Default:** `100`
-* `enableConnectProtocol` {boolean} Enable the extended CONNECT
-  protocol (RFC 9220). **Default:** `false`
-* `enableDatagrams` {boolean} Enable HTTP/3 datagrams (RFC 9297).
-  **Default:** `false`
+Application-specific options.
 
 ```mjs
 const { listen } = await import('node:quic');
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index cc70062765bbaa..a137f04a417a73 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -2678,6 +2678,14 @@ class QuicSession {
     debug('session created');
   }
 
+  get applicationOptions() {
+    // We don't cache application options because they may be updated by the
+    // C++ layer after session creation depending on the behavior of the
+    // application.
+    if (this.destroyed) return null;
+    return this.#handle.applicationOptions();
+  }
+
   get localTransportParams() {
     if (this.#inner.localTransportParams !== undefined) {
       return this.#inner.localTransportParams;
diff --git a/src/quic/application.cc b/src/quic/application.cc
index 96ddf6c84cbf0e..c37b22c2bd3209 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -19,9 +19,13 @@
 
 namespace node {
 
+using v8::BigInt;
+using v8::Boolean;
+using v8::DictionaryTemplate;
 using v8::Just;
 using v8::Local;
 using v8::Maybe;
+using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
 using v8::Value;
@@ -114,6 +118,44 @@ Maybe<Session::Application_Options> Session::Application_Options::From(
   return Just<Application_Options>(options);
 }
 
+MaybeLocal<Object> Session::Application_Options::ToObject(
+    Environment* env) const {
+  auto& binding_data = BindingData::Get(env);
+  auto tmpl = binding_data.application_options_template();
+  static constexpr std::string_view names[] = {
+      "maxHeaderPairs",
+      "maxHeaderLength",
+      "maxFieldSectionSize",
+      "qpackMaxDtableCapacity",
+      "qpackEncoderMaxDtableCapacity",
+      "qpackBlockedStreams",
+      "enableConnectProtocol",
+      "enableDatagrams",
+  };
+  if (tmpl.IsEmpty()) {
+    tmpl = DictionaryTemplate::New(env->isolate(), names);
+    binding_data.set_application_options_template(tmpl);
+  }
+  MaybeLocal<Value> values[] = {
+      BigInt::NewFromUnsigned(env->isolate(), max_header_pairs),
+      BigInt::NewFromUnsigned(env->isolate(), max_header_length),
+      BigInt::NewFromUnsigned(env->isolate(), max_field_section_size),
+      BigInt::NewFromUnsigned(env->isolate(), qpack_max_dtable_capacity),
+      BigInt::NewFromUnsigned(env->isolate(),
+                              qpack_encoder_max_dtable_capacity),
+      BigInt::NewFromUnsigned(env->isolate(), qpack_blocked_streams),
+      Boolean::New(env->isolate(), enable_connect_protocol),
+      Boolean::New(env->isolate(), enable_datagrams),
+  };
+  static_assert(std::size(values) == std::size(names));
+
+  auto obj = tmpl->NewInstance(env->context(), values);
+  if (obj->SetPrototypeV2(env->context(), Null(env->isolate())).IsNothing()) {
+    return {};
+  }
+  return obj;
+}
+
 // ============================================================================
 
 std::string Session::Application::StreamData::ToString() const {
@@ -655,7 +697,10 @@ class DefaultApplication final : public Session::Application {
   // Marked NOLINT because the cpp linter gets confused about this using
   // statement not being sorted with the using v8 statements at the top
   // of the namespace.
-  using Application::Application;  // NOLINT
+  DefaultApplication(Session* session, const Options& options)
+      : Session::Application(session, options), options_(options) {}
+
+  const Options& options() const override { return options_; }
 
   Session::Application::Type type() const override {
     return Session::Application::Type::DEFAULT;
@@ -827,6 +872,8 @@ class DefaultApplication final : public Session::Application {
     }
   }
 
+  Options options_;
+
   Stream::Queue stream_queue_;
 };
 
diff --git a/src/quic/application.h b/src/quic/application.h
index 59583b941b95b4..0df9b9f0a0e68d 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -38,6 +38,10 @@ class Session::Application : public MemoryRetainer {
   Application(Session* session, const Options& options);
   DISALLOW_COPY_AND_MOVE(Application)
 
+  // Get the active options for this application. These may differ from the
+  // options passed at construction time since some options can be negotiated.
+  virtual const Options& options() const = 0;
+
   // The type of Application, exposed via the session state so JS
   // can observe which Application was selected after ALPN negotiation.
   // This is used primarily for testing/debugging.
diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index a2a1921c087a25..f029f0e8eb83da 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -385,7 +385,17 @@ void BindingData::set_transport_params_template(
 
 Local<DictionaryTemplate> BindingData::transport_params_template() const {
   return PersistentToLocal::Default(env()->isolate(),
-    transport_params_template_);
+                                    transport_params_template_);
+}
+
+void BindingData::set_application_options_template(
+    Local<DictionaryTemplate> tmpl) {
+  application_options_template_.Reset(env()->isolate(), tmpl);
+}
+
+Local<DictionaryTemplate> BindingData::application_options_template() const {
+  return PersistentToLocal::Default(env()->isolate(),
+                                    application_options_template_);
 }
 
 #define V(name, _)                                                             \
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index 51d2035824bfa6..c3c5e9fc7834df 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -306,6 +306,9 @@ class BindingData final
   void set_transport_params_template(v8::Local<v8::DictionaryTemplate> tmpl);
   v8::Local<v8::DictionaryTemplate> transport_params_template() const;
 
+  void set_application_options_template(v8::Local<v8::DictionaryTemplate> tmpl);
+  v8::Local<v8::DictionaryTemplate> application_options_template() const;
+
 #define V(name, _)                                                             \
   void set_##name##_callback(v8::Local<v8::Function> fn);                      \
   v8::Local<v8::Function> name##_callback() const;
@@ -325,6 +328,7 @@ class BindingData final
 #undef V
 
   v8::Global<v8::DictionaryTemplate> transport_params_template_;
+  v8::Global<v8::DictionaryTemplate> application_options_template_;
 
 #define V(name, _) v8::Global<v8::Function> name##_callback_;
   QUIC_JS_CALLBACKS(V)
diff --git a/src/quic/http3.cc b/src/quic/http3.cc
index da96b776668ba0..c9e249682f3a00 100644
--- a/src/quic/http3.cc
+++ b/src/quic/http3.cc
@@ -157,6 +157,8 @@ class Http3ApplicationImpl final : public Session::Application {
     session->set_priority_supported();
   }
 
+  const Options& options() const override { return options_; }
+
   Session::Application::Type type() const override {
     return Session::Application::Type::HTTP3;
   }
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 4ffb3d7f7bb1ac..b42d19d0c0a307 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -193,6 +193,7 @@ uint64_t MaxDatagramPayload(uint64_t max_frame_size) {
   V(SendDatagram, sendDatagram, SIDE_EFFECT)                                   \
   V(LocalTransportParams, localTransportParams, NO_SIDE_EFFECT)                \
   V(RemoteTransportParams, remoteTransportParams, NO_SIDE_EFFECT)              \
+  V(ApplicationOptions, applicationOptions, NO_SIDE_EFFECT)
 
 struct Session::State final {
 #define V(_, name, type) type name;
@@ -1195,6 +1196,24 @@ struct Session::Impl final : public MemoryRetainer {
       args.GetReturnValue().Set(obj);
     }
   }
+
+  JS_METHOD(ApplicationOptions) {
+    auto env = Environment::GetCurrent(args);
+    Session* session;
+    ASSIGN_OR_RETURN_UNWRAP(&session, args.This());
+
+    Local<Object> obj;
+    if (!session->has_application()) {
+      // The application has not yet been selected (ALPN negotiation is not
+      // yet complete on the server) or the session has been destroyed. In
+      // either case, the application options are not available.
+      return args.GetReturnValue().SetUndefined();
+    }
+    auto& options = session->application().options();
+    if (options.ToObject(env).ToLocal(&obj)) {
+      args.GetReturnValue().Set(obj);
+    }
+  }
   // Internal ngtcp2 callbacks
 
   static int on_acknowledge_stream_data_offset(ngtcp2_conn* conn,
@@ -2074,6 +2093,10 @@ TLSSession& Session::tls_session() const {
   return *tls_session_;
 }
 
+bool Session::has_application() const {
+  return !is_destroyed() && impl_->application_ != nullptr;
+}
+
 Session::Application& Session::application() const {
   DCHECK(!is_destroyed());
   DCHECK(impl_->application_);
diff --git a/src/quic/session.h b/src/quic/session.h
index 48383672f03a73..9fb67fb918d818 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -91,6 +91,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
 
     std::string ToString() const;
 
+    v8::MaybeLocal<v8::Object> ToObject(Environment* env) const;
+
     static const Application_Options kDefault;
   };
 
@@ -324,6 +326,7 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   uint32_t version() const;
   Endpoint& endpoint() const;
   TLSSession& tls_session() const;
+  bool has_application() const;
   Application& application() const;
   const Config& config() const;
   const Options& options() const;
diff --git a/src/quic/transportparams.cc b/src/quic/transportparams.cc
index 27d855cddf67e0..183ba973ac1823 100644
--- a/src/quic/transportparams.cc
+++ b/src/quic/transportparams.cc
@@ -347,23 +347,23 @@ v8::MaybeLocal<v8::Object> TransportParams::ToObject(Environment* env) const {
   auto& binding_data = BindingData::Get(env);
   auto tmpl = binding_data.transport_params_template();
   static constexpr std::string_view names[] = {
-    "preferredAddressIpv4",
-    "preferredAddressIpv6",
-    "originalDCID",
-    "initialSCID",
-    "retrySCID",
-    "initialMaxStreamDataBidiLocal",
-    "initialMaxStreamDataBidiRemote",
-    "initialMaxStreamDataUni",
-    "initialMaxData",
-    "initialMaxStreamsBidi",
-    "initialMaxStreamsUni",
-    "maxIdleTimeout",
-    "activeConnectionIDLimit",
-    "ackDelayExponent",
-    "maxAckDelay",
-    "maxDatagramFrameSize",
-    "disableActiveMigration",
+      "preferredAddressIpv4",
+      "preferredAddressIpv6",
+      "originalDCID",
+      "initialSCID",
+      "retrySCID",
+      "initialMaxStreamDataBidiLocal",
+      "initialMaxStreamDataBidiRemote",
+      "initialMaxStreamDataUni",
+      "initialMaxData",
+      "initialMaxStreamsBidi",
+      "initialMaxStreamsUni",
+      "maxIdleTimeout",
+      "activeConnectionIDLimit",
+      "ackDelayExponent",
+      "maxAckDelay",
+      "maxDatagramFrameSize",
+      "disableActiveMigration",
   };
   if (tmpl.IsEmpty()) {
     tmpl = DictionaryTemplate::New(env->isolate(), names);
@@ -457,42 +457,30 @@ v8::MaybeLocal<v8::Object> TransportParams::ToObject(Environment* env) const {
       values[kRetrySCIDIndex] = value;
     }
 
-    values[kInitialMaxStreamDataBidiLocalIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_stream_data_bidi_local);
-    values[kInitialMaxStreamDataBidiRemoteIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_stream_data_bidi_remote);
-    values[kInitialMaxStreamDataUniIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_stream_data_uni);
+    values[kInitialMaxStreamDataBidiLocalIndex] = BigInt::NewFromUnsigned(
+        env->isolate(), ptr_->initial_max_stream_data_bidi_local);
+    values[kInitialMaxStreamDataBidiRemoteIndex] = BigInt::NewFromUnsigned(
+        env->isolate(), ptr_->initial_max_stream_data_bidi_remote);
+    values[kInitialMaxStreamDataUniIndex] = BigInt::NewFromUnsigned(
+        env->isolate(), ptr_->initial_max_stream_data_uni);
     values[kInitialMaxDataIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_data);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->initial_max_data);
     values[kInitialMaxStreamsBidiIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_streams_bidi);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->initial_max_streams_bidi);
     values[kInitialMaxStreamsUniIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->initial_max_streams_uni);
-    values[kMaxIdleTimeoutIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->max_idle_timeout / NGTCP2_SECONDS);
-    values[kActiveConnectionIDLimitIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->active_connection_id_limit);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->initial_max_streams_uni);
+    values[kMaxIdleTimeoutIndex] = BigInt::NewFromUnsigned(
+        env->isolate(), ptr_->max_idle_timeout / NGTCP2_SECONDS);
+    values[kActiveConnectionIDLimitIndex] = BigInt::NewFromUnsigned(
+        env->isolate(), ptr_->active_connection_id_limit);
     values[kAckDelayExponentIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->ack_delay_exponent);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->ack_delay_exponent);
     values[kMaxAckDelayIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->ack_delay_exponent);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->ack_delay_exponent);
     values[kMaxAckDelayIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->max_ack_delay);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->max_ack_delay);
     values[kMaxDatagramFrameSizeIndex] =
-        BigInt::NewFromUnsigned(env->isolate(),
-            ptr_->max_datagram_frame_size);
+        BigInt::NewFromUnsigned(env->isolate(), ptr_->max_datagram_frame_size);
     values[kDisableActiveMigrationIndex] =
         Boolean::New(env->isolate(), ptr_->disable_active_migration);
   }
diff --git a/test/parallel/test-quic-session-application-options.mjs b/test/parallel/test-quic-session-application-options.mjs
new file mode 100644
index 00000000000000..1f5c9c0926808c
--- /dev/null
+++ b/test/parallel/test-quic-session-application-options.mjs
@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: session.applicationOptions
+// Verifies that applicationOptions is available after ALPN negotiation
+// completes (i.e., once the application has been selected), returns a
+// null-prototype object, and reflects the configured values.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+
+const { ok, strictEqual } = assert;
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('../common/quic.mjs');
+
+const customAppOptions = {
+  maxHeaderPairs: 50n,
+  maxHeaderLength: 8192n,
+  maxFieldSectionSize: 16384n,
+  qpackMaxDTableCapacity: 2048n,
+  qpackEncoderMaxDTableCapacity: 2048n,
+  qpackBlockedStreams: 50n,
+  enableConnectProtocol: false,
+  enableDatagrams: false,
+};
+
+const serverDone = Promise.withResolvers();
+
+const serverEndpoint = await listen(mustCall((serverSession) => {
+  serverSession.onstream = mustCall(async (stream) => {
+    // After the stream arrives, the handshake and ALPN negotiation are
+    // complete, so applicationOptions should be available.
+    const opts = serverSession.applicationOptions;
+
+    ok(opts != null, 'server applicationOptions should be available after handshake');
+    strictEqual(typeof opts, 'object');
+    strictEqual(Object.getPrototypeOf(opts), null);
+
+    // Verify configured values are reflected.
+    strictEqual(opts.maxHeaderPairs, BigInt(customAppOptions.maxHeaderPairs));
+    strictEqual(opts.maxHeaderLength, BigInt(customAppOptions.maxHeaderLength));
+    strictEqual(opts.maxFieldSectionSize,
+                BigInt(customAppOptions.maxFieldSectionSize));
+    strictEqual(opts.qpackMaxDtableCapacity,
+                BigInt(customAppOptions.qpackMaxDTableCapacity));
+    strictEqual(opts.qpackEncoderMaxDtableCapacity,
+                BigInt(customAppOptions.qpackEncoderMaxDTableCapacity));
+    strictEqual(opts.qpackBlockedStreams,
+                BigInt(customAppOptions.qpackBlockedStreams));
+    strictEqual(opts.enableConnectProtocol,
+                customAppOptions.enableConnectProtocol);
+    strictEqual(opts.enableDatagrams, customAppOptions.enableDatagrams);
+
+    stream.writer.endSync();
+    await stream.closed;
+    serverSession.close();
+    serverDone.resolve();
+  });
+}), {
+  application: customAppOptions,
+});
+
+const clientSession = await connect(serverEndpoint.address, {
+  application: customAppOptions,
+});
+await clientSession.opened;
+
+// After opened, ALPN negotiation is complete and applicationOptions
+// should be available on the client session.
+const clientOpts = clientSession.applicationOptions;
+ok(clientOpts != null, 'client applicationOptions should be available after handshake');
+strictEqual(typeof clientOpts, 'object');
+strictEqual(Object.getPrototypeOf(clientOpts), null);
+
+// Verify configured values on the client side.
+strictEqual(clientOpts.maxHeaderPairs, BigInt(customAppOptions.maxHeaderPairs));
+strictEqual(clientOpts.maxHeaderLength, BigInt(customAppOptions.maxHeaderLength));
+strictEqual(clientOpts.maxFieldSectionSize,
+            customAppOptions.maxFieldSectionSize);
+strictEqual(clientOpts.qpackMaxDtableCapacity,
+            customAppOptions.qpackMaxDTableCapacity);
+strictEqual(clientOpts.qpackEncoderMaxDtableCapacity,
+            customAppOptions.qpackEncoderMaxDTableCapacity);
+strictEqual(clientOpts.qpackBlockedStreams,
+            customAppOptions.qpackBlockedStreams);
+strictEqual(clientOpts.enableConnectProtocol,
+            customAppOptions.enableConnectProtocol);
+strictEqual(clientOpts.enableDatagrams, customAppOptions.enableDatagrams);
+
+// Exchange data to let the server side run its assertions.
+const stream = await clientSession.createBidirectionalStream();
+stream.writer.endSync();
+
+// eslint-disable-next-line no-unused-vars
+for await (const _ of stream) { /* drain */ }
+await Promise.all([stream.closed, serverDone.promise]);
+
+// After close, applicationOptions should return null.
+await clientSession.close();
+strictEqual(clientSession.applicationOptions, null);
+
+await serverEndpoint.close();

From 7e7bde86b3c31c999c17e15352dc6ccc570fc3c1 Mon Sep 17 00:00:00 2001
From: sangwook <bnbt3@naver.com>
Date: Fri, 22 May 2026 15:21:25 +0900
Subject: [PATCH 73/83] stream: fix Writable.toWeb() hang on synchronous drain

A race condition in the Writable.toWeb() adapter caused the stream
to hang if the underlying Node.js Writable emitted a 'drain' event
synchronously during a write() call. This often happened when
highWaterMark was set to 0.

By checking writableNeedDrain immediately after a backpressured write,
the adapter now correctly detects if the stream has already drained,
resolving the backpressure promise instead of waiting indefinitely
for an event that has already occurred.

Fixes: https://github.com/nodejs/node/issues/61145
Signed-off-by: sangwook <rewq5991@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/61197
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/webstreams/adapters.js           |  3 +++
 ...g-webstreams-adapters-to-writablestream.js | 23 +++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index 6fb78b816db7fd..38e327fad2081a 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -238,6 +238,9 @@ function newWritableStreamFromStreamWritable(streamWritable, options = kEmptyObj
         }
         if (streamWritable.writableNeedDrain || !streamWritable.write(chunk)) {
           backpressurePromise = PromiseWithResolvers();
+          if (!streamWritable.writableNeedDrain) {
+            backpressurePromise.resolve();
+          }
           return SafePromisePrototypeFinally(
             backpressurePromise.promise, () => {
               backpressurePromise = undefined;
diff --git a/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js b/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js
index 23e6319563daa0..60c0538a0c1efb 100644
--- a/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js
+++ b/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js
@@ -197,3 +197,26 @@ class TestWritable extends Writable {
     assert.strictEqual(chunk, arrayBuffer);
   }));
 }
+
+{
+  // Test that the stream doesn't hang when the underlying Writable
+  // emits 'drain' synchronously during write().
+  // Fixes: https://github.com/nodejs/node/issues/61145
+  const writable = new Writable({
+    write(chunk, encoding, callback) {
+      callback();
+    },
+  });
+
+  // Force synchronous 'drain' emission during write()
+  // to simulate a stream that doesn't have Node.js's built-in kSync protection.
+  writable.write = function(chunk) {
+    this.emit('drain');
+    return false;
+  };
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  const writer = writableStream.getWriter();
+  writer.write(new Uint8Array([1, 2, 3])).then(common.mustCall());
+  writer.write(new Uint8Array([4, 5, 6])).then(common.mustCall());
+}

From e11b9459d1a4518971d26d50c74af587e335f888 Mon Sep 17 00:00:00 2001
From: Chemi Atlow <chemi@atlow.co.il>
Date: Fri, 22 May 2026 10:39:45 +0300
Subject: [PATCH 74/83] test: isolate rerun-failures state file under tmpdir

The rerun-failures state file lived at a fixed path under fixtures/,
so concurrent invocations of test-runner-test-rerun-failures (e.g.
`python tools/test.py --repeat 100 -j 16 ...`) raced on a single file
and failed intermittently. Move the path to `tmpdir.resolve(...)` so
each process gets its own scratch state.

Signed-off-by: atlowChemi <chemi@atlow.co.il>
PR-URL: https://github.com/nodejs/node/pull/63449
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 test/parallel/test-runner-test-rerun-failures.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-runner-test-rerun-failures.js b/test/parallel/test-runner-test-rerun-failures.js
index 3a9249cc52277b..a4e8d96410346d 100644
--- a/test/parallel/test-runner-test-rerun-failures.js
+++ b/test/parallel/test-runner-test-rerun-failures.js
@@ -1,5 +1,6 @@
 'use strict';
 const common = require('../common');
+const tmpdir = require('../common/tmpdir');
 
 const fixtures = require('../common/fixtures');
 const assert = require('node:assert');
@@ -8,7 +9,8 @@ const { setTimeout } = require('node:timers/promises');
 const { test, beforeEach, afterEach, run } = require('node:test');
 
 const fixture = fixtures.path('test-runner', 'rerun.js');
-const stateFile = fixtures.path('test-runner', 'rerun-state.json');
+tmpdir.refresh();
+const stateFile = tmpdir.resolve('rerun-state.json');
 
 beforeEach(() => rm(stateFile, { force: true }));
 afterEach(() => rm(stateFile, { force: true }));

From 3553a34c2c596d9b1974e826b3a97bd25ec397d9 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Fri, 22 May 2026 14:04:13 +0200
Subject: [PATCH 75/83] debugger: surface inspector failures in probe mode

This addresses a few TODOs left from the initial implementation
around the error handling when the inspector session fails
mid-probe - for example because a probe expression terminates
the target, severs the inspector connection, or hangs the
evaluation. Before this patch, these failures would cause the
probe report to silently miss hits or hit the session timeout.
A consumer of these reports could not tell whether the
recorded hits were reliable or a partial trace cut short
by an inspector-side failure.

This patch surfaces those cases as a new `probe_failure` terminal
`error` event on the report, with best-effort attribution to the
implicated probe via `error.probe` and additional context on
`error.details`. Together with `probe_timeout`, it marks the
report as best-effort, and the probing process exits 1 in both
cases. `probe_target_exit` and clean `completed`/`miss` reports
continue to exit 0 because the recorded hits in those cases remain
ground truth, so tooling can use the exit code as a quick
trustworthiness signal. `error.message` now also contains
actionable recovery hints whereever possible.

The per-hit `error` is reshaped to `{ message, details? }`
so that the per-hit and terminal errors share a top-level shape.
Both fields are informative-only, only their top-level type is stable.

Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63437
Refs: https://github.com/nodejs/node/pull/62713
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Jan Martin <jan.krems@gmail.com>
---
 doc/api/debugger.md                           |  39 +-
 lib/internal/debugger/inspect_probe.js        | 436 +++++++++++++-----
 test/common/debugger-probe.js                 |  57 ++-
 .../debugger/probe-exits-during-probe.js      |   8 +
 .../probe-inspector-close-two-probes.js       |  13 +
 .../debugger/probe-inspector-resume.js        |  14 +
 test/fixtures/debugger/probe-script-throws.js |   9 +
 .../debugger/probe-target-syntax-error.js     |   3 +
 .../debugger/probe-throwing-getter.js         |  21 +
 test/fixtures/debugger/probe-types.js         |   9 -
 .../test-debugger-probe-expression-throws.js  |  64 +++
 ...gger-probe-failure-hang-during-evaluate.js |  58 +++
 ...est-debugger-probe-failure-process-exit.js |  50 ++
 .../test-debugger-probe-failure-resume.js     |  57 +++
 .../test-debugger-probe-script-throws.js      |  63 +++
 ...test-debugger-probe-target-syntax-error.js |  51 ++
 16 files changed, 798 insertions(+), 154 deletions(-)
 create mode 100644 test/fixtures/debugger/probe-exits-during-probe.js
 create mode 100644 test/fixtures/debugger/probe-inspector-close-two-probes.js
 create mode 100644 test/fixtures/debugger/probe-inspector-resume.js
 create mode 100644 test/fixtures/debugger/probe-script-throws.js
 create mode 100644 test/fixtures/debugger/probe-target-syntax-error.js
 create mode 100644 test/fixtures/debugger/probe-throwing-getter.js
 create mode 100644 test/parallel/test-debugger-probe-expression-throws.js
 create mode 100644 test/parallel/test-debugger-probe-failure-hang-during-evaluate.js
 create mode 100644 test/parallel/test-debugger-probe-failure-process-exit.js
 create mode 100644 test/parallel/test-debugger-probe-failure-resume.js
 create mode 100644 test/parallel/test-debugger-probe-script-throws.js
 create mode 100644 test/parallel/test-debugger-probe-target-syntax-error.js

diff --git a/doc/api/debugger.md b/doc/api/debugger.md
index 478a4534ad4ca9..2582750c58e4e6 100644
--- a/doc/api/debugger.md
+++ b/doc/api/debugger.md
@@ -237,6 +237,10 @@ added:
   - v26.1.0
   - v24.16.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/63437
+    description: Add `probe_failure` terminal `error` event for inspector-side mid-session
+        failures, and `error.details` for additional context on per-hit and terminal errors.
   - version: v26.2.0
     pr-url: https://github.com/nodejs/node/pull/63286
     description: JSON report schema bumped to v2. Probe `target` is now
@@ -383,7 +387,10 @@ $ node inspect --json --probe cli.js:5 --expr 'rss' cli.js
         "value": 55443456,
         "description": "55443456"
       }
-      // If the expression throws, "error" is present instead of "result".
+      // If the probe expression throws, fails, or never completes, the entry
+      // carries an `error` field instead of `result` with the shape
+      // `{ message: string, details?: object }`. The `message` and `details`
+      // content is informational only and may change between releases.
     },
     {
       "probe": 0,
@@ -415,24 +422,40 @@ $ node inspect --json --probe cli.js:5 --expr 'rss' cli.js
       //      "error": {
       //       "code": "probe_target_exit",
       //       "exitCode": 1,
-      //       "stderr": "[Error: boom]",
+      //       "stderr": "Error: boom",
       //       "message": "Target exited with code 1 before probes: app.js:10"
       //      }
       //    }
+      // 5. {
+      //      "event": "error",
+      //      "pending": [1],
+      //      "error": {
+      //       "code": "probe_failure",
+      //       "probe": 0,
+      //       "stderr": "...",
+      //       "message": "Target process exited during probe evaluation before probes: app.js:12. If the failure repeats, review the probe expression.",
+      //       "details": { "lastCdpMethod": "Debugger.evaluateOnCallFrame" }
+      //      }
+      //    }
     }
   ]
 }
 ```
 
-### Output and exit codes from the probed process
+### Output and exit codes
 
 Probe mode only prints the final probe report to stdout, and otherwise silences
 stdout/stderr from the child process. When the probing session ends,
-`node inspect` typically exits with code `0` and prints a final report to
-stdout. If the child process exits with a non-zero code before the
-probe session ends, the final report records a terminal `error` event along
-with the exit code and captured child stderr. The probing process itself
-still exits with code `0` in this case.
+the probing process typically exits with code `0` and prints a final report to
+stdout. If the child process exits with a non-zero code before the probe
+session ends, or the probe session cannot complete for another reason, the
+final report records a terminal `error` event.
+
+When `error.code` is `'probe_failure'` or `'probe_timeout'`, the probing process
+exits with a non-zero code, indicating recorded hits may be incomplete.
+In this case, `error.message` will contain recovery hints, and `error.probe`,
+when present, is an index into the report's `probes` array that identifies
+the possible culprit probe on a best-effort basis to help guide debugging.
 
 Invalid arguments and fatal launch or connect failures may cause the
 probing process to exit with a non-zero code and print an error message
diff --git a/lib/internal/debugger/inspect_probe.js b/lib/internal/debugger/inspect_probe.js
index 4600d8eb10ee3b..14f7413fea8ef1 100644
--- a/lib/internal/debugger/inspect_probe.js
+++ b/lib/internal/debugger/inspect_probe.js
@@ -12,7 +12,7 @@ const {
   NumberIsNaN,
   NumberParseInt,
   ObjectEntries,
-  Promise,
+  PromiseWithResolvers,
   RegExpPrototypeExec,
   RegExpPrototypeSymbolSplit,
   SafeMap,
@@ -20,6 +20,7 @@ const {
   StringPrototypeIncludes,
   StringPrototypeSlice,
   StringPrototypeStartsWith,
+  Symbol,
 } = primordials;
 
 const { clearTimeout, setTimeout } = require('timers');
@@ -42,6 +43,18 @@ const {
 const kProbeDefaultTimeout = 30000;
 const kProbeVersion = 2;
 const kProbeDisconnectSentinel = 'Waiting for the debugger to disconnect...';
+const kProbeAttachedSentinel = 'Debugger attached.';
+const kProbeListeningPrefix = 'Debugger listening on ws://';
+const kProbeEndingPrefix = 'Debugger ending on ws://';
+const kProbeHelpLine =
+  'For help, see: https://nodejs.org/learn/getting-started/debugging';
+// Thrown by `callCdp` after `recordInspectorFailure` has handled the failure,
+// so callers can short-circuit without recording duplicate events.
+const kInspectorFailedSentinel = Symbol('probe.inspectorFailed');
+const kStartupTeardownAdvice =
+  'The target startup may have torn down the inspector. If startup does ' +
+  'not touch the inspector, this is likely a Node.js bug. Please file an issue.';
+const kReviewProbeExprAdvice = 'If the failure repeats, review the probe expression.';
 const kDigitsRegex = /^\d+$/;
 const kInspectPortRegex = /^--inspect-port=(\d+)$/;
 
@@ -56,7 +69,7 @@ const kInspectPortRegex = /^--inspect-port=(\d+)$/;
 /**
  * Location where the probe was evaluated, serialized into the public report.
  * @typedef {object} Location
- * @property {string} url V8-reported script URL.
+ * @property {string} [url] V8-reported script URL, if known.
  * @property {number} line 1-based line number.
  * @property {number} column 1-based column number.
  */
@@ -118,17 +131,7 @@ function formatPendingProbeLocations(probes, pending) {
   return ArrayPrototypeJoin(ArrayFrom(seen), ', ');
 }
 
-function formatTargetExitMessage(probes, pending, exitCode, signal) {
-  const status = signal === null ?
-    `Target exited with code ${exitCode}` :
-    `Target exited with signal ${signal}`;
-  if (pending.length === 0) {
-    return `${status} before target completion`;
-  }
-  return `${status} before probes: ${formatPendingProbeLocations(probes, pending)}`;
-}
-
-// Trim the "Waiting for the debugger to disconnect..." message from stderr for reporting child errors.
+// Trim inspector-side noise lines from stderr for reporting child errors.
 function trimProbeChildStderr(stderr) {
   const lines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, stderr);
   const kept = [];
@@ -136,6 +139,10 @@ function trimProbeChildStderr(stderr) {
     const line = lines[i];
     if (line === '' && i === lines.length - 1) { continue; }
     if (line === kProbeDisconnectSentinel) { continue; }
+    if (line === kProbeAttachedSentinel) { continue; }
+    if (line === kProbeHelpLine) { continue; }
+    if (StringPrototypeStartsWith(line, kProbeListeningPrefix)) { continue; }
+    if (StringPrototypeStartsWith(line, kProbeEndingPrefix)) { continue; }
     ArrayPrototypePush(kept, line);
   }
   return ArrayPrototypeJoin(kept, '\n');
@@ -251,9 +258,7 @@ function buildProbeTextReport(report) {
         formatHitLocation(result.location) : formatTargetText(probe.target);
       ArrayPrototypePush(lines, `Hit ${result.hit} at ${locText}`);
       if (result.error !== undefined) {
-        ArrayPrototypePush(lines,
-                           `  [error] ${probe.expr} = ` +
-                           `${formatRemoteObject(result.error)}`);
+        ArrayPrototypePush(lines, `  [error] ${probe.expr} = ${result.error.message}`);
       } else {
         ArrayPrototypePush(lines,
                            `  ${probe.expr} = ` +
@@ -428,18 +433,29 @@ class ProbeInspectorSession {
     this.childStderr = '';
     this.disconnectRequested = false;
     this.finished = false;
+    // True once the inspector WebSocket connects. Event handlers ignore
+    // pre-connect exits/closes so launch/connect failures report through run().
+    this.connected = false;
+    // True once breakpoints are bound and the target is released from --inspect-brk
+    // via `Runtime.runIfWaitingForDebugger`.
+    // Distinguishes "exited before user code ran" from "exited during the live session".
     this.started = false;
-    this.stderrBuffer = '';
+    // A sliding buffer of at most kProbeDisconnectSentinel.length to detect disconnect.
+    this.disconnectSentinelBuffer = '';
     /** @type {Map<string, BreakpointDefinition>} keyed by V8 breakpointId. */
     this.breakpointDefinitions = new SafeMap();
     /** @type {Map<string, string>} scriptId -> URL. */
     this.scriptIdToUrl = new SafeMap();
     this.results = [];
     this.timeout = null;
-    this.resolveCompletion = null;
-    this.completionPromise = new Promise((resolve) => {
-      this.resolveCompletion = resolve;
-    });
+    // The currently-awaited CDP request, or null when no request is in flight.
+    /** @type {{ method: string, probe: { index: number, location: Location } | null } | null} */
+    this.inFlight = null;
+    // Most recently completed probe, used for `error.probe` when a non-evaluate CDP call rejects.
+    this.lastProbeIndex = null;
+    const { promise, resolve } = PromiseWithResolvers();
+    this.completionPromise = promise;
+    this.resolveCompletion = resolve;
     /** @type {Probe[]} */
     this.probes = ArrayPrototypeMap(options.probes, ({ expr, target }) => ({ expr, target, hits: 0 }));
     this.onChildOutput = FunctionPrototypeBind(this.onChildOutput, this);
@@ -449,81 +465,129 @@ class ProbeInspectorSession {
     this.onScriptParsed = FunctionPrototypeBind(this.onScriptParsed, this);
   }
 
-  finish(state) {
+  // Marking the probing process to exit with 0, recorded hits are trustworthy.
+  finishWithTrustedResult(terminal) {
+    this.finish(kNoFailure, terminal);
+  }
+
+  // Marking the probing process to exit with 1, recorded hits are best-effort.
+  finishWithUnreliableResult(terminal) {
+    this.finish(kGenericUserError, terminal);
+  }
+
+  finish(exitCode, terminal) {
     if (this.finished) { return; }
     this.finished = true;
     if (this.timeout !== null) {
       clearTimeout(this.timeout);
       this.timeout = null;
     }
-    this.resolveCompletion(state);
+    this.resolveCompletion({ exitCode, terminal });
+  }
+
+  getProbeTargetExitEvent(exitCode, signal) {
+    const pending = this.getPendingProbeIndices();
+    const how = signal !== null ? `with signal ${signal}` : `with code ${exitCode}`;
+    const status = pending.length === 0 ?
+      'target completion' : `probes: ${formatPendingProbeLocations(this.probes, pending)}`;
+    const error = {
+      __proto__: null,
+      code: 'probe_target_exit',
+      message: `Target exited ${how} before ${status}`,
+    };
+    if (exitCode !== null) { error.exitCode = exitCode; }
+    if (signal !== null) { error.signal = signal; }
+    error.stderr = trimProbeChildStderr(this.childStderr);
+    return { event: 'error', pending, error };
   }
 
   onChildOutput(text, which) {
     if (which !== 'stderr') { return; }
 
-    if (this.started) {
-      this.childStderr += text;
-    }
+    this.childStderr += text;
 
-    const combined = this.stderrBuffer + text;
-    if (this.started &&
+    const combined = this.disconnectSentinelBuffer + text;
+    // Detect the disconnect sentinel.
+    if (this.connected &&
         StringPrototypeIncludes(combined, kProbeDisconnectSentinel)) {
       this.disconnectRequested = true;
       this.client.reset();
     }
 
-    if (combined.length > kProbeDisconnectSentinel.length) {
-      this.stderrBuffer = StringPrototypeSlice(combined,
-                                               combined.length -
-                                               kProbeDisconnectSentinel.length);
+    if (combined.length > kProbeDisconnectSentinel.length) {  // Slide the buffer.
+      this.disconnectSentinelBuffer = StringPrototypeSlice(combined,
+                                                           combined.length - kProbeDisconnectSentinel.length);
     } else {
-      this.stderrBuffer = combined;
+      this.disconnectSentinelBuffer = combined;
     }
   }
 
   onChildExit(code, signal) {
-    if (this.started) {
-      if (code !== 0 || signal !== null) {
-        this.finish({
-          __proto__: null,
-          event: 'error',
-          exitCode: code,
-          signal,
-          stderr: trimProbeChildStderr(this.childStderr),
-        });
-      } else {
-        this.finish('complete');
-      }
+    // Pre-connect exits are deliberately silent: the target never reached
+    // a state where probes could be set, so any report would be empty.
+    if (!this.connected) { return; }
+    if (this.finished) { return; }
+    if (this.inFlight !== null && this.inFlight.probe !== null) {
+      this.recordInspectorFailure({
+        reason: 'Target process exited during probe evaluation',
+        advice: kReviewProbeExprAdvice,
+      });
+      return;
+    }
+    if (this.started && code === 0 && signal === null) {
+      const pending = this.getPendingProbeIndices();
+      this.finishWithTrustedResult(pending.length === 0 ? { event: 'completed' } : { event: 'miss', pending });
+      return;
     }
+    this.finishWithTrustedResult(this.getProbeTargetExitEvent(code, signal));
   }
 
   onClientClose() {
-    if (!this.started || this.child === null) { return; }
-
-    // TODO(joyeecheung): Surface mid-probe inspector disconnects as terminal probe errors
-    // instead of deferring to timeout or miss classification.
+    if (!this.connected) { return; }
     if (this.disconnectRequested) { return; }
+    if (this.finished) { return; }
 
     if (this.child.exitCode !== null || this.child.signalCode !== null) {
       this.onChildExit(this.child.exitCode, this.child.signalCode);
+      return;
     }
+    if (!this.started) {
+      this.recordInspectorFailure({
+        reason: 'Inspector connection lost before probes started',
+        advice: kStartupTeardownAdvice,
+      });
+      return;
+    }
+    if (this.inFlight !== null) {
+      if (this.inFlight.probe !== null || this.lastProbeIndex !== null) {
+        this.recordInspectorFailure({
+          reason: 'Inspector connection lost during probe activity',
+          advice: 'A probe expression may have caused the disconnection. ' +
+            'If the failure repeats, review the probe expressions.',
+        });
+      } else {
+        this.recordInspectorFailure({
+          reason: 'Inspector connection lost during inspector activity',
+          advice: 'This is likely a Node.js bug. Please file an issue.',
+        });
+      }
+      return;
+    }
+    this.recordInspectorFailure({
+      reason: 'Inspector connection lost',
+      advice: 'The target was likely terminated externally. If the failure ' +
+        'persists, check the target\'s process environment.',
+    });
   }
 
   onPaused(params) {
-    // TODO(joyeecheung): Preserve evaluation and resume failures as terminal probe errors
-    // instead of collapsing them into a synthetic completion.
     this.handlePaused(params).catch((error) => {
-      if (!this.finished) {
-        if (error?.code === 'ERR_DEBUGGER_ERROR') {
-          if (this.child !== null &&
-              (this.child.exitCode !== null || this.child.signalCode !== null)) {
-            this.onChildExit(this.child.exitCode, this.child.signalCode);
-          }
-          return;
-        }
-        this.finish('complete');
-      }
+      if (error === kInspectorFailedSentinel) { return; }
+      this.recordInspectorFailure({
+        reason: 'Probe mode encountered an unexpected internal failure',
+        advice: 'This is likely a Node.js bug. Please file an issue.',
+        internalError: error,
+      });
     });
   }
 
@@ -561,6 +625,7 @@ class ProbeInspectorSession {
       // Evaluate the expressions in the order they appear on the command line.
       for (const probeIndex of definition.probeIndices) {
         await this.evaluateProbe(callFrameId, probeIndex, location);
+        if (this.finished) { break; }
       }
     }
 
@@ -568,35 +633,181 @@ class ProbeInspectorSession {
   }
 
   async evaluateProbe(callFrameId, probeIndex, location) {
+    if (this.finished) { return; }
     const probe = this.probes[probeIndex];
-    const evaluation = await this.client.callMethod('Debugger.evaluateOnCallFrame', {
-      callFrameId,
-      expression: probe.expr,
-      generatePreview: true,
-    });
+    const evaluation = await this.callCdp(
+      'Debugger.evaluateOnCallFrame',
+      { callFrameId, expression: probe.expr, generatePreview: true },
+      { __proto__: null, index: probeIndex, location },
+    );
+    this.lastProbeIndex = probeIndex;
 
     probe.hits++;
     const result = { probe: probeIndex, event: 'hit', hit: probe.hits, location };
     if (evaluation.exceptionDetails !== undefined) {
-      result.error = evaluation.result === undefined ? {
-        type: 'object',
-        subtype: 'error',
-        description: 'Probe expression failed',
-      } : trimRemoteObject(evaluation.result);
+      result.error = {
+        __proto__: null,
+        message: evaluation.result?.description ?? 'Probe expression failed',
+        details: { __proto__: null, exception: trimRemoteObject(evaluation.exceptionDetails) },
+      };
     } else {
       result.result = trimRemoteObject(evaluation.result);
     }
-
     ArrayPrototypePush(this.results, result);
   }
 
   async resume() {
     if (this.finished) { return; }
-    await this.client.callMethod('Debugger.resume');
+    await this.callCdp('Debugger.resume');
+  }
+
+  async callCdp(method, params, probe = null) {
+    if (this.finished) { throw kInspectorFailedSentinel; }
+    this.inFlight = { __proto__: null, method, probe };
+    try {
+      const result = await this.client.callMethod(method, params);
+      // A timeout or process exit can finish the report while the CDP request
+      // is still outstanding. Ignore the late reply in that case.
+      if (this.finished) { throw kInspectorFailedSentinel; }
+      return result;
+    } catch (err) {
+      if (this.disconnectRequested) {
+        // Only the in-flight evaluation gets attribution. Other rejections
+        // under disconnect are downstream noise.
+        if (probe !== null) {
+          this.recordInspectorFailure({
+            reason: 'Target process exited during probe evaluation',
+            advice: kReviewProbeExprAdvice,
+          });
+        }
+        throw kInspectorFailedSentinel;
+      }
+      // Another event handler already recorded the terminal event.
+      if (this.finished) { throw kInspectorFailedSentinel; }
+      if (!this.started) {
+        this.recordInspectorFailure({
+          reason: 'Probe mode failed before user code ran',
+          advice: kStartupTeardownAdvice,
+          cdpError: err,
+        });
+      } else if (method === 'Debugger.evaluateOnCallFrame') {
+        this.recordInspectorFailure({
+          reason: 'The inspector could not evaluate a probe expression',
+          advice: `The rejection details are recorded on the probe hit. ${kReviewProbeExprAdvice}`,
+          cdpError: err,
+        });
+      } else if (this.lastProbeIndex !== null) {
+        this.recordInspectorFailure({
+          reason: 'Probe session failed after a probe evaluation',
+          advice: 'If the failure repeats, review the most-recently-evaluated probe expression.',
+          cdpError: err,
+        });
+      } else {
+        this.recordInspectorFailure({
+          reason: 'Probe session failed during inspector activity',
+          advice: 'This is likely a Node.js bug. Please file an issue.',
+          cdpError: err,
+        });
+      }
+      throw kInspectorFailedSentinel;
+    } finally {
+      this.inFlight = null;
+    }
+  }
+
+  // Records the first inspector-side terminal for the session, later callers are ignored.
+  recordInspectorFailure({ reason, advice, cdpError, internalError }) {
+    if (this.finished) { return; }
+    const child = this.child;
+    const exitedAbnormally = child !== null &&
+      (child.signalCode !== null || (child.exitCode !== null && child.exitCode !== 0));
+    const inFlightProbe = this.inFlight === null ? null : this.inFlight.probe;
+    // This normally emits `probe_failure`, but yields to `probe_target_exit` when the child
+    // has already exited abnormally and there is no in-flight probe to attribute to.
+    if (exitedAbnormally && inFlightProbe === null) {
+      this.finishWithTrustedResult(this.getProbeTargetExitEvent(child.exitCode, child.signalCode));
+      return;
+    }
+
+    const failedCdpMethod = this.inFlight === null ? null : this.inFlight.method;
+    let protocolError = null;
+    // // `ERR_DEBUGGER_ERROR` is a Node-internal code, not a CDP-level protocol code
+    if (cdpError !== undefined && cdpError.code !== 'ERR_DEBUGGER_ERROR') {
+      protocolError = { __proto__: null, message: cdpError.message, code: cdpError.code };
+    }
+    const protocolErrorGoesOnHit = (protocolError !== null) && (failedCdpMethod === 'Debugger.evaluateOnCallFrame');
+
+    let attribution = null;
+    if (inFlightProbe !== null) {
+      const { index, location } = inFlightProbe;
+      const error = { __proto__: null };
+      if (protocolErrorGoesOnHit) {
+        error.message = 'Probe evaluation failed at the protocol layer';
+        error.details = { __proto__: null, protocolError };
+      } else {
+        error.message = 'Probe evaluation did not complete';
+      }
+      this.probes[index].hits++;
+      ArrayPrototypePush(this.results, {
+        probe: index, event: 'hit', hit: this.probes[index].hits, location, error,
+      });
+      attribution = index;
+    } else if (failedCdpMethod !== null && this.lastProbeIndex !== null) {
+      attribution = this.lastProbeIndex;
+    }
+    // When there is no in-flight CDP call (e.g. `onClientClose` after all probes hit), ignore
+    // `lastProbeIndex` since it can't be attributed to a specific probe.
+
+    const pending = this.getPendingProbeIndices();
+    const suffix = pending.length === 0 ?
+      '' : ` before probes: ${formatPendingProbeLocations(this.probes, pending)}`;
+    const error = {
+      __proto__: null,
+      code: 'probe_failure',
+      message: `${reason}${suffix}. ${advice}`,
+    };
+    if (attribution !== null) { error.probe = attribution; }
+    error.stderr = trimProbeChildStderr(this.childStderr);
+
+    let details;
+    if (failedCdpMethod !== null) {
+      details = { __proto__: null, lastCdpMethod: failedCdpMethod };
+      if (protocolError !== null && !protocolErrorGoesOnHit) { details.protocolError = protocolError; }
+    }
+    if (internalError !== undefined) {
+      details ??= { __proto__: null };
+      details.internalError = { __proto__: null, message: internalError?.message, stack: internalError?.stack };
+    }
+    if (details !== undefined) { error.details = details; }
+
+    this.finishWithUnreliableResult({ event: 'error', pending, error });
   }
 
   startTimeout() {
-    this.timeout = setTimeout(() => { this.finish('timeout'); }, this.options.timeout);
+    this.timeout = setTimeout(() => {
+      if (this.finished) { return; }
+      if (this.inFlight !== null) {
+        const hasProbeAttribution =
+          this.inFlight.probe !== null || this.lastProbeIndex !== null;
+        this.recordInspectorFailure({
+          reason: 'Probe session timed out',
+          advice: hasProbeAttribution ?
+            ('The probe expression may be slow, hanging, or interfering with the inspector connection. ' +
+            'Try increasing `--timeout`; if the failure persists, review the probe expressions.') :
+            'Try increasing `--timeout`; if the failure persists, please file an issue.',
+        });
+        return;
+      }
+      const pending = this.getPendingProbeIndices();
+      const message = `Timed out after ${this.options.timeout}ms waiting for ` +
+        (pending.length === 0 ? 'target completion' :
+          `probes: ${formatPendingProbeLocations(this.probes, pending)}`);
+      this.finishWithUnreliableResult({
+        event: 'timeout',
+        pending,
+        error: { code: 'probe_timeout', message },
+      });
+    }, this.options.timeout);
     this.timeout.unref();
   }
 
@@ -649,7 +860,7 @@ class ProbeInspectorSession {
         params.columnNumber = target.column - 1;
       }
 
-      const result = await this.client.callMethod('Debugger.setBreakpointByUrl', params);
+      const result = await this.callCdp('Debugger.setBreakpointByUrl', params);
       this.breakpointDefinitions.set(result.breakpointId, { probeIndices });
     }
   }
@@ -664,53 +875,17 @@ class ProbeInspectorSession {
     return pending;
   }
 
-  buildReport(state) {
-    const pending = this.getPendingProbeIndices();
-    const report = {
-      v: kProbeVersion,
-      probes: ArrayPrototypeMap(this.probes, ({ expr, target }) => ({ expr, target })),
-      results: ArrayPrototypeSlice(this.results),
+  buildReport({ exitCode, terminal }) {
+    const results = ArrayPrototypeSlice(this.results);
+    ArrayPrototypePush(results, terminal);
+    return {
+      code: exitCode,
+      report: {
+        v: kProbeVersion,
+        probes: ArrayPrototypeMap(this.probes, ({ expr, target }) => ({ expr, target })),
+        results,
+      },
     };
-
-    if (state === 'timeout') {
-      ArrayPrototypePush(report.results, {
-        event: 'timeout',
-        pending,
-        error: {
-          code: 'probe_timeout',
-          message: pending.length === 0 ?
-            `Timed out after ${this.options.timeout}ms waiting for target completion` :
-            `Timed out after ${this.options.timeout}ms waiting for probes: ` +
-            `${formatPendingProbeLocations(this.probes, pending)}`,
-        },
-      });
-      return { code: kGenericUserError, report };
-    }
-
-    if (state?.event === 'error') {
-      const error = {
-        __proto__: null,
-        code: 'probe_target_exit',
-        message: formatTargetExitMessage(this.probes, pending, state.exitCode, state.signal),
-      };
-      if (state.exitCode !== null) {
-        error.exitCode = state.exitCode;
-      }
-      if (state.signal !== null) {
-        error.signal = state.signal;
-      }
-      error.stderr = state.stderr;
-      ArrayPrototypePush(report.results, { event: 'error', pending, error });
-      return { code: kNoFailure, report };
-    }
-
-    if (pending.length === 0) {
-      ArrayPrototypePush(report.results, { event: 'completed' });
-    } else {
-      ArrayPrototypePush(report.results, { event: 'miss', pending });
-    }
-
-    return { code: kNoFailure, report };
   }
 
   async cleanup() {
@@ -746,13 +921,18 @@ class ProbeInspectorSession {
       this.attachListeners();
 
       await this.client.connect(actualPort, actualHost);
-      await this.client.callMethod('Runtime.enable');
-      await this.client.callMethod('Debugger.enable');
-      await this.bindBreakpoints();
-      this.started = true;
-      this.startTimeout();
-
-      await this.client.callMethod('Runtime.runIfWaitingForDebugger');
+      this.connected = true;
+
+      try {
+        await this.callCdp('Runtime.enable');
+        await this.callCdp('Debugger.enable');
+        await this.bindBreakpoints();
+        this.started = true;
+        this.startTimeout();
+        await this.callCdp('Runtime.runIfWaitingForDebugger');
+      } catch (err) {
+        if (err !== kInspectorFailedSentinel) { throw err; }
+      }
 
       const state = await this.completionPromise;
       return this.buildReport(state);
diff --git a/test/common/debugger-probe.js b/test/common/debugger-probe.js
index c9e67931ee4573..bc5c206bb78926 100644
--- a/test/common/debugger-probe.js
+++ b/test/common/debugger-probe.js
@@ -10,30 +10,69 @@ const assert = require('assert');
 // https://github.com/nodejs/node/issues/58245
 const probeTargetExitSignal = 'SIGSEGV';
 
+function isProbeSegvTeardown(result) {
+  if (result?.event !== 'error') { return false; }
+  const error = result.error;
+  if (error?.signal !== probeTargetExitSignal) { return false; }
+  return error.code === 'probe_target_exit' || error.code === 'probe_failure';
+}
+
+function findProbeSegvTeardownLine(output) {
+  const signalPrefix = `Target exited with signal ${probeTargetExitSignal}`;
+  if (output.startsWith(signalPrefix)) { return 0; }
+  const idx = output.indexOf(`\n${signalPrefix}`);
+  return idx === -1 ? -1 : idx + 1;
+}
+
+// Replace volatile fields in a probe report (stack frames, Node.js version,
+// scriptId, callFrames) with stable placeholders for deepStrictEqual.
+function normalizeProbeReport(value) {
+  if (typeof value === 'string') {
+    return value
+      .replace(/(?:\n[ \t]+at\s[^\n]*)+/g, '\n<stack>')
+      .replace(/\nNode\.js v[^\n]+/g, '\nNode.js <version>');
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeProbeReport);
+  }
+  if (value !== null && typeof value === 'object') {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      if (key === 'scriptId') {
+        result[key] = '<scriptId>';
+      } else if (key === 'callFrames') {
+        result[key] = '<callFrames>';
+      } else {
+        result[key] = normalizeProbeReport(value[key]);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+
 function assertProbeJson(output, expected) {
   const normalized = JSON.parse(output);
   const lastResult = normalized.results?.[normalized.results.length - 1];
 
-  if (lastResult?.event === 'error' &&
-    lastResult.error?.code === 'probe_target_exit' &&
-    lastResult.error?.signal === probeTargetExitSignal) {
+  if (isProbeSegvTeardown(lastResult)) {
     // Log to facilitate debugging if this normalization is occurring.
     console.log('Normalizing trailing SIGSEGV in JSON probe output');
     normalized.results[normalized.results.length - 1] = expected.results.at(-1);
   }
 
-  assert.deepStrictEqual(normalized, expected);
+  assert.deepStrictEqual(normalizeProbeReport(normalized), normalizeProbeReport(expected));
 }
 
 function assertProbeText(output, expected) {
-  const signalPrefix = `Target exited with signal ${probeTargetExitSignal}`;
-  const idx = output.indexOf(signalPrefix);
+  const lineStart = findProbeSegvTeardownLine(output);
   let normalized;
-  if (idx !== -1) {
+  if (lineStart !== -1) {
     // Log to facilitate debugging if this normalization is occurring.
     console.log('Normalizing trailing SIGSEGV in text probe output');
-    const lineStart = output.lastIndexOf('\n', idx);
-    normalized = (lineStart === -1 ? '' : output.slice(0, lineStart)) + '\nCompleted';
+    const expectedLineStart = expected.lastIndexOf('\n');
+    const terminalLine = expectedLineStart === -1 ? expected : expected.slice(expectedLineStart + 1);
+    normalized = lineStart === 0 ? terminalLine : `${output.slice(0, lineStart - 1)}\n${terminalLine}`;
   } else {
     normalized = output;
   }
diff --git a/test/fixtures/debugger/probe-exits-during-probe.js b/test/fixtures/debugger/probe-exits-during-probe.js
new file mode 100644
index 00000000000000..7bed0703f90570
--- /dev/null
+++ b/test/fixtures/debugger/probe-exits-during-probe.js
@@ -0,0 +1,8 @@
+'use strict';
+
+function exitDuringProbe() {
+  process.exit(0);
+}
+
+module.exports = { exitDuringProbe };
+globalThis.probeLine = 1;
diff --git a/test/fixtures/debugger/probe-inspector-close-two-probes.js b/test/fixtures/debugger/probe-inspector-close-two-probes.js
new file mode 100644
index 00000000000000..43bf438e899547
--- /dev/null
+++ b/test/fixtures/debugger/probe-inspector-close-two-probes.js
@@ -0,0 +1,13 @@
+'use strict';
+
+const fs = require('fs');
+const inspector = require('inspector');
+
+fs.writeSync(2, 'probe-inspector-close-marker\n');
+
+const closeInspector = () => { inspector.close(); };
+
+const firstProbeLine = 1;
+const secondProbeLine = 2;
+
+setInterval(() => {}, 1000);
diff --git a/test/fixtures/debugger/probe-inspector-resume.js b/test/fixtures/debugger/probe-inspector-resume.js
new file mode 100644
index 00000000000000..f8025c53e7191c
--- /dev/null
+++ b/test/fixtures/debugger/probe-inspector-resume.js
@@ -0,0 +1,14 @@
+'use strict';
+const { Session } = require('inspector');
+
+function callInspectorResume() {
+  const session = new Session();
+  session.connect();
+  // Use a callback to ensure the probing resume happens after this one is delivered.
+  session.post('Debugger.resume', () => {});
+  return 1;
+}
+
+const probeLine = 1;
+module.exports = { callInspectorResume };
+setInterval(() => {}, 1000);  // Keep it alive to prevent early exit.
diff --git a/test/fixtures/debugger/probe-script-throws.js b/test/fixtures/debugger/probe-script-throws.js
new file mode 100644
index 00000000000000..c253eaf163a193
--- /dev/null
+++ b/test/fixtures/debugger/probe-script-throws.js
@@ -0,0 +1,9 @@
+'use strict';
+
+function neverCalled() {
+  return 1;
+}
+
+const reached = 1;
+throw new Error('boom');
+neverCalled();
diff --git a/test/fixtures/debugger/probe-target-syntax-error.js b/test/fixtures/debugger/probe-target-syntax-error.js
new file mode 100644
index 00000000000000..a72137f7fe1346
--- /dev/null
+++ b/test/fixtures/debugger/probe-target-syntax-error.js
@@ -0,0 +1,3 @@
+'use strict';
+
+const x = ;
diff --git a/test/fixtures/debugger/probe-throwing-getter.js b/test/fixtures/debugger/probe-throwing-getter.js
new file mode 100644
index 00000000000000..906e464f98dd87
--- /dev/null
+++ b/test/fixtures/debugger/probe-throwing-getter.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const holder = {
+  get throwingGetter() {
+    throw new Error('boom');
+  },
+};
+
+let probesDone = false;
+function markProbesDone() {
+  probesDone = true;
+}
+
+module.exports = { holder, markProbesDone };
+
+globalThis.probeLine1 = 1;
+globalThis.probeLine2 = 2;
+
+const interval = setInterval(() => {
+  if (probesDone) clearInterval(interval);
+}, 50);
diff --git a/test/fixtures/debugger/probe-types.js b/test/fixtures/debugger/probe-types.js
index d5d676a6b8dfa4..9ca45b69684b37 100644
--- a/test/fixtures/debugger/probe-types.js
+++ b/test/fixtures/debugger/probe-types.js
@@ -15,12 +15,3 @@ errorValue.stack = 'Error: boom';
 
 function consume() {}
 consume();
-
-// TODO(joyeecheung): add a test for evaluation errors. This can be
-// somewhat flaky on slow CI machines.
-// const holder = new class Foo {
-//   get throwingGetter() {
-//     throw new Error('foo');
-//   }
-// }
-// probe holder.throwingGetter
diff --git a/test/parallel/test-debugger-probe-expression-throws.js b/test/parallel/test-debugger-probe-expression-throws.js
new file mode 100644
index 00000000000000..a5447fe0a0f590
--- /dev/null
+++ b/test/parallel/test-debugger-probe-expression-throws.js
@@ -0,0 +1,64 @@
+// This tests that a probe expression throwing an exception is recorded as
+// a per-hit error and does not fail the session.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-throwing-getter.js';
+const probes = [
+  { expr: 'holder.throwingGetter', target: { suffix: fixture, line: 16 } },
+  // This clears the interval so the process will exit naturally.
+  { expr: 'markProbesDone()', target: { suffix: fixture, line: 17 } },
+];
+const url = fixtures.fileURL('debugger', fixture).href;
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:16`, '--expr', probes[0].expr,
+  '--probe', `${fixture}:17`, '--expr', probes[1].expr,
+  fixture,
+], { cwd }, {
+  status: 0,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location: { url, line: 16, column: 1 },
+        error: {
+          message: 'Error: boom\n<stack>',
+          details: {
+            exception: {
+              exceptionId: 1,
+              text: 'Uncaught',
+              lineNumber: 4,
+              columnNumber: 4,
+              scriptId: '<scriptId>',
+              stackTrace: { callFrames: '<callFrames>' },
+              exception: { type: 'object', subtype: 'error', description: 'Error: boom\n<stack>' },
+            },
+          },
+        },
+      }, {
+        probe: 1,
+        event: 'hit',
+        hit: 1,
+        location: { url, line: 17, column: 1 },
+        result: { type: 'undefined' },
+      }, {
+        event: 'completed',
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/parallel/test-debugger-probe-failure-hang-during-evaluate.js b/test/parallel/test-debugger-probe-failure-hang-during-evaluate.js
new file mode 100644
index 00000000000000..332b519d393fcd
--- /dev/null
+++ b/test/parallel/test-debugger-probe-failure-hang-during-evaluate.js
@@ -0,0 +1,58 @@
+// This tests that when a probe expression closes the inspector mid-session,
+// session failure surfaces as probe_failure with downstream probes left pending.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-inspector-close-two-probes.js';
+const marker = 'probe-inspector-close-marker';
+const timeoutMs = common.platformTimeout(1000);
+const probes = [
+  { expr: 'closeInspector()', target: { suffix: fixture, line: 10 } },
+  { expr: 'firstProbeLine', target: { suffix: fixture, line: 11 } },
+];
+const location = { url: fixtures.fileURL('debugger', fixture).href, line: 10, column: 24 };
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json', `--timeout=${timeoutMs}`,
+  '--probe', `${fixture}:10`, '--expr', probes[0].expr,
+  '--probe', `${fixture}:11`, '--expr', probes[1].expr,
+  fixture,
+], { cwd }, {
+  status: 1,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location,
+        error: { message: 'Probe evaluation did not complete' },
+      }, {
+        event: 'error',
+        pending: [1],
+        error: {
+          code: 'probe_failure',
+          message:
+            `Probe session timed out before probes: ${fixture}:11. ` +
+            'The probe expression may be slow, hanging, or interfering ' +
+            'with the inspector connection. Try increasing `--timeout`; ' +
+            'if the failure persists, review the probe expressions.',
+          probe: 0,
+          stderr: marker,
+          details: { lastCdpMethod: 'Debugger.evaluateOnCallFrame' },
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/parallel/test-debugger-probe-failure-process-exit.js b/test/parallel/test-debugger-probe-failure-process-exit.js
new file mode 100644
index 00000000000000..1e14c8b2b81842
--- /dev/null
+++ b/test/parallel/test-debugger-probe-failure-process-exit.js
@@ -0,0 +1,50 @@
+// This tests that a clean process.exit(0) from inside a probe expression
+// surfaces as probe_failure, not probe_target_exit.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-exits-during-probe.js';
+const probes = [{ expr: 'exitDuringProbe()', target: { suffix: fixture, line: 8 } }];
+const location = { url: fixtures.fileURL('debugger', fixture).href, line: 8, column: 1 };
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:8`, '--expr', probes[0].expr,
+  fixture,
+], { cwd }, {
+  status: 1,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location,
+        error: { message: 'Probe evaluation did not complete' },
+      }, {
+        event: 'error',
+        pending: [],
+        error: {
+          code: 'probe_failure',
+          message:
+            'Target process exited during probe evaluation. ' +
+            'If the failure repeats, review the probe expression.',
+          probe: 0,
+          stderr: '',
+          details: { lastCdpMethod: 'Debugger.evaluateOnCallFrame' },
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/parallel/test-debugger-probe-failure-resume.js b/test/parallel/test-debugger-probe-failure-resume.js
new file mode 100644
index 00000000000000..e5578ec452e1e7
--- /dev/null
+++ b/test/parallel/test-debugger-probe-failure-resume.js
@@ -0,0 +1,57 @@
+// This tests that a probe expression resuming the target through its own
+// inspector.Session surfaces as probe_failure.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-inspector-resume.js';
+const probes = [{
+  expr: 'callInspectorResume()',
+  target: { suffix: fixture, line: 12 },
+}];
+const location = { url: fixtures.fileURL('debugger', fixture).href, line: 12, column: 19 };
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:12`, '--expr', probes[0].expr,
+  fixture,
+], { cwd }, {
+  status: 1,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location,
+        result: { type: 'number', value: 1, description: '1' },
+      }, {
+        event: 'error',
+        pending: [],
+        error: {
+          code: 'probe_failure',
+          message:
+            'Probe session failed after a probe evaluation. If the ' +
+            'failure repeats, review the most-recently-evaluated probe ' +
+            'expression.',
+          probe: 0,
+          stderr: '',
+          details: {
+            lastCdpMethod: 'Debugger.resume',
+            protocolError: { message: 'Can only perform operation while paused.', code: -32000 },
+          },
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/parallel/test-debugger-probe-script-throws.js b/test/parallel/test-debugger-probe-script-throws.js
new file mode 100644
index 00000000000000..0df67adb6a862a
--- /dev/null
+++ b/test/parallel/test-debugger-probe-script-throws.js
@@ -0,0 +1,63 @@
+// This tests that an uncaught throw in the target between probe hits is
+// surfaced as probe_target_exit, with hits before the throw preserved.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const path = require('path');
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-script-throws.js';
+const fixturePath = path.join(cwd, fixture);
+const probes = [
+  { expr: '\'before-throw\'', target: { suffix: fixture, line: 7 } },
+  { expr: '99', target: { suffix: fixture, line: 4 } },
+];
+const location = { url: fixtures.fileURL('debugger', fixture).href, line: 7, column: 17 };
+const stderr =
+  `${fixturePath}:8\n` +
+  'throw new Error(\'boom\');\n' +
+  '^\n' +
+  '\n' +
+  'Error: boom\n' +
+  '<stack>\n' +
+  '\n' +
+  'Node.js <version>';
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:7`, '--expr', probes[0].expr,
+  '--probe', `${fixture}:4`, '--expr', probes[1].expr,
+  fixture,
+], { cwd }, {
+  // probe_target_exit: probing process exits 0 (hits trustworthy).
+  status: 0,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location,
+        result: { type: 'string', value: 'before-throw' },
+      }, {
+        event: 'error',
+        pending: [1],
+        error: {
+          code: 'probe_target_exit',
+          message: `Target exited with code 1 before probes: ${fixture}:4`,
+          exitCode: 1,
+          stderr,
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/parallel/test-debugger-probe-target-syntax-error.js b/test/parallel/test-debugger-probe-target-syntax-error.js
new file mode 100644
index 00000000000000..905bcd0b6ce3e3
--- /dev/null
+++ b/test/parallel/test-debugger-probe-target-syntax-error.js
@@ -0,0 +1,51 @@
+// This tests that a target script that fails to parse is surfaced as probe_target_exit.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const path = require('path');
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-target-syntax-error.js';
+const fixturePath = path.join(cwd, fixture);
+const probes = [{ expr: 'x', target: { suffix: fixture, line: 3 } }];
+const stderr =
+  `${fixturePath}:3\n` +
+  'const x = ;\n' +
+  '          ^\n' +
+  '\n' +
+  'SyntaxError: Unexpected token \';\'\n' +
+  '<stack>\n' +
+  '\n' +
+  'Node.js <version>';
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:3`, '--expr', probes[0].expr,
+  fixture,
+], { cwd }, {
+  // probe_target_exit: probing process exits 0.
+  status: 0,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        event: 'error',
+        pending: [0],
+        error: {
+          code: 'probe_target_exit',
+          message: `Target exited with code 1 before probes: ${fixture}:3`,
+          exitCode: 1,
+          stderr,
+        },
+      }],
+    });
+  },
+  trim: true,
+});

From 10f8a8310eb594a51e57cd6c9d6c6526cc52ed89 Mon Sep 17 00:00:00 2001
From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
Date: Fri, 22 May 2026 16:40:20 +0200
Subject: [PATCH 76/83] doc: add Rust toolchain general install instructions

Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com>
PR-URL: https://github.com/nodejs/node/pull/63426
Refs: https://github.com/nodejs/node/issues/63225
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Richard Lau <richard.lau@ibm.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 BUILDING.md | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/BUILDING.md b/BUILDING.md
index c302cf3f8f6083..d10c1b685ac24e 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -237,10 +237,23 @@ tarball and/or browse the git repository checked out at the relevant tag.
 ### Prerequisites
 
 * [A supported version of Python][Python versions] for building and testing.
-* Memory: at least 8GB of RAM is typically required when compiling with 4 parallel jobs (e.g: `make -j4`)
+* A Rust toolchain if [building Node.js with Temporal support](#building-nodejs-with-temporal-support)
+  is required (enabled by default starting in Node.js 26).
+* Memory: at least 8GB of RAM is typically required when compiling with 4 parallel jobs (e.g: `make -j4`).
 
 ### Unix and macOS
 
+Consult the official [Install Rust](https://rust-lang.org/tools/install/)
+instructions to install a Rust toolchain, required for Temporal support introduced in Node.js 25.4.0.
+Individual packages such as `rust` and `cargo` in some operating system distributions may be considered
+as an alternative, for example in CI environments.
+Consult with relevant operating system documentation to ensure that packages
+meet the minimum version specified in the
+[Building Node.js with Temporal support](#building-nodejs-with-temporal-support) section,
+as packaged versions may lag behind the `stable` version installed by the official instructions.
+Avoid mixing `rustup` together with `rust` and `cargo` package installations, due to
+potential version conflicts.
+
 #### Unix prerequisites
 
 * `gcc` and `g++` >= 13.2 or `clang` and `clang++` >= 19.1
@@ -1056,6 +1069,8 @@ requires a Rust toolchain:
 * rustc >= 1.82 (with LLVM >= 19)
 * cargo >= 1.82
 
+Refer to [Install Rust](https://rust-lang.org/tools/install/) for instructions.
+
 If `--v8-enable-temporal-support` and `--v8-disable-temporal-support` are both
 omitted, `configure.py` probes for `cargo` and `rustc`. If either is missing,
 a warning is printed and Temporal support is disabled.

From 5ff701aa28d5c6468120cb736095068d34e645cb Mon Sep 17 00:00:00 2001
From: Daijiro Wachi <daijiro.wachi@gmail.com>
Date: Sat, 23 May 2026 01:11:55 +0900
Subject: [PATCH 77/83] doc: fix "options" to "option" in tls.createServer

Signed-off-by: Daijiro Wachi <daijiro.wachi@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63453
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/tls.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/tls.md b/doc/api/tls.md
index 5d11e2c53eada0..a1a8c98d987784 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -2199,7 +2199,7 @@ changes:
 Creates a new [`tls.Server`][]. The `secureConnectionListener`, if provided, is
 automatically set as a listener for the [`'secureConnection'`][] event.
 
-The `ticketKeys` options is automatically shared between `node:cluster` module
+The `ticketKeys` option is automatically shared between `node:cluster` module
 workers.
 
 The following illustrates a simple echo server:

From ca3766568e320fe826f80b6ee4da5cf005255d04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9?= <contact.9a5d6388@renegade334.me.uk>
Date: Fri, 22 May 2026 18:01:28 +0100
Subject: [PATCH 78/83] ffi: move DynamicLibrary disposer to native layer

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>
PR-URL: https://github.com/nodejs/node/pull/63459
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Paolo Insogna <paolo@cowtech.it>
---
 lib/ffi.js      | 4 ----
 src/node_ffi.cc | 1 +
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/lib/ffi.js b/lib/ffi.js
index b3a1563b520dcc..5dc1d80ba5c700 100644
--- a/lib/ffi.js
+++ b/lib/ffi.js
@@ -56,10 +56,6 @@ const {
 
 require('internal/ffi-shared-buffer');
 
-DynamicLibrary.prototype[SymbolDispose] = function() {
-  this.close();
-};
-
 function checkFFIPermission() {
   if (!permission.isEnabled()) {
     return;
diff --git a/src/node_ffi.cc b/src/node_ffi.cc
index 34f999b015123b..c8197827ac47ae 100644
--- a/src/node_ffi.cc
+++ b/src/node_ffi.cc
@@ -1102,6 +1102,7 @@ Local<FunctionTemplate> DynamicLibrary::GetConstructorTemplate(
         static_cast<PropertyAttribute>(ReadOnly));
 
     SetProtoMethod(isolate, tmpl, "close", DynamicLibrary::Close);
+    SetProtoDispose(isolate, tmpl, DynamicLibrary::Close);
     SetProtoMethod(isolate, tmpl, "getFunction", DynamicLibrary::GetFunction);
     SetProtoMethod(isolate, tmpl, "getFunctions", DynamicLibrary::GetFunctions);
     SetProtoMethod(isolate, tmpl, "getSymbol", DynamicLibrary::GetSymbol);

From 11ea171f82cec8338c091cc2447ef3327860e570 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 22 May 2026 21:45:33 +0200
Subject: [PATCH 79/83] tools: mock some Python utils in `v8.nix` to reuse
 builds

Signed-off-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/63454
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 tools/nix/v8.nix | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/tools/nix/v8.nix b/tools/nix/v8.nix
index 73356f067c3a63..fa931092a83f08 100644
--- a/tools/nix/v8.nix
+++ b/tools/nix/v8.nix
@@ -33,13 +33,8 @@ let
         ../../deps/v8
         ../../node.gyp
         ../../node.gypi
-        ../../src/node_version.h
-        ../../tools/configure.d/nodedownload.py
-        ../../tools/getmoduleversion.py
-        ../../tools/getnapibuildversion.py
         ../../tools/gyp/pylib
         ../../tools/gyp_node.py
-        ../../tools/utils.py
         ../../tools/v8_gypfiles/abseil.gyp
         ../../tools/v8_gypfiles/features.gypi
         ../../tools/v8_gypfiles/ForEachFormat.py
@@ -103,6 +98,30 @@ stdenv.mkDerivation (finalAttrs: {
         patches+=("$filtered")
       fi
     done
+  ''
+  # We also need to mock some Python util files that are not used to configure Python.
+  # Mocking lets us avoid rebuilding the whole derivation if there's a unrelated
+  # change in one of those files.
+  + ''
+    mkdir -p tools/configure.d
+    cat -> tools/configure.d/nodedownload.py <<'EOF'
+    def parse(opt):
+      return {}
+    def help():
+      return ""
+    EOF
+    cat -> tools/getmoduleversion.py <<'EOF'
+    def get_version():
+      return "99"
+    EOF
+    cat -> tools/getnapibuildversion.py <<'EOF'
+    def get_napi_version():
+      return "9"
+    EOF
+    cat -> tools/utils.py <<'EOF'
+    def SearchFiles(dir, ext):
+      return []
+    EOF
   '';
   # We need to remove the node_inspector.gypi ref so GYP does not search for it.
   postPatch = ''

From fa0aadc271e924914b548acde1950d636eca1e8e Mon Sep 17 00:00:00 2001
From: npm CLI robot <npm-cli+bot@github.com>
Date: Fri, 22 May 2026 13:58:11 -0700
Subject: [PATCH 80/83] deps: upgrade npm to 11.15.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/63463
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jordan Harband <ljharb@gmail.com>
---
 deps/npm/docs/content/commands/npm-ci.md      |   59 +-
 deps/npm/docs/content/commands/npm-dedupe.md  |   59 +-
 .../content/commands/npm-install-ci-test.md   |   59 +-
 .../docs/content/commands/npm-install-test.md |   75 +-
 deps/npm/docs/content/commands/npm-install.md |   75 +-
 deps/npm/docs/content/commands/npm-link.md    |   59 +-
 deps/npm/docs/content/commands/npm-ls.md      |    2 +-
 .../npm/docs/content/commands/npm-outdated.md |   16 +-
 deps/npm/docs/content/commands/npm-stage.md   |  255 +++
 deps/npm/docs/content/commands/npm-trust.md   |   23 +-
 deps/npm/docs/content/commands/npm-update.md  |   16 +-
 deps/npm/docs/content/commands/npm.md         |    2 +-
 deps/npm/docs/content/using-npm/config.md     |   75 +-
 deps/npm/docs/output/commands/npm-access.html |    4 +-
 .../npm/docs/output/commands/npm-adduser.html |    4 +-
 deps/npm/docs/output/commands/npm-audit.html  |    4 +-
 deps/npm/docs/output/commands/npm-bugs.html   |    4 +-
 deps/npm/docs/output/commands/npm-cache.html  |    4 +-
 deps/npm/docs/output/commands/npm-ci.html     |   53 +-
 .../docs/output/commands/npm-completion.html  |    4 +-
 deps/npm/docs/output/commands/npm-config.html |    4 +-
 deps/npm/docs/output/commands/npm-dedupe.html |   53 +-
 .../docs/output/commands/npm-deprecate.html   |    4 +-
 deps/npm/docs/output/commands/npm-diff.html   |    4 +-
 .../docs/output/commands/npm-dist-tag.html    |    4 +-
 deps/npm/docs/output/commands/npm-docs.html   |    4 +-
 deps/npm/docs/output/commands/npm-doctor.html |    4 +-
 deps/npm/docs/output/commands/npm-edit.html   |    4 +-
 deps/npm/docs/output/commands/npm-exec.html   |    4 +-
 .../npm/docs/output/commands/npm-explain.html |    4 +-
 .../npm/docs/output/commands/npm-explore.html |    4 +-
 .../docs/output/commands/npm-find-dupes.html  |    4 +-
 deps/npm/docs/output/commands/npm-fund.html   |    4 +-
 deps/npm/docs/output/commands/npm-get.html    |    4 +-
 .../docs/output/commands/npm-help-search.html |    4 +-
 deps/npm/docs/output/commands/npm-help.html   |    4 +-
 deps/npm/docs/output/commands/npm-init.html   |    4 +-
 .../output/commands/npm-install-ci-test.html  |   53 +-
 .../output/commands/npm-install-test.html     |   66 +-
 .../npm/docs/output/commands/npm-install.html |   66 +-
 deps/npm/docs/output/commands/npm-link.html   |   53 +-
 deps/npm/docs/output/commands/npm-ll.html     |    4 +-
 deps/npm/docs/output/commands/npm-login.html  |    4 +-
 deps/npm/docs/output/commands/npm-logout.html |    4 +-
 deps/npm/docs/output/commands/npm-ls.html     |    6 +-
 deps/npm/docs/output/commands/npm-org.html    |    4 +-
 .../docs/output/commands/npm-outdated.html    |   17 +-
 deps/npm/docs/output/commands/npm-owner.html  |    4 +-
 deps/npm/docs/output/commands/npm-pack.html   |    4 +-
 deps/npm/docs/output/commands/npm-ping.html   |    4 +-
 deps/npm/docs/output/commands/npm-pkg.html    |    4 +-
 deps/npm/docs/output/commands/npm-prefix.html |    4 +-
 .../npm/docs/output/commands/npm-profile.html |    4 +-
 deps/npm/docs/output/commands/npm-prune.html  |    4 +-
 .../npm/docs/output/commands/npm-publish.html |    4 +-
 deps/npm/docs/output/commands/npm-query.html  |    4 +-
 .../npm/docs/output/commands/npm-rebuild.html |    4 +-
 deps/npm/docs/output/commands/npm-repo.html   |    4 +-
 .../npm/docs/output/commands/npm-restart.html |    4 +-
 deps/npm/docs/output/commands/npm-root.html   |    4 +-
 deps/npm/docs/output/commands/npm-run.html    |    4 +-
 deps/npm/docs/output/commands/npm-sbom.html   |    4 +-
 deps/npm/docs/output/commands/npm-search.html |    4 +-
 deps/npm/docs/output/commands/npm-set.html    |    4 +-
 .../docs/output/commands/npm-shrinkwrap.html  |    4 +-
 deps/npm/docs/output/commands/npm-stage.html  |  582 ++++++
 deps/npm/docs/output/commands/npm-star.html   |    4 +-
 deps/npm/docs/output/commands/npm-stars.html  |    4 +-
 deps/npm/docs/output/commands/npm-start.html  |    4 +-
 deps/npm/docs/output/commands/npm-stop.html   |    4 +-
 deps/npm/docs/output/commands/npm-team.html   |    4 +-
 deps/npm/docs/output/commands/npm-test.html   |    4 +-
 deps/npm/docs/output/commands/npm-token.html  |    4 +-
 deps/npm/docs/output/commands/npm-trust.html  |   56 +-
 .../docs/output/commands/npm-undeprecate.html |    4 +-
 .../docs/output/commands/npm-uninstall.html   |    4 +-
 .../docs/output/commands/npm-unpublish.html   |    4 +-
 deps/npm/docs/output/commands/npm-unstar.html |    4 +-
 deps/npm/docs/output/commands/npm-update.html |   17 +-
 .../npm/docs/output/commands/npm-version.html |    4 +-
 deps/npm/docs/output/commands/npm-view.html   |    4 +-
 deps/npm/docs/output/commands/npm-whoami.html |    4 +-
 deps/npm/docs/output/commands/npm.html        |    6 +-
 deps/npm/docs/output/commands/npx.html        |    4 +-
 .../docs/output/configuring-npm/folders.html  |    4 +-
 .../docs/output/configuring-npm/install.html  |    4 +-
 .../output/configuring-npm/npm-global.html    |    4 +-
 .../docs/output/configuring-npm/npm-json.html |    4 +-
 .../configuring-npm/npm-shrinkwrap-json.html  |    4 +-
 .../docs/output/configuring-npm/npmrc.html    |    4 +-
 .../output/configuring-npm/package-json.html  |    4 +-
 .../configuring-npm/package-lock-json.html    |    4 +-
 deps/npm/docs/output/using-npm/config.html    |   66 +-
 .../using-npm/dependency-selectors.html       |    4 +-
 .../npm/docs/output/using-npm/developers.html |    4 +-
 deps/npm/docs/output/using-npm/logging.html   |    4 +-
 deps/npm/docs/output/using-npm/orgs.html      |    4 +-
 .../docs/output/using-npm/package-spec.html   |    4 +-
 deps/npm/docs/output/using-npm/registry.html  |    4 +-
 deps/npm/docs/output/using-npm/removal.html   |    4 +-
 deps/npm/docs/output/using-npm/scope.html     |    4 +-
 deps/npm/docs/output/using-npm/scripts.html   |    4 +-
 .../npm/docs/output/using-npm/workspaces.html |    4 +-
 deps/npm/lib/commands/ci.js                   |    3 +
 deps/npm/lib/commands/dedupe.js               |    3 +
 deps/npm/lib/commands/install.js              |    3 +
 deps/npm/lib/commands/link.js                 |    3 +
 deps/npm/lib/commands/outdated.js             |    1 +
 deps/npm/lib/commands/publish.js              |   57 +-
 deps/npm/lib/commands/stage/approve.js        |   35 +
 deps/npm/lib/commands/stage/download.js       |   70 +
 deps/npm/lib/commands/stage/index.js          |   25 +
 deps/npm/lib/commands/stage/list.js           |   72 +
 deps/npm/lib/commands/stage/publish.js        |   13 +
 deps/npm/lib/commands/stage/reject.js         |   37 +
 deps/npm/lib/commands/stage/view.js           |   34 +
 deps/npm/lib/commands/trust/circleci.js       |   13 +-
 deps/npm/lib/commands/trust/github.js         |    5 +-
 deps/npm/lib/commands/trust/gitlab.js         |    5 +-
 deps/npm/lib/commands/update.js               |    1 +
 deps/npm/lib/trust-cmd.js                     |   69 +-
 deps/npm/lib/utils/cmd-list.js                |    1 +
 deps/npm/lib/utils/display.js                 |   11 +-
 deps/npm/lib/utils/key-values.js              |   42 +
 deps/npm/lib/utils/sbom-cyclonedx.js          |   15 +-
 deps/npm/lib/utils/sbom-spdx.js               |   12 +
 deps/npm/lib/utils/tar.js                     |    7 +-
 deps/npm/lib/utils/validate-uuid.js           |   10 +
 deps/npm/man/man1/npm-access.1                |    2 +-
 deps/npm/man/man1/npm-adduser.1               |    2 +-
 deps/npm/man/man1/npm-audit.1                 |    2 +-
 deps/npm/man/man1/npm-bugs.1                  |    2 +-
 deps/npm/man/man1/npm-cache.1                 |    2 +-
 deps/npm/man/man1/npm-ci.1                    |   42 +-
 deps/npm/man/man1/npm-completion.1            |    2 +-
 deps/npm/man/man1/npm-config.1                |    2 +-
 deps/npm/man/man1/npm-dedupe.1                |   42 +-
 deps/npm/man/man1/npm-deprecate.1             |    2 +-
 deps/npm/man/man1/npm-diff.1                  |    2 +-
 deps/npm/man/man1/npm-dist-tag.1              |    2 +-
 deps/npm/man/man1/npm-docs.1                  |    2 +-
 deps/npm/man/man1/npm-doctor.1                |    2 +-
 deps/npm/man/man1/npm-edit.1                  |    2 +-
 deps/npm/man/man1/npm-exec.1                  |    2 +-
 deps/npm/man/man1/npm-explain.1               |    2 +-
 deps/npm/man/man1/npm-explore.1               |    2 +-
 deps/npm/man/man1/npm-find-dupes.1            |    2 +-
 deps/npm/man/man1/npm-fund.1                  |    2 +-
 deps/npm/man/man1/npm-get.1                   |    2 +-
 deps/npm/man/man1/npm-help-search.1           |    2 +-
 deps/npm/man/man1/npm-help.1                  |    2 +-
 deps/npm/man/man1/npm-init.1                  |    2 +-
 deps/npm/man/man1/npm-install-ci-test.1       |   42 +-
 deps/npm/man/man1/npm-install-test.1          |   48 +-
 deps/npm/man/man1/npm-install.1               |   48 +-
 deps/npm/man/man1/npm-link.1                  |   42 +-
 deps/npm/man/man1/npm-ll.1                    |    2 +-
 deps/npm/man/man1/npm-login.1                 |    2 +-
 deps/npm/man/man1/npm-logout.1                |    2 +-
 deps/npm/man/man1/npm-ls.1                    |    4 +-
 deps/npm/man/man1/npm-org.1                   |    2 +-
 deps/npm/man/man1/npm-outdated.1              |    8 +-
 deps/npm/man/man1/npm-owner.1                 |    2 +-
 deps/npm/man/man1/npm-pack.1                  |    2 +-
 deps/npm/man/man1/npm-ping.1                  |    2 +-
 deps/npm/man/man1/npm-pkg.1                   |    2 +-
 deps/npm/man/man1/npm-prefix.1                |    2 +-
 deps/npm/man/man1/npm-profile.1               |    2 +-
 deps/npm/man/man1/npm-prune.1                 |    2 +-
 deps/npm/man/man1/npm-publish.1               |    2 +-
 deps/npm/man/man1/npm-query.1                 |    2 +-
 deps/npm/man/man1/npm-rebuild.1               |    2 +-
 deps/npm/man/man1/npm-repo.1                  |    2 +-
 deps/npm/man/man1/npm-restart.1               |    2 +-
 deps/npm/man/man1/npm-root.1                  |    2 +-
 deps/npm/man/man1/npm-run.1                   |    2 +-
 deps/npm/man/man1/npm-sbom.1                  |    2 +-
 deps/npm/man/man1/npm-search.1                |    2 +-
 deps/npm/man/man1/npm-set.1                   |    2 +-
 deps/npm/man/man1/npm-shrinkwrap.1            |    2 +-
 deps/npm/man/man1/npm-stage.1                 |  178 ++
 deps/npm/man/man1/npm-star.1                  |    2 +-
 deps/npm/man/man1/npm-stars.1                 |    2 +-
 deps/npm/man/man1/npm-start.1                 |    2 +-
 deps/npm/man/man1/npm-stop.1                  |    2 +-
 deps/npm/man/man1/npm-team.1                  |    2 +-
 deps/npm/man/man1/npm-test.1                  |    2 +-
 deps/npm/man/man1/npm-token.1                 |    2 +-
 deps/npm/man/man1/npm-trust.1                 |   27 +-
 deps/npm/man/man1/npm-undeprecate.1           |    2 +-
 deps/npm/man/man1/npm-uninstall.1             |    2 +-
 deps/npm/man/man1/npm-unpublish.1             |    2 +-
 deps/npm/man/man1/npm-unstar.1                |    2 +-
 deps/npm/man/man1/npm-update.1                |    8 +-
 deps/npm/man/man1/npm-version.1               |    2 +-
 deps/npm/man/man1/npm-view.1                  |    2 +-
 deps/npm/man/man1/npm-whoami.1                |    2 +-
 deps/npm/man/man1/npm.1                       |    4 +-
 deps/npm/man/man1/npx.1                       |    2 +-
 deps/npm/man/man5/folders.5                   |    2 +-
 deps/npm/man/man5/install.5                   |    2 +-
 deps/npm/man/man5/npm-global.5                |    2 +-
 deps/npm/man/man5/npm-json.5                  |    2 +-
 deps/npm/man/man5/npm-shrinkwrap-json.5       |    2 +-
 deps/npm/man/man5/npmrc.5                     |    2 +-
 deps/npm/man/man5/package-json.5              |    2 +-
 deps/npm/man/man5/package-lock-json.5         |    2 +-
 deps/npm/man/man7/config.7                    |   48 +-
 deps/npm/man/man7/dependency-selectors.7      |    2 +-
 deps/npm/man/man7/developers.7                |    2 +-
 deps/npm/man/man7/logging.7                   |    2 +-
 deps/npm/man/man7/orgs.7                      |    2 +-
 deps/npm/man/man7/package-spec.7              |    2 +-
 deps/npm/man/man7/registry.7                  |    2 +-
 deps/npm/man/man7/removal.7                   |    2 +-
 deps/npm/man/man7/scope.7                     |    2 +-
 deps/npm/man/man7/scripts.7                   |    2 +-
 deps/npm/man/man7/workspaces.7                |    2 +-
 .../arborist/lib/arborist/build-ideal-tree.js |  173 +-
 .../@npmcli/arborist/lib/arborist/index.js    |   10 +
 .../arborist/lib/arborist/isolated-reifier.js |    4 +-
 .../@npmcli/arborist/lib/arborist/reify.js    |  194 +-
 .../node_modules/@npmcli/arborist/lib/link.js |   20 +
 .../@npmcli/arborist/lib/shrinkwrap.js        |   16 +-
 .../@npmcli/arborist/package.json             |    2 +-
 .../config/lib/definitions/definitions.js     |   71 +-
 .../node_modules/@npmcli/config/package.json  |    2 +-
 .../node_modules/bin-links/lib/check-bin.js   |   10 +-
 .../node_modules/bin-links/lib/link-gently.js |    4 +-
 .../node_modules/bin-links/lib/shim-bin.js    |    5 +-
 deps/npm/node_modules/bin-links/package.json  |   10 +-
 .../brace-expansion/dist/commonjs/index.js    |    2 +-
 .../brace-expansion/dist/esm/index.js         |    2 +-
 .../node_modules/brace-expansion/package.json |    2 +-
 deps/npm/node_modules/cidr-regex/package.json |   33 +-
 .../node_modules/hosted-git-info/lib/hosts.js |    4 +-
 .../node_modules/hosted-git-info/package.json |   30 +-
 .../node_modules/ip-address/dist/common.js    |   21 +
 deps/npm/node_modules/ip-address/dist/ipv4.js |  261 ++-
 deps/npm/node_modules/ip-address/dist/ipv6.js |  476 +++--
 .../ip-address/dist/v6/constants.js           |    5 +
 .../ip-address/dist/v6/helpers.js             |   15 +-
 deps/npm/node_modules/ip-address/package.json |   80 +-
 deps/npm/node_modules/libnpmdiff/package.json |    4 +-
 deps/npm/node_modules/libnpmexec/package.json |    4 +-
 deps/npm/node_modules/libnpmfund/package.json |    4 +-
 deps/npm/node_modules/libnpmpack/package.json |    4 +-
 deps/npm/node_modules/libnpmpublish/README.md |    7 +
 .../node_modules/libnpmpublish/lib/publish.js |   17 +-
 .../node_modules/libnpmpublish/package.json   |    2 +-
 .../commonjs/browser/diagnostics-channel.js   |    7 +
 .../lru-cache/dist/commonjs/browser/index.js  | 1726 +++++++++++++++++
 .../dist/commonjs/browser/index.min.js        |    2 +
 .../lru-cache/dist/commonjs/browser/perf.js   |   10 +
 .../dist/commonjs/diagnostics-channel.js      |   11 +-
 .../lru-cache/dist/commonjs/index.js          |  148 +-
 .../lru-cache/dist/commonjs/index.min.js      |    2 +-
 .../dist/commonjs/node/diagnostics-channel.js |    9 +
 .../lru-cache/dist/commonjs/node/index.js     | 1726 +++++++++++++++++
 .../lru-cache/dist/commonjs/node/index.min.js |    2 +
 .../lru-cache/dist/commonjs/node/perf.js      |   10 +
 .../lru-cache/dist/commonjs/perf.js           |   10 +
 .../dist/esm/browser/diagnostics-channel.js   |    2 +-
 .../lru-cache/dist/esm/browser/index.js       |  146 +-
 .../lru-cache/dist/esm/browser/index.min.js   |    2 +-
 .../lru-cache/dist/esm/browser/perf.js        |    7 +
 .../node_modules/lru-cache/dist/esm/index.js  |  146 +-
 .../lru-cache/dist/esm/index.min.js           |    2 +-
 .../dist/esm/node/diagnostics-channel.js      |    5 +-
 .../lru-cache/dist/esm/node/index.js          |  146 +-
 .../lru-cache/dist/esm/node/index.min.js      |    2 +-
 .../lru-cache/dist/esm/node/perf.js           |    7 +
 .../node_modules/lru-cache/dist/esm/perf.js   |    7 +
 deps/npm/node_modules/lru-cache/package.json  |   72 +-
 deps/npm/node_modules/semver/README.md        |   23 +-
 deps/npm/node_modules/semver/bin/semver.js    |   24 +-
 .../node_modules/semver/functions/truncate.js |   48 +
 deps/npm/node_modules/semver/index.js         |    2 +
 deps/npm/node_modules/semver/internal/re.js   |    2 +-
 deps/npm/node_modules/semver/package.json     |    6 +-
 deps/npm/node_modules/semver/range.bnf        |    9 +-
 deps/npm/node_modules/socks/package.json      |    6 +-
 .../tar/dist/commonjs/index.min.js            |    6 +-
 .../node_modules/tar/dist/commonjs/pack.js    |   48 +-
 .../node_modules/tar/dist/esm/index.min.js    |    6 +-
 deps/npm/node_modules/tar/dist/esm/pack.js    |   48 +-
 deps/npm/node_modules/tar/package.json        |    8 +-
 deps/npm/package.json                         |   22 +-
 .../test/lib/commands/completion.js.test.cjs  |   12 +
 .../test/lib/commands/config.js.test.cjs      |    6 +
 .../test/lib/commands/publish.js.test.cjs     |   39 +-
 .../tap-snapshots/test/lib/docs.js.test.cjs   |  266 ++-
 .../tap-snapshots/test/lib/npm.js.test.cjs    |   71 +-
 .../test/lib/utils/sbom-cyclonedx.js.test.cjs |   60 +
 .../test/lib/utils/sbom-spdx.js.test.cjs      |   67 +
 deps/npm/test/lib/commands/install.js         |  128 +-
 deps/npm/test/lib/commands/stage/approve.js   |   72 +
 deps/npm/test/lib/commands/stage/download.js  |  139 ++
 deps/npm/test/lib/commands/stage/index.js     |  332 ++++
 deps/npm/test/lib/commands/stage/list.js      |  147 ++
 deps/npm/test/lib/commands/stage/reject.js    |   72 +
 deps/npm/test/lib/commands/stage/view.js      |  100 +
 deps/npm/test/lib/commands/trust/circleci.js  |   11 +
 deps/npm/test/lib/commands/trust/github.js    |    8 +-
 deps/npm/test/lib/commands/trust/gitlab.js    |    8 +-
 deps/npm/test/lib/trust-cmd.js                |  143 +-
 deps/npm/test/lib/utils/display.js            |   29 +
 deps/npm/test/lib/utils/key-values.js         |   84 +
 deps/npm/test/lib/utils/sbom-cyclonedx.js     |   19 +
 deps/npm/test/lib/utils/sbom-spdx.js          |   21 +
 deps/npm/test/lib/utils/tar.js                |   14 +
 311 files changed, 9995 insertions(+), 1231 deletions(-)
 create mode 100644 deps/npm/docs/content/commands/npm-stage.md
 create mode 100644 deps/npm/docs/output/commands/npm-stage.html
 create mode 100644 deps/npm/lib/commands/stage/approve.js
 create mode 100644 deps/npm/lib/commands/stage/download.js
 create mode 100644 deps/npm/lib/commands/stage/index.js
 create mode 100644 deps/npm/lib/commands/stage/list.js
 create mode 100644 deps/npm/lib/commands/stage/publish.js
 create mode 100644 deps/npm/lib/commands/stage/reject.js
 create mode 100644 deps/npm/lib/commands/stage/view.js
 create mode 100644 deps/npm/lib/utils/key-values.js
 create mode 100644 deps/npm/lib/utils/validate-uuid.js
 create mode 100644 deps/npm/man/man1/npm-stage.1
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.min.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/browser/perf.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/node/diagnostics-channel.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/node/index.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/node/index.min.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/node/perf.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/commonjs/perf.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/esm/browser/perf.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/esm/node/perf.js
 create mode 100644 deps/npm/node_modules/lru-cache/dist/esm/perf.js
 create mode 100644 deps/npm/node_modules/semver/functions/truncate.js
 create mode 100644 deps/npm/test/lib/commands/stage/approve.js
 create mode 100644 deps/npm/test/lib/commands/stage/download.js
 create mode 100644 deps/npm/test/lib/commands/stage/index.js
 create mode 100644 deps/npm/test/lib/commands/stage/list.js
 create mode 100644 deps/npm/test/lib/commands/stage/reject.js
 create mode 100644 deps/npm/test/lib/commands/stage/view.js
 create mode 100644 deps/npm/test/lib/utils/key-values.js

diff --git a/deps/npm/docs/content/commands/npm-ci.md b/deps/npm/docs/content/commands/npm-ci.md
index 45162af8d61d57..6f8dd5bd3f6655 100644
--- a/deps/npm/docs/content/commands/npm-ci.md
+++ b/deps/npm/docs/content/commands/npm-ci.md
@@ -189,6 +189,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -197,12 +233,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
diff --git a/deps/npm/docs/content/commands/npm-dedupe.md b/deps/npm/docs/content/commands/npm-dedupe.md
index e7fd142d00c07c..8186ee2c1f31c7 100644
--- a/deps/npm/docs/content/commands/npm-dedupe.md
+++ b/deps/npm/docs/content/commands/npm-dedupe.md
@@ -184,6 +184,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -192,12 +228,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
diff --git a/deps/npm/docs/content/commands/npm-install-ci-test.md b/deps/npm/docs/content/commands/npm-install-ci-test.md
index 6b9681d202c991..22dc87ce8bb6ca 100644
--- a/deps/npm/docs/content/commands/npm-install-ci-test.md
+++ b/deps/npm/docs/content/commands/npm-install-ci-test.md
@@ -142,6 +142,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -150,12 +186,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
diff --git a/deps/npm/docs/content/commands/npm-install-test.md b/deps/npm/docs/content/commands/npm-install-test.md
index 8291409edfb835..999019bde3668d 100644
--- a/deps/npm/docs/content/commands/npm-install-test.md
+++ b/deps/npm/docs/content/commands/npm-install-test.md
@@ -219,6 +219,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -227,12 +263,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
@@ -264,7 +319,13 @@ If the requested version is a `dist-tag` and the given tag does not pass the
 will be used. For example, `foo@latest` might install `foo@1.2` even though
 `latest` is `2.0`.
 
-This config cannot be used with: `min-release-age`
+If `before` and `min-release-age` are both set in the same source, `before`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### `min-release-age`
 
@@ -277,9 +338,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to `before`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: `before`
+of a relative number of days. The two may coexist (e.g. `min-release-age` in
+your `.npmrc` is preserved when npm internally spawns a sub-process with
+`--before` while preparing a `git:` or `github:` dependency); when both
+apply, `before` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
diff --git a/deps/npm/docs/content/commands/npm-install.md b/deps/npm/docs/content/commands/npm-install.md
index 77a34667725c3f..925439ceb21dd3 100644
--- a/deps/npm/docs/content/commands/npm-install.md
+++ b/deps/npm/docs/content/commands/npm-install.md
@@ -561,6 +561,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -569,12 +605,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
@@ -606,7 +661,13 @@ If the requested version is a `dist-tag` and the given tag does not pass the
 will be used. For example, `foo@latest` might install `foo@1.2` even though
 `latest` is `2.0`.
 
-This config cannot be used with: `min-release-age`
+If `before` and `min-release-age` are both set in the same source, `before`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### `min-release-age`
 
@@ -619,9 +680,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to `before`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: `before`
+of a relative number of days. The two may coexist (e.g. `min-release-age` in
+your `.npmrc` is preserved when npm internally spawns a sub-process with
+`--before` while preparing a `git:` or `github:` dependency); when both
+apply, `before` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
diff --git a/deps/npm/docs/content/commands/npm-link.md b/deps/npm/docs/content/commands/npm-link.md
index 31af87bfa3006d..37efda66408fbd 100644
--- a/deps/npm/docs/content/commands/npm-link.md
+++ b/deps/npm/docs/content/commands/npm-link.md
@@ -248,6 +248,42 @@ run any pre- or post-scripts.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -256,12 +292,31 @@ run any pre- or post-scripts.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
diff --git a/deps/npm/docs/content/commands/npm-ls.md b/deps/npm/docs/content/commands/npm-ls.md
index 556e77976c1a8f..91e06ed30836d4 100644
--- a/deps/npm/docs/content/commands/npm-ls.md
+++ b/deps/npm/docs/content/commands/npm-ls.md
@@ -23,7 +23,7 @@ Note that nested packages will *also* show the paths to the specified packages.
 For example, running `npm ls promzard` in npm's source tree will show:
 
 ```bash
-npm@11.13.0 /path/to/npm
+npm@11.15.0 /path/to/npm
 └─┬ init-package-json@0.0.4
   └── promzard@0.1.5
 ```
diff --git a/deps/npm/docs/content/commands/npm-outdated.md b/deps/npm/docs/content/commands/npm-outdated.md
index f635cb90565d2f..92e15e9602013d 100644
--- a/deps/npm/docs/content/commands/npm-outdated.md
+++ b/deps/npm/docs/content/commands/npm-outdated.md
@@ -165,7 +165,13 @@ If the requested version is a `dist-tag` and the given tag does not pass the
 will be used. For example, `foo@latest` might install `foo@1.2` even though
 `latest` is `2.0`.
 
-This config cannot be used with: `min-release-age`
+If `before` and `min-release-age` are both set in the same source, `before`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### `min-release-age`
 
@@ -178,9 +184,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to `before`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: `before`
+of a relative number of days. The two may coexist (e.g. `min-release-age` in
+your `.npmrc` is preserved when npm internally spawns a sub-process with
+`--before` while preparing a `git:` or `github:` dependency); when both
+apply, `before` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
diff --git a/deps/npm/docs/content/commands/npm-stage.md b/deps/npm/docs/content/commands/npm-stage.md
new file mode 100644
index 00000000000000..9a761bbd8a5146
--- /dev/null
+++ b/deps/npm/docs/content/commands/npm-stage.md
@@ -0,0 +1,255 @@
+---
+title: npm-stage
+section: 1
+description: Stage packages for publishing
+---
+
+### Synopsis
+
+```bash
+npm stage
+```
+
+Note: This command is unaware of workspaces.
+
+### Description
+
+Staged publishing allows package maintainers to require proof-of-presence
+for all publishes. Proof-of-presence is where a human is involved,
+interjects, and provides authentication (2FA) during an action — in this
+case, publishing an npm package.
+
+Typically when maintainers use automated workflows to publish,
+proof-of-presence is lacking as there's no convenient way to interject the
+process and provide 2FA, as is the case for publishing with a granular
+access token with bypass and the trusted publishing flow. Staged publishing
+allows users to have their automated workflows stage a package without a 2FA
+prompt, deferring the act of 2FA, allowing the maintainer to approve the
+staged package and publish at a later point.
+
+The `npm stage publish` command packs the current working directory and
+places that version of the package into the registry in a state where it's
+not available for public access, allowing maintainers to approve the package
+at a later point in time. The act of staging does not prompt for 2FA and can be done with any token
+type, the act of approving will.
+
+Key behaviors:
+
+* Staged packages share the same semver version unique index as published
+  packages — you cannot publish a version that already exists as a staged
+  version for that package.
+* You can still publish packages normally while you have staged packages
+  pending.
+* You can stage multiple versions of the same package.
+* `npm stage publish` has parity with `npm publish` and will respect
+  `"private": true` in `package.json`, refusing to stage the package.
+
+### Prerequisites
+
+Before using `npm stage` commands, ensure the following requirements are met:
+
+* **Write permissions on the package:** You must have write access to the
+  package you're configuring.
+* **Package must exist:** The package you're configuring must already exist
+  on the npm registry.
+* **2FA enabled on your account:** Commands that require 2FA will prompt you
+  to authenticate. If you don't already have 2FA enabled on your account,
+  you must enable it before using these commands.
+
+### Subcommands
+
+* `npm stage publish [<package-spec>]` - Stage a package for publishing
+* `npm stage list [<package-spec>]` - List all staged package versions
+* `npm stage view <stage-id>` - View details of a specific staged package
+* `npm stage approve <stage-id>` - Approve a staged package for publishing
+* `npm stage reject <stage-id>` - Reject a staged package
+* `npm stage download <stage-id>` - Download the tarball for inspection
+
+### 2FA Requirements by Subcommand
+
+| Command | Requires 2FA | Notes |
+| --- | --- | --- |
+| `npm stage publish` | No | Designed for automated workflows; defers 2FA to approval |
+| `npm stage list` | No | View staged packages |
+| `npm stage view` | No | View staged package details |
+| `npm stage approve` | Yes | Prompts for 2FA to publish the staged package |
+| `npm stage reject` | Yes | Prompts for 2FA to permanently remove the staged package |
+| `npm stage download` | No | Downloads the tarball for local inspection |
+
+### Tag Behavior
+
+The `--tag` flag follows the same logic as `npm publish`. If no tag is
+provided, the `latest` tag is used by default. For pre-release versions
+(e.g., `1.0.0-beta.1`) and non-latest semver versions, the tag must be
+explicitly provided — otherwise the CLI will error, just as `npm publish`
+would.
+
+The tag is an immutable property of the staged package. Once a package is
+staged with a given tag, the tag cannot be changed. If you need to stage the
+same version with a different tag, you must first reject the existing staged
+package using `npm stage reject` and then re-stage it with the desired tag.
+
+### Token Behavior
+
+The key difference with staged publishing is that `npm stage publish` never
+requires a 2FA prompt, regardless of token type. This is what makes it
+suitable for automated workflows. The goal of `npm stage publish` is
+deferring proof-of-presence to a later point in time.
+
+| Token Type | `npm stage publish` | `npm publish` |
+| --- | --- | --- |
+| GAT with bypass | Can stage | Can publish (if allowed by package publishing access) |
+| GAT without bypass | Can stage | 2FA prompt (if allowed by package publishing access) |
+| Session token | Can stage | 2FA prompt |
+| Trust token (OIDC) | Can stage (if allowed) | Can publish (if allowed) |
+
+### Trust Relationship Permissions
+
+With staged publishing, trust relationships now support granular command
+permissions. Shortlived tokens issued through trust relationships can only be
+used with `npm stage publish` and `npm publish`. Shortlived tokens cannot run
+`npm stage` subcommands.
+
+`npm trust <provider>` supports `--allow-publish` and `--allow-stage-publish`
+to control which commands are available through each trust relationship.
+
+### Best Practices
+
+**Note:** The addition of staged publishing does not make your account or org
+more secure. Maintainers must still use the best practices listed below.
+
+1. **Delete Granular Access Tokens (GAT) with bypass 2FA enabled.**
+   Now with staged publishing, we've eliminated the need for a GAT token
+   that can bypass 2FA. We encourage you to delete all your tokens with
+   bypass enabled and switch to using a trust relationship in your automated
+   workflows, or create a GAT without bypass and use `npm stage publish`.
+
+2. **Disallow tokens from publishing at the package level.**
+   All packages have their own access controls under "package access"
+   allowing packages to be published with bypass tokens, which is no longer
+   a necessity. We encourage you to select "Require two-factor
+   authentication and disallow tokens (recommended)" for all your packages
+   on the package access page.
+
+3. **Configure trust relationship permissions to prevent `npm publish`.**
+   We encourage you to only enable `npm stage publish` on your trust
+   relationships and disable `npm publish`.
+
+### Configuration
+
+### `npm stage publish`
+
+Stage a package for publishing, deferring proof-of-presence (2FA) to a later point in time
+
+#### Synopsis
+
+```bash
+npm stage publish <package-spec>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--tag` | "latest" | String | If you ask npm to install a package and don't tell it a specific version,       then it will install the specified tag.        It is the tag added to the package@version specified in the        `npm dist-tag add` command, if no explicit tag is given.        When used by the `npm diff` command, this is the tag used to fetch the       tarball that will be compared with the local files by default.              If used in the `npm publish` command, this is the tag that will be        added to the package submitted to the registry. |
+| `--access` |
+    'public' for new packages, existing packages it will not change the current level
+   | null, "restricted", or "public" | If you do not want your scoped package to be publicly viewable (and     installable) set `--access=restricted`.      Unscoped packages cannot be set to `restricted`.      Note: This defaults to not changing the current access level for existing     packages.  Specifying a value of `restricted` or `public` during     publish will change the access for an existing package the same way that     `npm access set status` would. |
+| `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
+| `--otp` | null | null or String | This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with `npm access`.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one. |
+| `--workspace`, `-w` |  | String (can be set multiple times) | Enable running a command in the context of the configured workspaces of the       current project while filtering by running only the workspaces defined by       this configuration option.        Valid values for the `workspace` config are either:        * Workspace names       * Path to a workspace directory       * Path to a parent workspace directory (will result in selecting all         workspaces within that folder)        When set for the `npm init` command, this may be set to the folder of       a workspace which does not yet exist, to create the folder and set it       up as a brand new workspace within the project. |
+| `--workspaces` | null | null or Boolean | Set to true to run the command in the context of **all** configured       workspaces.        Explicitly setting this to false will cause commands like `install` to       ignore workspaces altogether.       When not set explicitly:        - Commands that operate on the `node_modules` tree (install, update,         etc.) will link workspaces into the `node_modules` folder.       - Commands that do other things (test, exec, publish, etc.) will operate         on the root project, _unless_ one or more workspaces are specified in         the `workspace` config. |
+| `--include-workspace-root` | false | Boolean | Include the workspace root when workspaces are enabled for a command.        When false, specifying individual workspaces via the `workspace` config,       or all workspaces via the `workspaces` flag, will cause npm to operate only       on the specified workspaces, and not on the root project. |
+| `--provenance` | false | Boolean | When publishing from a supported cloud CI/CD system, the package will be       publicly linked to where it was built and published from. |
+
+### `npm stage list`
+
+List all staged package versions
+
+#### Synopsis
+
+```bash
+npm stage list [<package-spec>]
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+### `npm stage view`
+
+View details of a specific staged package
+
+#### Synopsis
+
+```bash
+npm stage view <stage-id>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+### `npm stage approve`
+
+Approve a staged package, publishing it to the npm registry
+
+#### Synopsis
+
+```bash
+npm stage approve <stage-id>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--otp` | null | null or String | This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with `npm access`.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+### `npm stage reject`
+
+Reject a staged package, removing it from the registry
+
+#### Synopsis
+
+```bash
+npm stage reject <stage-id>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--otp` | null | null or String | This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with `npm access`.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+### `npm stage download`
+
+Download the tarball of a staged package for inspection
+
+#### Synopsis
+
+```bash
+npm stage download <stage-id>
+```
+
+#### Flags
+
+| Flag | Default | Type | Description |
+| --- | --- | --- | --- |
+| `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
+| `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+
+
+### See Also
+
+* [npm publish](/commands/npm-publish)
+* [npm unpublish](/commands/npm-unpublish)
+* [npm trust](/commands/npm-trust)
diff --git a/deps/npm/docs/content/commands/npm-trust.md b/deps/npm/docs/content/commands/npm-trust.md
index e780330db878de..5aac2035b38644 100644
--- a/deps/npm/docs/content/commands/npm-trust.md
+++ b/deps/npm/docs/content/commands/npm-trust.md
@@ -28,6 +28,17 @@ The `[package]` argument specifies the package name. If omitted, npm will use th
 
 Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal—npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use `npm trust <provider> --help`.
 
+### Permissions
+
+When creating a trust relationship, you must specify at least one permission flag to indicate which operations the trusted publisher is allowed to perform:
+
+* `--allow-publish`: Allows the trusted publisher to run `npm publish` for the package.
+* `--allow-stage-publish`: Allows the trusted publisher to run `npm stage` for the package. The alias `--allow-staged-publish` is also accepted.
+
+At least one of these flags is required when creating a trust configuration. You can specify both to grant both permissions.
+
+### Provider Options
+
 The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the [managing trusted publisher configurations](https://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations) section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the `repository.url` field from your `package.json`, if available.
 
 Currently, the registry only supports one configuration per package. If you attempt to create a new trust relationship when one already exists, it will result in an error. To replace an existing configuration:
@@ -53,7 +64,7 @@ Create a trusted relationship between a package and GitHub Actions
 #### Synopsis
 
 ```bash
-npm trust github [package] --file [--repo|--repository] [--env|--environment] [-y|--yes]
+npm trust github [package] --file [--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 ```
 
 #### Flags
@@ -63,6 +74,8 @@ npm trust github [package] --file [--repo|--repository] [--env|--environment] [-
 | `--file` | null | String (required) | Name of workflow file within a repositories .GitHub folder (must end in yaml, yml) |
 | `--repository`, `--repo` | null | String | Name of the repository in the format owner/repo |
 | `--environment`, `--env` | null | String | CI environment name |
+| `--allow-publish` | false | Boolean | Allow npm publish for this trusted publisher configuration |
+| `--allow-stage-publish`, `--allow-staged-publish` | false | Boolean | Allow npm stage publish for this trusted publisher configuration |
 | `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
 | `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
 | `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
@@ -75,7 +88,7 @@ Create a trusted relationship between a package and GitLab CI/CD
 #### Synopsis
 
 ```bash
-npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]
+npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 ```
 
 #### Flags
@@ -85,6 +98,8 @@ npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--envir
 | `--file` | null | String (required) | Name of pipeline file (e.g., .gitlab-ci.yml) |
 | `--project` | null | String | Name of the project in the format group/project or group/subgroup/project |
 | `--environment`, `--env` | null | String | CI environment name |
+| `--allow-publish` | false | Boolean | Allow npm publish for this trusted publisher configuration |
+| `--allow-stage-publish`, `--allow-staged-publish` | false | Boolean | Allow npm stage publish for this trusted publisher configuration |
 | `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
 | `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
 | `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
@@ -97,7 +112,7 @@ Create a trusted relationship between a package and CircleCI
 #### Synopsis
 
 ```bash
-npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [-y|--yes]
+npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 ```
 
 #### Flags
@@ -109,6 +124,8 @@ npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-defi
 | `--pipeline-definition-id` | null | String (required) | CircleCI pipeline definition UUID |
 | `--vcs-origin` | null | String (required) | CircleCI repository origin in format 'provider/owner/repo' |
 | `--context-id` | null | null or String (can be set multiple times) | CircleCI context UUID to match |
+| `--allow-publish` | false | Boolean | Allow npm publish for this trusted publisher configuration |
+| `--allow-stage-publish`, `--allow-staged-publish` | false | Boolean | Allow npm stage publish for this trusted publisher configuration |
 | `--dry-run` | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, `install`,       `update`, `dedupe`, `uninstall`, as well as `pack` and       `publish`.        Note: This is NOT honored by other network related commands, eg       `dist-tags`, `owner`, etc. |
 | `--json` | false | Boolean | Whether or not to output JSON data, rather than the normal output.        * In `npm pkg set` it enables parsing set values with JSON.parse()       before saving them to your `package.json`.        Not supported by all npm commands. |
 | `--registry` | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
diff --git a/deps/npm/docs/content/commands/npm-update.md b/deps/npm/docs/content/commands/npm-update.md
index 979f1c1de333d9..4dc7e9a1edccbe 100644
--- a/deps/npm/docs/content/commands/npm-update.md
+++ b/deps/npm/docs/content/commands/npm-update.md
@@ -330,7 +330,13 @@ If the requested version is a `dist-tag` and the given tag does not pass the
 will be used. For example, `foo@latest` might install `foo@1.2` even though
 `latest` is `2.0`.
 
-This config cannot be used with: `min-release-age`
+If `before` and `min-release-age` are both set in the same source, `before`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### `min-release-age`
 
@@ -343,9 +349,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to `before`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: `before`
+of a relative number of days. The two may coexist (e.g. `min-release-age` in
+your `.npmrc` is preserved when npm internally spawns a sub-process with
+`--before` while preparing a `git:` or `github:` dependency); when both
+apply, `before` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
diff --git a/deps/npm/docs/content/commands/npm.md b/deps/npm/docs/content/commands/npm.md
index 242c61509bc1c7..89e5dd6ef50d78 100644
--- a/deps/npm/docs/content/commands/npm.md
+++ b/deps/npm/docs/content/commands/npm.md
@@ -14,7 +14,7 @@ Note: This command is unaware of workspaces.
 
 ### Version
 
-11.13.0
+11.15.0
 
 ### Description
 
diff --git a/deps/npm/docs/content/using-npm/config.md b/deps/npm/docs/content/using-npm/config.md
index 96df0ae0058c69..0e99c58f3c002b 100644
--- a/deps/npm/docs/content/using-npm/config.md
+++ b/deps/npm/docs/content/using-npm/config.md
@@ -165,6 +165,42 @@ upon by the current project.
 
 
 
+#### `allow-directory`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any directories to be installed. `none` prevents any
+directories from being installed. `root` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like `npm view`
+
+
+
+#### `allow-file`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+`all` allows any tarball file to be installed. `none` prevents any tarball
+file from being installed. `root` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like `npm view`
+
+
+
 #### `allow-git`
 
 * Default: "all"
@@ -173,12 +209,31 @@ upon by the current project.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 `all` allows any git dependencies to be fetched and installed. `none`
 prevents any git dependencies from being fetched and installed. `root` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like `npm view`
+
+
+
+#### `allow-remote`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+`all` allows any url to be installed. `none` prevents any url from being
+installed. `root` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like `npm view`
 
 
@@ -240,7 +295,13 @@ If the requested version is a `dist-tag` and the given tag does not pass the
 will be used. For example, `foo@latest` might install `foo@1.2` even though
 `latest` is `2.0`.
 
-This config cannot be used with: `min-release-age`
+If `before` and `min-release-age` are both set in the same source, `before`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### `bin-links`
 
@@ -1094,9 +1155,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to `before`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: `before`
+of a relative number of days. The two may coexist (e.g. `min-release-age` in
+your `.npmrc` is preserved when npm internally spawns a sub-process with
+`--before` while preparing a `git:` or `github:` dependency); when both
+apply, `before` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
diff --git a/deps/npm/docs/output/commands/npm-access.html b/deps/npm/docs/output/commands/npm-access.html
index 329fad79ba9d15..224177685f2e4a 100644
--- a/deps/npm/docs/output/commands/npm-access.html
+++ b/deps/npm/docs/output/commands/npm-access.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-access----11130">
+<h1 id="----npm-access----11150">
     <span>npm-access</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Set access level on published packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-adduser.html b/deps/npm/docs/output/commands/npm-adduser.html
index 52fc19c7942228..c73b60b16ed7ea 100644
--- a/deps/npm/docs/output/commands/npm-adduser.html
+++ b/deps/npm/docs/output/commands/npm-adduser.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-adduser----11130">
+<h1 id="----npm-adduser----11150">
     <span>npm-adduser</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Add a registry user account</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-audit.html b/deps/npm/docs/output/commands/npm-audit.html
index e935f919dfd483..eff894d79e5adf 100644
--- a/deps/npm/docs/output/commands/npm-audit.html
+++ b/deps/npm/docs/output/commands/npm-audit.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-audit----11130">
+<h1 id="----npm-audit----11150">
     <span>npm-audit</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Run a security audit</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-bugs.html b/deps/npm/docs/output/commands/npm-bugs.html
index f6eb47691c1842..143b82ff563534 100644
--- a/deps/npm/docs/output/commands/npm-bugs.html
+++ b/deps/npm/docs/output/commands/npm-bugs.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-bugs----11130">
+<h1 id="----npm-bugs----11150">
     <span>npm-bugs</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Report bugs for a package in a web browser</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-cache.html b/deps/npm/docs/output/commands/npm-cache.html
index 761f44801dcd58..185ac37463e9dd 100644
--- a/deps/npm/docs/output/commands/npm-cache.html
+++ b/deps/npm/docs/output/commands/npm-cache.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-cache----11130">
+<h1 id="----npm-cache----11150">
     <span>npm-cache</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manipulates packages cache</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-ci.html b/deps/npm/docs/output/commands/npm-ci.html
index 8762c8463177d5..772d4ae14de699 100644
--- a/deps/npm/docs/output/commands/npm-ci.html
+++ b/deps/npm/docs/output/commands/npm-ci.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-ci----11130">
+<h1 id="----npm-ci----11150">
     <span>npm-ci</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Clean install a project</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#example">Example</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -333,6 +333,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -341,11 +369,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-completion.html b/deps/npm/docs/output/commands/npm-completion.html
index 8d92430c9b6822..161ac0c6de585a 100644
--- a/deps/npm/docs/output/commands/npm-completion.html
+++ b/deps/npm/docs/output/commands/npm-completion.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-completion----11130">
+<h1 id="----npm-completion----11150">
     <span>npm-completion</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Tab Completion for npm</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-config.html b/deps/npm/docs/output/commands/npm-config.html
index 9f23af17c2ba2a..0e8ebe721f7ec2 100644
--- a/deps/npm/docs/output/commands/npm-config.html
+++ b/deps/npm/docs/output/commands/npm-config.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-config----11130">
+<h1 id="----npm-config----11150">
     <span>npm-config</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage the npm configuration files</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-dedupe.html b/deps/npm/docs/output/commands/npm-dedupe.html
index c4ded5d1e93e0e..f0d32be8df62b7 100644
--- a/deps/npm/docs/output/commands/npm-dedupe.html
+++ b/deps/npm/docs/output/commands/npm-dedupe.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-dedupe----11130">
+<h1 id="----npm-dedupe----11150">
     <span>npm-dedupe</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Reduce duplication in the package tree</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -323,6 +323,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -331,11 +359,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-deprecate.html b/deps/npm/docs/output/commands/npm-deprecate.html
index 5bc588535e092e..8286ff6dfde58b 100644
--- a/deps/npm/docs/output/commands/npm-deprecate.html
+++ b/deps/npm/docs/output/commands/npm-deprecate.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-deprecate----11130">
+<h1 id="----npm-deprecate----11150">
     <span>npm-deprecate</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Deprecate a version of a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-diff.html b/deps/npm/docs/output/commands/npm-diff.html
index a65a7c15e9dfd8..b006a5fe1565d9 100644
--- a/deps/npm/docs/output/commands/npm-diff.html
+++ b/deps/npm/docs/output/commands/npm-diff.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-diff----11130">
+<h1 id="----npm-diff----11150">
     <span>npm-diff</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">The registry diff command</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-dist-tag.html b/deps/npm/docs/output/commands/npm-dist-tag.html
index 374fcd8ceaa270..ea3f353bce7e13 100644
--- a/deps/npm/docs/output/commands/npm-dist-tag.html
+++ b/deps/npm/docs/output/commands/npm-dist-tag.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-dist-tag----11130">
+<h1 id="----npm-dist-tag----11150">
     <span>npm-dist-tag</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Modify package distribution tags</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-docs.html b/deps/npm/docs/output/commands/npm-docs.html
index 1f445117b93cab..fa3f70a34e43d9 100644
--- a/deps/npm/docs/output/commands/npm-docs.html
+++ b/deps/npm/docs/output/commands/npm-docs.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-docs----11130">
+<h1 id="----npm-docs----11150">
     <span>npm-docs</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Open documentation for a package in a web browser</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-doctor.html b/deps/npm/docs/output/commands/npm-doctor.html
index b16a27077ccfd7..35289c9f4baa65 100644
--- a/deps/npm/docs/output/commands/npm-doctor.html
+++ b/deps/npm/docs/output/commands/npm-doctor.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-doctor----11130">
+<h1 id="----npm-doctor----11150">
     <span>npm-doctor</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Check the health of your npm environment</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-edit.html b/deps/npm/docs/output/commands/npm-edit.html
index 3660272c77fc56..47a653e76bc67e 100644
--- a/deps/npm/docs/output/commands/npm-edit.html
+++ b/deps/npm/docs/output/commands/npm-edit.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-edit----11130">
+<h1 id="----npm-edit----11150">
     <span>npm-edit</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Edit an installed package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-exec.html b/deps/npm/docs/output/commands/npm-exec.html
index eaab3d41205b80..b27f5aeef44ff5 100644
--- a/deps/npm/docs/output/commands/npm-exec.html
+++ b/deps/npm/docs/output/commands/npm-exec.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-exec----11130">
+<h1 id="----npm-exec----11150">
     <span>npm-exec</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Run a command from a local or remote npm package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-explain.html b/deps/npm/docs/output/commands/npm-explain.html
index bd64b49a29f4b5..4e054a719f6943 100644
--- a/deps/npm/docs/output/commands/npm-explain.html
+++ b/deps/npm/docs/output/commands/npm-explain.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-explain----11130">
+<h1 id="----npm-explain----11150">
     <span>npm-explain</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Explain installed packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-explore.html b/deps/npm/docs/output/commands/npm-explore.html
index aed39e77a6c4dd..0302e915dc24df 100644
--- a/deps/npm/docs/output/commands/npm-explore.html
+++ b/deps/npm/docs/output/commands/npm-explore.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-explore----11130">
+<h1 id="----npm-explore----11150">
     <span>npm-explore</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Browse an installed package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-find-dupes.html b/deps/npm/docs/output/commands/npm-find-dupes.html
index bbe3222494c0b7..c0e9ecaecd3884 100644
--- a/deps/npm/docs/output/commands/npm-find-dupes.html
+++ b/deps/npm/docs/output/commands/npm-find-dupes.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-find-dupes----11130">
+<h1 id="----npm-find-dupes----11150">
     <span>npm-find-dupes</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Find duplication in the package tree</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-fund.html b/deps/npm/docs/output/commands/npm-fund.html
index 85b66955b516b3..43aa08e534662c 100644
--- a/deps/npm/docs/output/commands/npm-fund.html
+++ b/deps/npm/docs/output/commands/npm-fund.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-fund----11130">
+<h1 id="----npm-fund----11150">
     <span>npm-fund</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Retrieve funding information</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-get.html b/deps/npm/docs/output/commands/npm-get.html
index eb4bde934ce801..ba24cd9fe4e5b2 100644
--- a/deps/npm/docs/output/commands/npm-get.html
+++ b/deps/npm/docs/output/commands/npm-get.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-get----11130">
+<h1 id="----npm-get----11150">
     <span>npm-get</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Get a value from the npm configuration</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-help-search.html b/deps/npm/docs/output/commands/npm-help-search.html
index cad8a79a483727..839f3d9e3df53c 100644
--- a/deps/npm/docs/output/commands/npm-help-search.html
+++ b/deps/npm/docs/output/commands/npm-help-search.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-help-search----11130">
+<h1 id="----npm-help-search----11150">
     <span>npm-help-search</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Search npm help documentation</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-help.html b/deps/npm/docs/output/commands/npm-help.html
index 519fde8cf07841..76b8f03fdabd23 100644
--- a/deps/npm/docs/output/commands/npm-help.html
+++ b/deps/npm/docs/output/commands/npm-help.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-help----11130">
+<h1 id="----npm-help----11150">
     <span>npm-help</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Get help on npm</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-init.html b/deps/npm/docs/output/commands/npm-init.html
index a26b848890dffd..570d84d38c09e8 100644
--- a/deps/npm/docs/output/commands/npm-init.html
+++ b/deps/npm/docs/output/commands/npm-init.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-init----11130">
+<h1 id="----npm-init----11150">
     <span>npm-init</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Create a package.json file</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-install-ci-test.html b/deps/npm/docs/output/commands/npm-install-ci-test.html
index bb65682760d46e..10cf3475a8cb97 100644
--- a/deps/npm/docs/output/commands/npm-install-ci-test.html
+++ b/deps/npm/docs/output/commands/npm-install-ci-test.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-install-ci-test----11130">
+<h1 id="----npm-install-ci-test----11150">
     <span>npm-install-ci-test</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Install a project with a clean slate and run tests</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -297,6 +297,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -305,11 +333,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-install-test.html b/deps/npm/docs/output/commands/npm-install-test.html
index dff8ea97a81ae3..3aa17aef585d3a 100644
--- a/deps/npm/docs/output/commands/npm-install-test.html
+++ b/deps/npm/docs/output/commands/npm-install-test.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-install-test----11130">
+<h1 id="----npm-install-test----11150">
     <span>npm-install-test</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Install package(s) and run tests</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -353,6 +353,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -361,11 +389,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
@@ -389,7 +432,11 @@ <h4 id="before"><code>before</code></h4>
 <code>--before</code> filter, the most recent version less than or equal to that tag
 will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
 <code>latest</code> is <code>2.0</code>.</p>
-<p>This config cannot be used with: <code>min-release-age</code></p>
+<p>If <code>before</code> and <code>min-release-age</code> are both set in the same source, <code>before</code>
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli &gt; env &gt; project &gt; user &gt;
+global), so a higher-priority source can always relax or override a
+lower-priority one.</p>
 <h4 id="min-release-age"><code>min-release-age</code></h4>
 <ul>
 <li>Default: null</li>
@@ -400,8 +447,11 @@ <h4 id="min-release-age"><code>min-release-age</code></h4>
 are no versions available for the current set of dependencies, the command
 will error.</p>
 <p>This flag is a complement to <code>before</code>, which accepts an exact date instead
-of a relative number of days.</p>
-<p>This config cannot be used with: <code>before</code></p>
+of a relative number of days. The two may coexist (e.g. <code>min-release-age</code> in
+your <code>.npmrc</code> is preserved when npm internally spawns a sub-process with
+<code>--before</code> while preparing a <code>git:</code> or <code>github:</code> dependency); when both
+apply, <code>before</code> wins within a single source and across sources the standard
+precedence rules apply.</p>
 <p>This value is not exported to the environment for child processes.</p>
 <h4 id="bin-links"><code>bin-links</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-install.html b/deps/npm/docs/output/commands/npm-install.html
index 69d2207db9df91..072f465f26a4b5 100644
--- a/deps/npm/docs/output/commands/npm-install.html
+++ b/deps/npm/docs/output/commands/npm-install.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-install----11130">
+<h1 id="----npm-install----11150">
     <span>npm-install</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Install a package</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#how-npm-install-uses-package-lockjson">How <code>npm install</code> uses <code>package-lock.json</code></a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#algorithm">Algorithm</a></li><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><ul><li><a href="#how-npm-install-uses-package-lockjson">How <code>npm install</code> uses <code>package-lock.json</code></a></li></ul><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#algorithm">Algorithm</a></li><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -628,6 +628,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -636,11 +664,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
@@ -664,7 +707,11 @@ <h4 id="before"><code>before</code></h4>
 <code>--before</code> filter, the most recent version less than or equal to that tag
 will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
 <code>latest</code> is <code>2.0</code>.</p>
-<p>This config cannot be used with: <code>min-release-age</code></p>
+<p>If <code>before</code> and <code>min-release-age</code> are both set in the same source, <code>before</code>
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli &gt; env &gt; project &gt; user &gt;
+global), so a higher-priority source can always relax or override a
+lower-priority one.</p>
 <h4 id="min-release-age"><code>min-release-age</code></h4>
 <ul>
 <li>Default: null</li>
@@ -675,8 +722,11 @@ <h4 id="min-release-age"><code>min-release-age</code></h4>
 are no versions available for the current set of dependencies, the command
 will error.</p>
 <p>This flag is a complement to <code>before</code>, which accepts an exact date instead
-of a relative number of days.</p>
-<p>This config cannot be used with: <code>before</code></p>
+of a relative number of days. The two may coexist (e.g. <code>min-release-age</code> in
+your <code>.npmrc</code> is preserved when npm internally spawns a sub-process with
+<code>--before</code> while preparing a <code>git:</code> or <code>github:</code> dependency); when both
+apply, <code>before</code> wins within a single source and across sources the standard
+precedence rules apply.</p>
 <p>This value is not exported to the environment for child processes.</p>
 <h4 id="bin-links"><code>bin-links</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-link.html b/deps/npm/docs/output/commands/npm-link.html
index aed7d7f511bfad..06097944e8ca5f 100644
--- a/deps/npm/docs/output/commands/npm-link.html
+++ b/deps/npm/docs/output/commands/npm-link.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-link----11130">
+<h1 id="----npm-link----11150">
     <span>npm-link</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Symlink a package folder</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#caveat">Caveat</a></li><li><a href="#workspace-usage">Workspace Usage</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#caveat">Caveat</a></li><li><a href="#workspace-usage">Workspace Usage</a></li><li><a href="#configuration">Configuration</a></li><ul><li><a href="#save"><code>save</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#install-links"><code>install-links</code></a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -366,6 +366,34 @@ <h4 id="ignore-scripts"><code>ignore-scripts</code></h4>
 <code>npm start</code>, <code>npm stop</code>, <code>npm restart</code>, <code>npm test</code>, and <code>npm run</code> will still
 run their intended script if <code>ignore-scripts</code> is set, but they will <em>not</em>
 run any pre- or post-scripts.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -374,11 +402,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="audit"><code>audit</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-ll.html b/deps/npm/docs/output/commands/npm-ll.html
index ce891f5976b960..c61d58d80d9ef8 100644
--- a/deps/npm/docs/output/commands/npm-ll.html
+++ b/deps/npm/docs/output/commands/npm-ll.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-ll----11130">
+<h1 id="----npm-ll----11150">
     <span>npm-ll</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">List installed packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-login.html b/deps/npm/docs/output/commands/npm-login.html
index a442b2e7e76669..58c694e1d4e19a 100644
--- a/deps/npm/docs/output/commands/npm-login.html
+++ b/deps/npm/docs/output/commands/npm-login.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-login----11130">
+<h1 id="----npm-login----11150">
     <span>npm-login</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Login to a registry user account</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-logout.html b/deps/npm/docs/output/commands/npm-logout.html
index 28482bfd2a53f1..2229efdbe6a7f4 100644
--- a/deps/npm/docs/output/commands/npm-logout.html
+++ b/deps/npm/docs/output/commands/npm-logout.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-logout----11130">
+<h1 id="----npm-logout----11150">
     <span>npm-logout</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Log out of the registry</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-ls.html b/deps/npm/docs/output/commands/npm-ls.html
index 2f5dd885004c16..00829f01ae061d 100644
--- a/deps/npm/docs/output/commands/npm-ls.html
+++ b/deps/npm/docs/output/commands/npm-ls.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-ls----11130">
+<h1 id="----npm-ls----11150">
     <span>npm-ls</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">List installed packages</span>
 </header>
@@ -209,7 +209,7 @@ <h3 id="description">Description</h3>
 <p>Positional arguments are <code>name@version-range</code> identifiers, which will limit the results to only the paths to the packages named.
 Note that nested packages will <em>also</em> show the paths to the specified packages.
 For example, running <code>npm ls promzard</code> in npm's source tree will show:</p>
-<pre><code class="language-bash">npm@11.13.0 /path/to/npm
+<pre><code class="language-bash">npm@11.15.0 /path/to/npm
 └─┬ init-package-json@0.0.4
   └── promzard@0.1.5
 </code></pre>
diff --git a/deps/npm/docs/output/commands/npm-org.html b/deps/npm/docs/output/commands/npm-org.html
index 02bd129659dc32..257e5fa0c12910 100644
--- a/deps/npm/docs/output/commands/npm-org.html
+++ b/deps/npm/docs/output/commands/npm-org.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-org----11130">
+<h1 id="----npm-org----11150">
     <span>npm-org</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage orgs</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-outdated.html b/deps/npm/docs/output/commands/npm-outdated.html
index 2b4702dc5eefdd..0c95c2bfa59ead 100644
--- a/deps/npm/docs/output/commands/npm-outdated.html
+++ b/deps/npm/docs/output/commands/npm-outdated.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-outdated----11130">
+<h1 id="----npm-outdated----11150">
     <span>npm-outdated</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Check for outdated packages</span>
 </header>
@@ -328,7 +328,11 @@ <h4 id="before"><code>before</code></h4>
 <code>--before</code> filter, the most recent version less than or equal to that tag
 will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
 <code>latest</code> is <code>2.0</code>.</p>
-<p>This config cannot be used with: <code>min-release-age</code></p>
+<p>If <code>before</code> and <code>min-release-age</code> are both set in the same source, <code>before</code>
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli &gt; env &gt; project &gt; user &gt;
+global), so a higher-priority source can always relax or override a
+lower-priority one.</p>
 <h4 id="min-release-age"><code>min-release-age</code></h4>
 <ul>
 <li>Default: null</li>
@@ -339,8 +343,11 @@ <h4 id="min-release-age"><code>min-release-age</code></h4>
 are no versions available for the current set of dependencies, the command
 will error.</p>
 <p>This flag is a complement to <code>before</code>, which accepts an exact date instead
-of a relative number of days.</p>
-<p>This config cannot be used with: <code>before</code></p>
+of a relative number of days. The two may coexist (e.g. <code>min-release-age</code> in
+your <code>.npmrc</code> is preserved when npm internally spawns a sub-process with
+<code>--before</code> while preparing a <code>git:</code> or <code>github:</code> dependency); when both
+apply, <code>before</code> wins within a single source and across sources the standard
+precedence rules apply.</p>
 <p>This value is not exported to the environment for child processes.</p>
 <h3 id="see-also">See Also</h3>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-owner.html b/deps/npm/docs/output/commands/npm-owner.html
index 7519b7eafa17bd..5f7dda96d69e2a 100644
--- a/deps/npm/docs/output/commands/npm-owner.html
+++ b/deps/npm/docs/output/commands/npm-owner.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-owner----11130">
+<h1 id="----npm-owner----11150">
     <span>npm-owner</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage package owners</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-pack.html b/deps/npm/docs/output/commands/npm-pack.html
index 3290b6a50cb74f..7097d255509ae9 100644
--- a/deps/npm/docs/output/commands/npm-pack.html
+++ b/deps/npm/docs/output/commands/npm-pack.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-pack----11130">
+<h1 id="----npm-pack----11150">
     <span>npm-pack</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Create a tarball from a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-ping.html b/deps/npm/docs/output/commands/npm-ping.html
index 4fe67beb9b00a9..6f0dd51b517e4e 100644
--- a/deps/npm/docs/output/commands/npm-ping.html
+++ b/deps/npm/docs/output/commands/npm-ping.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-ping----11130">
+<h1 id="----npm-ping----11150">
     <span>npm-ping</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Ping npm registry</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-pkg.html b/deps/npm/docs/output/commands/npm-pkg.html
index 82928d2a503eae..d1953066d18b0f 100644
--- a/deps/npm/docs/output/commands/npm-pkg.html
+++ b/deps/npm/docs/output/commands/npm-pkg.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-pkg----11130">
+<h1 id="----npm-pkg----11150">
     <span>npm-pkg</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manages your package.json</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-prefix.html b/deps/npm/docs/output/commands/npm-prefix.html
index 6bbab9ec8b6baa..d248c0e19d5d91 100644
--- a/deps/npm/docs/output/commands/npm-prefix.html
+++ b/deps/npm/docs/output/commands/npm-prefix.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-prefix----11130">
+<h1 id="----npm-prefix----11150">
     <span>npm-prefix</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Display prefix</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-profile.html b/deps/npm/docs/output/commands/npm-profile.html
index a201918112143a..7f27c45182e770 100644
--- a/deps/npm/docs/output/commands/npm-profile.html
+++ b/deps/npm/docs/output/commands/npm-profile.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-profile----11130">
+<h1 id="----npm-profile----11150">
     <span>npm-profile</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Change settings on your registry profile</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-prune.html b/deps/npm/docs/output/commands/npm-prune.html
index 485ad8c114bca1..a2782ed0eae29c 100644
--- a/deps/npm/docs/output/commands/npm-prune.html
+++ b/deps/npm/docs/output/commands/npm-prune.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-prune----11130">
+<h1 id="----npm-prune----11150">
     <span>npm-prune</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Remove extraneous packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-publish.html b/deps/npm/docs/output/commands/npm-publish.html
index 9f16f9a0732631..2f194d3c4086a3 100644
--- a/deps/npm/docs/output/commands/npm-publish.html
+++ b/deps/npm/docs/output/commands/npm-publish.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-publish----11130">
+<h1 id="----npm-publish----11150">
     <span>npm-publish</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Publish a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-query.html b/deps/npm/docs/output/commands/npm-query.html
index caadf8dffcf929..30bddb72964b0d 100644
--- a/deps/npm/docs/output/commands/npm-query.html
+++ b/deps/npm/docs/output/commands/npm-query.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-query----11130">
+<h1 id="----npm-query----11150">
     <span>npm-query</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Dependency selector query</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-rebuild.html b/deps/npm/docs/output/commands/npm-rebuild.html
index 51386d3290beab..30301c4cda1c2e 100644
--- a/deps/npm/docs/output/commands/npm-rebuild.html
+++ b/deps/npm/docs/output/commands/npm-rebuild.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-rebuild----11130">
+<h1 id="----npm-rebuild----11150">
     <span>npm-rebuild</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Rebuild a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-repo.html b/deps/npm/docs/output/commands/npm-repo.html
index 1b4db65a41f8a1..e6bd1024c2252f 100644
--- a/deps/npm/docs/output/commands/npm-repo.html
+++ b/deps/npm/docs/output/commands/npm-repo.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-repo----11130">
+<h1 id="----npm-repo----11150">
     <span>npm-repo</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Open package repository page in the browser</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-restart.html b/deps/npm/docs/output/commands/npm-restart.html
index 3bfb26e5b83c35..3f08556ca35fd4 100644
--- a/deps/npm/docs/output/commands/npm-restart.html
+++ b/deps/npm/docs/output/commands/npm-restart.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-restart----11130">
+<h1 id="----npm-restart----11150">
     <span>npm-restart</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Restart a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-root.html b/deps/npm/docs/output/commands/npm-root.html
index f224de42549133..638fe0c5f29a31 100644
--- a/deps/npm/docs/output/commands/npm-root.html
+++ b/deps/npm/docs/output/commands/npm-root.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-root----11130">
+<h1 id="----npm-root----11150">
     <span>npm-root</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Display npm root</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-run.html b/deps/npm/docs/output/commands/npm-run.html
index c61048f31cf8e2..38864357391f68 100644
--- a/deps/npm/docs/output/commands/npm-run.html
+++ b/deps/npm/docs/output/commands/npm-run.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-run----11130">
+<h1 id="----npm-run----11150">
     <span>npm-run</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Run arbitrary package scripts</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-sbom.html b/deps/npm/docs/output/commands/npm-sbom.html
index ddee5f40af3896..a08eee8e909bf4 100644
--- a/deps/npm/docs/output/commands/npm-sbom.html
+++ b/deps/npm/docs/output/commands/npm-sbom.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-sbom----11130">
+<h1 id="----npm-sbom----11150">
     <span>npm-sbom</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Generate a Software Bill of Materials (SBOM)</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-search.html b/deps/npm/docs/output/commands/npm-search.html
index 5c01a0fd8bfe66..8a009f559e779c 100644
--- a/deps/npm/docs/output/commands/npm-search.html
+++ b/deps/npm/docs/output/commands/npm-search.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-search----11130">
+<h1 id="----npm-search----11150">
     <span>npm-search</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Search for packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-set.html b/deps/npm/docs/output/commands/npm-set.html
index b5bd610f6d999a..c6811ae41180e3 100644
--- a/deps/npm/docs/output/commands/npm-set.html
+++ b/deps/npm/docs/output/commands/npm-set.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-set----11130">
+<h1 id="----npm-set----11150">
     <span>npm-set</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Set a value in the npm configuration</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-shrinkwrap.html b/deps/npm/docs/output/commands/npm-shrinkwrap.html
index ac415a958f178d..3dff3e5d1db87c 100644
--- a/deps/npm/docs/output/commands/npm-shrinkwrap.html
+++ b/deps/npm/docs/output/commands/npm-shrinkwrap.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-shrinkwrap----11130">
+<h1 id="----npm-shrinkwrap----11150">
     <span>npm-shrinkwrap</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Lock down dependency versions for publication</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-stage.html b/deps/npm/docs/output/commands/npm-stage.html
new file mode 100644
index 00000000000000..6abe7e8bb5daa1
--- /dev/null
+++ b/deps/npm/docs/output/commands/npm-stage.html
@@ -0,0 +1,582 @@
+<!DOCTYPE html><html><head>
+<meta charset="utf-8">
+<title>npm-stage</title>
+<style>
+body {
+    background-color: #ffffff;
+    color: #24292e;
+
+    margin: 0;
+
+    line-height: 1.5;
+
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+}
+#rainbar {
+    height: 10px;
+    background-image: linear-gradient(139deg, #fb8817, #ff4b01, #c12127, #e02aff);
+}
+
+a {
+    text-decoration: none;
+    color: #0366d6;
+}
+a:hover {
+    text-decoration: underline;
+}
+
+pre {
+    margin: 1em 0px;
+    padding: 1em;
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+
+    display: block;
+    overflow: auto;
+
+    white-space: pre;
+
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+code {
+    font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    font-size: 85%;
+    padding: 0.2em 0.4em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+pre > code {
+    padding: 0;
+    background-color: inherit;
+    color: inherit;
+}
+h1, h2, h3 {
+    font-weight: 600;
+}
+
+#logobar {
+    background-color: #333333;
+    margin: 0 auto;
+    padding: 1em 4em;
+}
+#logobar .logo {
+    float: left;
+}
+#logobar .title {
+    font-weight: 600;
+    color: #dddddd;
+    float: left;
+    margin: 5px 0 0 1em;
+}
+#logobar:after {
+    content: "";
+    display: block;
+    clear: both;
+}
+
+#content {
+    margin: 0 auto;
+    padding: 0 4em;
+}
+
+#table_of_contents > h2 {
+    font-size: 1.17em;
+}
+#table_of_contents ul:first-child {
+    border: solid 1px #e1e4e8;
+    border-radius: 6px;
+    padding: 1em;
+    background-color: #f6f8fa;
+    color: #393a34;
+}
+#table_of_contents ul {
+    list-style-type: none;
+    padding-left: 1.5em;
+}
+#table_of_contents li {
+    font-size: 0.9em;
+}
+#table_of_contents li a {
+    color: #000000;
+}
+
+header.title {
+    border-bottom: solid 1px #e1e4e8;
+}
+header.title > h1 {
+    margin-bottom: 0.25em;
+}
+header.title > .description {
+    display: block;
+    margin-bottom: 0.5em;
+    line-height: 1;
+}
+
+header.title .version {
+    font-size: 0.8em;
+    color: #666666;
+}
+
+footer#edit {
+    border-top: solid 1px #e1e4e8;
+    margin: 3em 0 4em 0;
+    padding-top: 2em;
+}
+
+table {
+    width: 100%;
+    margin: 1em 0;
+    border-radius: 6px;
+    border: 1px solid #e1e4e8;
+    overflow: hidden;
+    border-collapse: separate;
+    border-spacing: 0;
+}
+
+table thead {
+    background-color: #f6f8fa;
+}
+
+table tbody {
+    background-color: #ffffff;
+}
+
+table th,
+table td {
+    padding: 0.75em;
+    text-align: left;
+    border-right: 1px solid #e1e4e8;
+    border-bottom: 1px solid #e1e4e8;
+}
+
+table th:last-child,
+table td:last-child {
+    border-right: none;
+}
+
+table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+table th {
+    font-weight: 600;
+    background-color: #f6f8fa;
+}
+
+table code {
+    white-space: nowrap;
+}
+
+</style>
+</head>
+<body>
+<div id="banner">
+<div id="rainbar"></div>
+<div id="logobar">
+<svg class="logo" role="img" height="32" width="32" viewBox="0 0 700 700">
+<polygon fill="#cb0000" points="0,700 700,700 700,0 0,0"></polygon>
+<polygon fill="#ffffff" points="150,550 350,550 350,250 450,250 450,550 550,550 550,150 150,150"></polygon>
+</svg>
+<div class="title">
+npm command-line interface
+</div>
+</div>
+</div>
+
+<section id="content">
+<header class="title">
+<h1 id="----npm-stage----11150">
+    <span>npm-stage</span>
+    <span class="version">@11.15.0</span>
+</h1>
+<span class="description">Stage packages for publishing</span>
+</header>
+
+<section id="table_of_contents">
+<h2 id="table-of-contents">Table of contents</h2>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#description">Description</a></li><li><a href="#prerequisites">Prerequisites</a></li><li><a href="#subcommands">Subcommands</a></li><li><a href="#2fa-requirements-by-subcommand">2FA Requirements by Subcommand</a></li><li><a href="#tag-behavior">Tag Behavior</a></li><li><a href="#token-behavior">Token Behavior</a></li><li><a href="#trust-relationship-permissions">Trust Relationship Permissions</a></li><li><a href="#best-practices">Best Practices</a></li><li><a href="#configuration">Configuration</a></li><li><a href="#npm-stage-publish"><code>npm stage publish</code></a></li><ul><li><a href="#synopsis2">Synopsis</a></li><li><a href="#flags">Flags</a></li></ul><li><a href="#npm-stage-list"><code>npm stage list</code></a></li><ul><li><a href="#synopsis3">Synopsis</a></li><li><a href="#flags2">Flags</a></li></ul><li><a href="#npm-stage-view"><code>npm stage view</code></a></li><ul><li><a href="#synopsis4">Synopsis</a></li><li><a href="#flags3">Flags</a></li></ul><li><a href="#npm-stage-approve"><code>npm stage approve</code></a></li><ul><li><a href="#synopsis5">Synopsis</a></li><li><a href="#flags4">Flags</a></li></ul><li><a href="#npm-stage-reject"><code>npm stage reject</code></a></li><ul><li><a href="#synopsis6">Synopsis</a></li><li><a href="#flags5">Flags</a></li></ul><li><a href="#npm-stage-download"><code>npm stage download</code></a></li><ul><li><a href="#synopsis7">Synopsis</a></li><li><a href="#flags6">Flags</a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+</section>
+
+<div id="_content"><h3 id="synopsis">Synopsis</h3>
+<pre><code class="language-bash">npm stage
+</code></pre>
+<p>Note: This command is unaware of workspaces.</p>
+<h3 id="description">Description</h3>
+<p>Staged publishing allows package maintainers to require proof-of-presence
+for all publishes. Proof-of-presence is where a human is involved,
+interjects, and provides authentication (2FA) during an action — in this
+case, publishing an npm package.</p>
+<p>Typically when maintainers use automated workflows to publish,
+proof-of-presence is lacking as there's no convenient way to interject the
+process and provide 2FA, as is the case for publishing with a granular
+access token with bypass and the trusted publishing flow. Staged publishing
+allows users to have their automated workflows stage a package without a 2FA
+prompt, deferring the act of 2FA, allowing the maintainer to approve the
+staged package and publish at a later point.</p>
+<p>The <code>npm stage publish</code> command packs the current working directory and
+places that version of the package into the registry in a state where it's
+not available for public access, allowing maintainers to approve the package
+at a later point in time. The act of staging does not prompt for 2FA and can be done with any token
+type, the act of approving will.</p>
+<p>Key behaviors:</p>
+<ul>
+<li>Staged packages share the same semver version unique index as published
+packages — you cannot publish a version that already exists as a staged
+version for that package.</li>
+<li>You can still publish packages normally while you have staged packages
+pending.</li>
+<li>You can stage multiple versions of the same package.</li>
+<li><code>npm stage publish</code> has parity with <code>npm publish</code> and will respect
+<code>"private": true</code> in <code>package.json</code>, refusing to stage the package.</li>
+</ul>
+<h3 id="prerequisites">Prerequisites</h3>
+<p>Before using <code>npm stage</code> commands, ensure the following requirements are met:</p>
+<ul>
+<li><strong>Write permissions on the package:</strong> You must have write access to the
+package you're configuring.</li>
+<li><strong>Package must exist:</strong> The package you're configuring must already exist
+on the npm registry.</li>
+<li><strong>2FA enabled on your account:</strong> Commands that require 2FA will prompt you
+to authenticate. If you don't already have 2FA enabled on your account,
+you must enable it before using these commands.</li>
+</ul>
+<h3 id="subcommands">Subcommands</h3>
+<ul>
+<li><code>npm stage publish [&lt;package-spec&gt;]</code> - Stage a package for publishing</li>
+<li><code>npm stage list [&lt;package-spec&gt;]</code> - List all staged package versions</li>
+<li><code>npm stage view &lt;stage-id&gt;</code> - View details of a specific staged package</li>
+<li><code>npm stage approve &lt;stage-id&gt;</code> - Approve a staged package for publishing</li>
+<li><code>npm stage reject &lt;stage-id&gt;</code> - Reject a staged package</li>
+<li><code>npm stage download &lt;stage-id&gt;</code> - Download the tarball for inspection</li>
+</ul>
+<h3 id="2fa-requirements-by-subcommand">2FA Requirements by Subcommand</h3>
+<table>
+<thead>
+<tr>
+<th>Command</th>
+<th>Requires 2FA</th>
+<th>Notes</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>npm stage publish</code></td>
+<td>No</td>
+<td>Designed for automated workflows; defers 2FA to approval</td>
+</tr>
+<tr>
+<td><code>npm stage list</code></td>
+<td>No</td>
+<td>View staged packages</td>
+</tr>
+<tr>
+<td><code>npm stage view</code></td>
+<td>No</td>
+<td>View staged package details</td>
+</tr>
+<tr>
+<td><code>npm stage approve</code></td>
+<td>Yes</td>
+<td>Prompts for 2FA to publish the staged package</td>
+</tr>
+<tr>
+<td><code>npm stage reject</code></td>
+<td>Yes</td>
+<td>Prompts for 2FA to permanently remove the staged package</td>
+</tr>
+<tr>
+<td><code>npm stage download</code></td>
+<td>No</td>
+<td>Downloads the tarball for local inspection</td>
+</tr>
+</tbody>
+</table>
+<h3 id="tag-behavior">Tag Behavior</h3>
+<p>The <code>--tag</code> flag follows the same logic as <code>npm publish</code>. If no tag is
+provided, the <code>latest</code> tag is used by default. For pre-release versions
+(e.g., <code>1.0.0-beta.1</code>) and non-latest semver versions, the tag must be
+explicitly provided — otherwise the CLI will error, just as <code>npm publish</code>
+would.</p>
+<p>The tag is an immutable property of the staged package. Once a package is
+staged with a given tag, the tag cannot be changed. If you need to stage the
+same version with a different tag, you must first reject the existing staged
+package using <code>npm stage reject</code> and then re-stage it with the desired tag.</p>
+<h3 id="token-behavior">Token Behavior</h3>
+<p>The key difference with staged publishing is that <code>npm stage publish</code> never
+requires a 2FA prompt, regardless of token type. This is what makes it
+suitable for automated workflows. The goal of <code>npm stage publish</code> is
+deferring proof-of-presence to a later point in time.</p>
+<table>
+<thead>
+<tr>
+<th>Token Type</th>
+<th><code>npm stage publish</code></th>
+<th><code>npm publish</code></th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>GAT with bypass</td>
+<td>Can stage</td>
+<td>Can publish (if allowed by package publishing access)</td>
+</tr>
+<tr>
+<td>GAT without bypass</td>
+<td>Can stage</td>
+<td>2FA prompt (if allowed by package publishing access)</td>
+</tr>
+<tr>
+<td>Session token</td>
+<td>Can stage</td>
+<td>2FA prompt</td>
+</tr>
+<tr>
+<td>Trust token (OIDC)</td>
+<td>Can stage (if allowed)</td>
+<td>Can publish (if allowed)</td>
+</tr>
+</tbody>
+</table>
+<h3 id="trust-relationship-permissions">Trust Relationship Permissions</h3>
+<p>With staged publishing, trust relationships now support granular command
+permissions. Shortlived tokens issued through trust relationships can only be
+used with <code>npm stage publish</code> and <code>npm publish</code>. Shortlived tokens cannot run
+<code>npm stage</code> subcommands.</p>
+<p><code>npm trust &lt;provider&gt;</code> supports <code>--allow-publish</code> and <code>--allow-stage-publish</code>
+to control which commands are available through each trust relationship.</p>
+<h3 id="best-practices">Best Practices</h3>
+<p><strong>Note:</strong> The addition of staged publishing does not make your account or org
+more secure. Maintainers must still use the best practices listed below.</p>
+<ol>
+<li>
+<p><strong>Delete Granular Access Tokens (GAT) with bypass 2FA enabled.</strong>
+Now with staged publishing, we've eliminated the need for a GAT token
+that can bypass 2FA. We encourage you to delete all your tokens with
+bypass enabled and switch to using a trust relationship in your automated
+workflows, or create a GAT without bypass and use <code>npm stage publish</code>.</p>
+</li>
+<li>
+<p><strong>Disallow tokens from publishing at the package level.</strong>
+All packages have their own access controls under "package access"
+allowing packages to be published with bypass tokens, which is no longer
+a necessity. We encourage you to select "Require two-factor
+authentication and disallow tokens (recommended)" for all your packages
+on the package access page.</p>
+</li>
+<li>
+<p><strong>Configure trust relationship permissions to prevent <code>npm publish</code>.</strong>
+We encourage you to only enable <code>npm stage publish</code> on your trust
+relationships and disable <code>npm publish</code>.</p>
+</li>
+</ol>
+<h3 id="configuration">Configuration</h3>
+<h3 id="npm-stage-publish"><code>npm stage publish</code></h3>
+<p>Stage a package for publishing, deferring proof-of-presence (2FA) to a later point in time</p>
+<h4 id="synopsis2">Synopsis</h4>
+<pre><code class="language-bash">npm stage publish &lt;package-spec&gt;
+</code></pre>
+<h4 id="flags">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--tag</code></td>
+<td>"latest"</td>
+<td>String</td>
+<td>If you ask npm to install a package and don't tell it a specific version,       then it will install the specified tag.        It is the tag added to the package@version specified in the        <code>npm dist-tag add</code> command, if no explicit tag is given.        When used by the <code>npm diff</code> command, this is the tag used to fetch the       tarball that will be compared with the local files by default.              If used in the <code>npm publish</code> command, this is the tag that will be        added to the package submitted to the registry.</td>
+</tr>
+<tr>
+<td><code>--access</code></td>
+<td></td>
+<td></td>
+<td></td>
+</tr>
+</tbody>
+</table>
+<pre><code>'public' for new packages, existing packages it will not change the current level
+</code></pre>
+<p>| null, "restricted", or "public" | If you do not want your scoped package to be publicly viewable (and     installable) set <code>--access=restricted</code>.      Unscoped packages cannot be set to <code>restricted</code>.      Note: This defaults to not changing the current access level for existing     packages.  Specifying a value of <code>restricted</code> or <code>public</code> during     publish will change the access for an existing package the same way that     <code>npm access set status</code> would. |
+| <code>--dry-run</code> | false | Boolean | Indicates that you don't want npm to make any changes and that it should       only report what it would have done.  This can be passed into any of the       commands that modify your local installation, eg, <code>install</code>,       <code>update</code>, <code>dedupe</code>, <code>uninstall</code>, as well as <code>pack</code> and       <code>publish</code>.        Note: This is NOT honored by other network related commands, eg       <code>dist-tags</code>, <code>owner</code>, etc. |
+| <code>--otp</code> | null | null or String | This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with <code>npm access</code>.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one. |
+| <code>--workspace</code>, <code>-w</code> |  | String (can be set multiple times) | Enable running a command in the context of the configured workspaces of the       current project while filtering by running only the workspaces defined by       this configuration option.        Valid values for the <code>workspace</code> config are either:        * Workspace names       * Path to a workspace directory       * Path to a parent workspace directory (will result in selecting all         workspaces within that folder)        When set for the <code>npm init</code> command, this may be set to the folder of       a workspace which does not yet exist, to create the folder and set it       up as a brand new workspace within the project. |
+| <code>--workspaces</code> | null | null or Boolean | Set to true to run the command in the context of <strong>all</strong> configured       workspaces.        Explicitly setting this to false will cause commands like <code>install</code> to       ignore workspaces altogether.       When not set explicitly:        - Commands that operate on the <code>node_modules</code> tree (install, update,         etc.) will link workspaces into the <code>node_modules</code> folder.       - Commands that do other things (test, exec, publish, etc.) will operate         on the root project, <em>unless</em> one or more workspaces are specified in         the <code>workspace</code> config. |
+| <code>--include-workspace-root</code> | false | Boolean | Include the workspace root when workspaces are enabled for a command.        When false, specifying individual workspaces via the <code>workspace</code> config,       or all workspaces via the <code>workspaces</code> flag, will cause npm to operate only       on the specified workspaces, and not on the root project. |
+| <code>--provenance</code> | false | Boolean | When publishing from a supported cloud CI/CD system, the package will be       publicly linked to where it was built and published from. |</p>
+<h3 id="npm-stage-list"><code>npm stage list</code></h3>
+<p>List all staged package versions</p>
+<h4 id="synopsis3">Synopsis</h4>
+<pre><code class="language-bash">npm stage list [&lt;package-spec&gt;]
+</code></pre>
+<h4 id="flags2">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-stage-view"><code>npm stage view</code></h3>
+<p>View details of a specific staged package</p>
+<h4 id="synopsis4">Synopsis</h4>
+<pre><code class="language-bash">npm stage view &lt;stage-id&gt;
+</code></pre>
+<h4 id="flags3">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-stage-approve"><code>npm stage approve</code></h3>
+<p>Approve a staged package, publishing it to the npm registry</p>
+<h4 id="synopsis5">Synopsis</h4>
+<pre><code class="language-bash">npm stage approve &lt;stage-id&gt;
+</code></pre>
+<h4 id="flags4">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--otp</code></td>
+<td>null</td>
+<td>null or String</td>
+<td>This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with <code>npm access</code>.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-stage-reject"><code>npm stage reject</code></h3>
+<p>Reject a staged package, removing it from the registry</p>
+<h4 id="synopsis6">Synopsis</h4>
+<pre><code class="language-bash">npm stage reject &lt;stage-id&gt;
+</code></pre>
+<h4 id="flags5">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--otp</code></td>
+<td>null</td>
+<td>null or String</td>
+<td>This is a one-time password from a two-factor authenticator.  It's needed       when publishing or changing package permissions with <code>npm access</code>.        If not set, and a registry response fails with a challenge for a one-time       password, npm will prompt on the command line for one.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="npm-stage-download"><code>npm stage download</code></h3>
+<p>Download the tarball of a staged package for inspection</p>
+<h4 id="synopsis7">Synopsis</h4>
+<pre><code class="language-bash">npm stage download &lt;stage-id&gt;
+</code></pre>
+<h4 id="flags6">Flags</h4>
+<table>
+<thead>
+<tr>
+<th>Flag</th>
+<th>Default</th>
+<th>Type</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>--json</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Whether or not to output JSON data, rather than the normal output.        * In <code>npm pkg set</code> it enables parsing set values with JSON.parse()       before saving them to your <code>package.json</code>.        Not supported by all npm commands.</td>
+</tr>
+<tr>
+<td><code>--registry</code></td>
+<td>"<a href="https://registry.npmjs.org/">https://registry.npmjs.org/</a>"</td>
+<td>URL</td>
+<td>The base URL of the npm registry.</td>
+</tr>
+</tbody>
+</table>
+<h3 id="see-also">See Also</h3>
+<ul>
+<li><a href="../commands/npm-publish.html">npm publish</a></li>
+<li><a href="../commands/npm-unpublish.html">npm unpublish</a></li>
+<li><a href="../commands/npm-trust.html">npm trust</a></li>
+</ul></div>
+
+<footer id="edit">
+<a href="https://github.com/npm/cli/edit/latest/docs/lib/content/commands/npm-stage.md">
+<svg role="img" viewBox="0 0 16 16" width="16" height="16" fill="currentcolor" style="vertical-align: text-bottom; margin-right: 0.3em;">
+<path fill-rule="evenodd" d="M11.013 1.427a1.75 1.75 0 012.474 0l1.086 1.086a1.75 1.75 0 010 2.474l-8.61 8.61c-.21.21-.47.364-.756.445l-3.251.93a.75.75 0 01-.927-.928l.929-3.25a1.75 1.75 0 01.445-.758l8.61-8.61zm1.414 1.06a.25.25 0 00-.354 0L10.811 3.75l1.439 1.44 1.263-1.263a.25.25 0 000-.354l-1.086-1.086zM11.189 6.25L9.75 4.81l-6.286 6.287a.25.25 0 00-.064.108l-.558 1.953 1.953-.558a.249.249 0 00.108-.064l6.286-6.286z"></path>
+</svg>
+Edit this page on GitHub
+</a>
+</footer>
+</section>
+
+
+
+</body></html>
\ No newline at end of file
diff --git a/deps/npm/docs/output/commands/npm-star.html b/deps/npm/docs/output/commands/npm-star.html
index 977756cc679403..40433712a41fef 100644
--- a/deps/npm/docs/output/commands/npm-star.html
+++ b/deps/npm/docs/output/commands/npm-star.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-star----11130">
+<h1 id="----npm-star----11150">
     <span>npm-star</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Mark your favorite packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-stars.html b/deps/npm/docs/output/commands/npm-stars.html
index 66164fa7780b94..4fa00ccd89e134 100644
--- a/deps/npm/docs/output/commands/npm-stars.html
+++ b/deps/npm/docs/output/commands/npm-stars.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-stars----11130">
+<h1 id="----npm-stars----11150">
     <span>npm-stars</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">View packages marked as favorites</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-start.html b/deps/npm/docs/output/commands/npm-start.html
index c5079ac37a31da..79e15eaeabe32e 100644
--- a/deps/npm/docs/output/commands/npm-start.html
+++ b/deps/npm/docs/output/commands/npm-start.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-start----11130">
+<h1 id="----npm-start----11150">
     <span>npm-start</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Start a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-stop.html b/deps/npm/docs/output/commands/npm-stop.html
index 92500df777600a..132a6540c9031e 100644
--- a/deps/npm/docs/output/commands/npm-stop.html
+++ b/deps/npm/docs/output/commands/npm-stop.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-stop----11130">
+<h1 id="----npm-stop----11150">
     <span>npm-stop</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Stop a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-team.html b/deps/npm/docs/output/commands/npm-team.html
index f83bbe0ee6bbe3..42031ba120ae7b 100644
--- a/deps/npm/docs/output/commands/npm-team.html
+++ b/deps/npm/docs/output/commands/npm-team.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-team----11130">
+<h1 id="----npm-team----11150">
     <span>npm-team</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage organization teams and team memberships</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-test.html b/deps/npm/docs/output/commands/npm-test.html
index 9466dd432374db..2da5db2ff7f08b 100644
--- a/deps/npm/docs/output/commands/npm-test.html
+++ b/deps/npm/docs/output/commands/npm-test.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-test----11130">
+<h1 id="----npm-test----11150">
     <span>npm-test</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Test a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-token.html b/deps/npm/docs/output/commands/npm-token.html
index 7b956c64d1d11e..bff16ccc4e1c42 100644
--- a/deps/npm/docs/output/commands/npm-token.html
+++ b/deps/npm/docs/output/commands/npm-token.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-token----11130">
+<h1 id="----npm-token----11150">
     <span>npm-token</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage your authentication tokens</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-trust.html b/deps/npm/docs/output/commands/npm-trust.html
index d2f7cfb44c024a..e4041c733f4b3b 100644
--- a/deps/npm/docs/output/commands/npm-trust.html
+++ b/deps/npm/docs/output/commands/npm-trust.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-trust----11130">
+<h1 id="----npm-trust----11150">
     <span>npm-trust</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Manage trusted publishing relationships between packages and CI/CD providers</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#prerequisites">Prerequisites</a></li><li><a href="#description">Description</a></li><li><a href="#bulk-usage">Bulk Usage</a></li><li><a href="#configuration">Configuration</a></li><li><a href="#npm-trust-github"><code>npm trust github</code></a></li><ul><li><a href="#synopsis2">Synopsis</a></li><li><a href="#flags">Flags</a></li></ul><li><a href="#npm-trust-gitlab"><code>npm trust gitlab</code></a></li><ul><li><a href="#synopsis3">Synopsis</a></li><li><a href="#flags2">Flags</a></li></ul><li><a href="#npm-trust-circleci"><code>npm trust circleci</code></a></li><ul><li><a href="#synopsis4">Synopsis</a></li><li><a href="#flags3">Flags</a></li></ul><li><a href="#npm-trust-list"><code>npm trust list</code></a></li><ul><li><a href="#synopsis5">Synopsis</a></li><li><a href="#flags4">Flags</a></li></ul><li><a href="#npm-trust-revoke"><code>npm trust revoke</code></a></li><ul><li><a href="#synopsis6">Synopsis</a></li><li><a href="#flags5">Flags</a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#synopsis">Synopsis</a></li><li><a href="#prerequisites">Prerequisites</a></li><li><a href="#description">Description</a></li><li><a href="#permissions">Permissions</a></li><li><a href="#provider-options">Provider Options</a></li><li><a href="#bulk-usage">Bulk Usage</a></li><li><a href="#configuration">Configuration</a></li><li><a href="#npm-trust-github"><code>npm trust github</code></a></li><ul><li><a href="#synopsis2">Synopsis</a></li><li><a href="#flags">Flags</a></li></ul><li><a href="#npm-trust-gitlab"><code>npm trust gitlab</code></a></li><ul><li><a href="#synopsis3">Synopsis</a></li><li><a href="#flags2">Flags</a></li></ul><li><a href="#npm-trust-circleci"><code>npm trust circleci</code></a></li><ul><li><a href="#synopsis4">Synopsis</a></li><li><a href="#flags3">Flags</a></li></ul><li><a href="#npm-trust-list"><code>npm trust list</code></a></li><ul><li><a href="#synopsis5">Synopsis</a></li><li><a href="#flags4">Flags</a></li></ul><li><a href="#npm-trust-revoke"><code>npm trust revoke</code></a></li><ul><li><a href="#synopsis6">Synopsis</a></li><li><a href="#flags5">Flags</a></li></ul><li><a href="#see-also">See Also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="synopsis">Synopsis</h3>
@@ -214,6 +214,14 @@ <h3 id="description">Description</h3>
 <p>For a comprehensive overview of trusted publishing, see the <a href="https://docs.npmjs.com/trusted-publishers">npm trusted publishers documentation</a>.</p>
 <p>The <code>[package]</code> argument specifies the package name. If omitted, npm will use the name from the <code>package.json</code> in the current directory.</p>
 <p>Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal—npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use <code>npm trust &lt;provider&gt; --help</code>.</p>
+<h3 id="permissions">Permissions</h3>
+<p>When creating a trust relationship, you must specify at least one permission flag to indicate which operations the trusted publisher is allowed to perform:</p>
+<ul>
+<li><code>--allow-publish</code>: Allows the trusted publisher to run <code>npm publish</code> for the package.</li>
+<li><code>--allow-stage-publish</code>: Allows the trusted publisher to run <code>npm stage</code> for the package. The alias <code>--allow-staged-publish</code> is also accepted.</li>
+</ul>
+<p>At least one of these flags is required when creating a trust configuration. You can specify both to grant both permissions.</p>
+<h3 id="provider-options">Provider Options</h3>
 <p>The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the <a href="https://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations">managing trusted publisher configurations</a> section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the <code>repository.url</code> field from your <code>package.json</code>, if available.</p>
 <p>Currently, the registry only supports one configuration per package. If you attempt to create a new trust relationship when one already exists, it will result in an error. To replace an existing configuration:</p>
 <ol>
@@ -229,7 +237,7 @@ <h3 id="configuration">Configuration</h3>
 <h3 id="npm-trust-github"><code>npm trust github</code></h3>
 <p>Create a trusted relationship between a package and GitHub Actions</p>
 <h4 id="synopsis2">Synopsis</h4>
-<pre><code class="language-bash">npm trust github [package] --file [--repo|--repository] [--env|--environment] [-y|--yes]
+<pre><code class="language-bash">npm trust github [package] --file [--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 </code></pre>
 <h4 id="flags">Flags</h4>
 <table>
@@ -261,6 +269,18 @@ <h4 id="flags">Flags</h4>
 <td>CI environment name</td>
 </tr>
 <tr>
+<td><code>--allow-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm publish for this trusted publisher configuration</td>
+</tr>
+<tr>
+<td><code>--allow-stage-publish</code>, <code>--allow-staged-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm stage publish for this trusted publisher configuration</td>
+</tr>
+<tr>
 <td><code>--dry-run</code></td>
 <td>false</td>
 <td>Boolean</td>
@@ -289,7 +309,7 @@ <h4 id="flags">Flags</h4>
 <h3 id="npm-trust-gitlab"><code>npm trust gitlab</code></h3>
 <p>Create a trusted relationship between a package and GitLab CI/CD</p>
 <h4 id="synopsis3">Synopsis</h4>
-<pre><code class="language-bash">npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]
+<pre><code class="language-bash">npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 </code></pre>
 <h4 id="flags2">Flags</h4>
 <table>
@@ -321,6 +341,18 @@ <h4 id="flags2">Flags</h4>
 <td>CI environment name</td>
 </tr>
 <tr>
+<td><code>--allow-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm publish for this trusted publisher configuration</td>
+</tr>
+<tr>
+<td><code>--allow-stage-publish</code>, <code>--allow-staged-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm stage publish for this trusted publisher configuration</td>
+</tr>
+<tr>
 <td><code>--dry-run</code></td>
 <td>false</td>
 <td>Boolean</td>
@@ -349,7 +381,7 @@ <h4 id="flags2">Flags</h4>
 <h3 id="npm-trust-circleci"><code>npm trust circleci</code></h3>
 <p>Create a trusted relationship between a package and CircleCI</p>
 <h4 id="synopsis4">Synopsis</h4>
-<pre><code class="language-bash">npm trust circleci [package] --org-id &lt;uuid&gt; --project-id &lt;uuid&gt; --pipeline-definition-id &lt;uuid&gt; --vcs-origin &lt;origin&gt; [--context-id &lt;uuid&gt;...] [-y|--yes]
+<pre><code class="language-bash">npm trust circleci [package] --org-id &lt;uuid&gt; --project-id &lt;uuid&gt; --pipeline-definition-id &lt;uuid&gt; --vcs-origin &lt;origin&gt; [--context-id &lt;uuid&gt;...] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 </code></pre>
 <h4 id="flags3">Flags</h4>
 <table>
@@ -393,6 +425,18 @@ <h4 id="flags3">Flags</h4>
 <td>CircleCI context UUID to match</td>
 </tr>
 <tr>
+<td><code>--allow-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm publish for this trusted publisher configuration</td>
+</tr>
+<tr>
+<td><code>--allow-stage-publish</code>, <code>--allow-staged-publish</code></td>
+<td>false</td>
+<td>Boolean</td>
+<td>Allow npm stage publish for this trusted publisher configuration</td>
+</tr>
+<tr>
 <td><code>--dry-run</code></td>
 <td>false</td>
 <td>Boolean</td>
diff --git a/deps/npm/docs/output/commands/npm-undeprecate.html b/deps/npm/docs/output/commands/npm-undeprecate.html
index f4a4530423d3f2..bafbabefdfecef 100644
--- a/deps/npm/docs/output/commands/npm-undeprecate.html
+++ b/deps/npm/docs/output/commands/npm-undeprecate.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-undeprecate----11130">
+<h1 id="----npm-undeprecate----11150">
     <span>npm-undeprecate</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Undeprecate a version of a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-uninstall.html b/deps/npm/docs/output/commands/npm-uninstall.html
index dbad4b89328bfa..a42ee20cf0509b 100644
--- a/deps/npm/docs/output/commands/npm-uninstall.html
+++ b/deps/npm/docs/output/commands/npm-uninstall.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-uninstall----11130">
+<h1 id="----npm-uninstall----11150">
     <span>npm-uninstall</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Remove a package</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-unpublish.html b/deps/npm/docs/output/commands/npm-unpublish.html
index 2437c08a3d38b1..3e3f4e3e9d541b 100644
--- a/deps/npm/docs/output/commands/npm-unpublish.html
+++ b/deps/npm/docs/output/commands/npm-unpublish.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-unpublish----11130">
+<h1 id="----npm-unpublish----11150">
     <span>npm-unpublish</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Remove a package from the registry</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-unstar.html b/deps/npm/docs/output/commands/npm-unstar.html
index 78b27c53c751dc..0e98f60d7bc737 100644
--- a/deps/npm/docs/output/commands/npm-unstar.html
+++ b/deps/npm/docs/output/commands/npm-unstar.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-unstar----11130">
+<h1 id="----npm-unstar----11150">
     <span>npm-unstar</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Remove an item from your favorite packages</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-update.html b/deps/npm/docs/output/commands/npm-update.html
index 9396c8a6834ed1..a57b62afbf6943 100644
--- a/deps/npm/docs/output/commands/npm-update.html
+++ b/deps/npm/docs/output/commands/npm-update.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-update----11130">
+<h1 id="----npm-update----11150">
     <span>npm-update</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Update packages</span>
 </header>
@@ -429,7 +429,11 @@ <h4 id="before"><code>before</code></h4>
 <code>--before</code> filter, the most recent version less than or equal to that tag
 will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
 <code>latest</code> is <code>2.0</code>.</p>
-<p>This config cannot be used with: <code>min-release-age</code></p>
+<p>If <code>before</code> and <code>min-release-age</code> are both set in the same source, <code>before</code>
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli &gt; env &gt; project &gt; user &gt;
+global), so a higher-priority source can always relax or override a
+lower-priority one.</p>
 <h4 id="min-release-age"><code>min-release-age</code></h4>
 <ul>
 <li>Default: null</li>
@@ -440,8 +444,11 @@ <h4 id="min-release-age"><code>min-release-age</code></h4>
 are no versions available for the current set of dependencies, the command
 will error.</p>
 <p>This flag is a complement to <code>before</code>, which accepts an exact date instead
-of a relative number of days.</p>
-<p>This config cannot be used with: <code>before</code></p>
+of a relative number of days. The two may coexist (e.g. <code>min-release-age</code> in
+your <code>.npmrc</code> is preserved when npm internally spawns a sub-process with
+<code>--before</code> while preparing a <code>git:</code> or <code>github:</code> dependency); when both
+apply, <code>before</code> wins within a single source and across sources the standard
+precedence rules apply.</p>
 <p>This value is not exported to the environment for child processes.</p>
 <h4 id="bin-links"><code>bin-links</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/commands/npm-version.html b/deps/npm/docs/output/commands/npm-version.html
index f80e5161e98b82..03468cb82e91b8 100644
--- a/deps/npm/docs/output/commands/npm-version.html
+++ b/deps/npm/docs/output/commands/npm-version.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-version----11130">
+<h1 id="----npm-version----11150">
     <span>npm-version</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Bump a package version</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-view.html b/deps/npm/docs/output/commands/npm-view.html
index 2636be46817ead..2943db55d7643f 100644
--- a/deps/npm/docs/output/commands/npm-view.html
+++ b/deps/npm/docs/output/commands/npm-view.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-view----11130">
+<h1 id="----npm-view----11150">
     <span>npm-view</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">View registry info</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm-whoami.html b/deps/npm/docs/output/commands/npm-whoami.html
index 2b456c4450622d..f18819e8cc4586 100644
--- a/deps/npm/docs/output/commands/npm-whoami.html
+++ b/deps/npm/docs/output/commands/npm-whoami.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-whoami----11130">
+<h1 id="----npm-whoami----11150">
     <span>npm-whoami</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Display npm username</span>
 </header>
diff --git a/deps/npm/docs/output/commands/npm.html b/deps/npm/docs/output/commands/npm.html
index d9807c608a8289..9f0ceff2c5fea1 100644
--- a/deps/npm/docs/output/commands/npm.html
+++ b/deps/npm/docs/output/commands/npm.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm----11130">
+<h1 id="----npm----11150">
     <span>npm</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">javascript package manager</span>
 </header>
@@ -203,7 +203,7 @@ <h2 id="table-of-contents">Table of contents</h2>
 </code></pre>
 <p>Note: This command is unaware of workspaces.</p>
 <h3 id="version">Version</h3>
-<p>11.13.0</p>
+<p>11.15.0</p>
 <h3 id="description">Description</h3>
 <p>npm is the package manager for the Node JavaScript platform.
 It puts modules in place so that node can find them, and manages dependency conflicts intelligently.</p>
diff --git a/deps/npm/docs/output/commands/npx.html b/deps/npm/docs/output/commands/npx.html
index ce14ad68a0a9a9..de7bab625b3800 100644
--- a/deps/npm/docs/output/commands/npx.html
+++ b/deps/npm/docs/output/commands/npx.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npx----11130">
+<h1 id="----npx----11150">
     <span>npx</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Run a command from a local or remote npm package</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/folders.html b/deps/npm/docs/output/configuring-npm/folders.html
index 2ebf3eb7ee4ea0..ead948bfa7a22e 100644
--- a/deps/npm/docs/output/configuring-npm/folders.html
+++ b/deps/npm/docs/output/configuring-npm/folders.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----folders----11130">
+<h1 id="----folders----11150">
     <span>Folders</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Folder structures used by npm</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/install.html b/deps/npm/docs/output/configuring-npm/install.html
index 1c928d1e45ad9b..af9419e0f8496c 100644
--- a/deps/npm/docs/output/configuring-npm/install.html
+++ b/deps/npm/docs/output/configuring-npm/install.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----install----11130">
+<h1 id="----install----11150">
     <span>Install</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Download and install node and npm</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/npm-global.html b/deps/npm/docs/output/configuring-npm/npm-global.html
index 2ebf3eb7ee4ea0..ead948bfa7a22e 100644
--- a/deps/npm/docs/output/configuring-npm/npm-global.html
+++ b/deps/npm/docs/output/configuring-npm/npm-global.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----folders----11130">
+<h1 id="----folders----11150">
     <span>Folders</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Folder structures used by npm</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/npm-json.html b/deps/npm/docs/output/configuring-npm/npm-json.html
index b7b4f7545043b0..05565040705356 100644
--- a/deps/npm/docs/output/configuring-npm/npm-json.html
+++ b/deps/npm/docs/output/configuring-npm/npm-json.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----packagejson----11130">
+<h1 id="----packagejson----11150">
     <span>package.json</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Specifics of npm's package.json handling</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html
index 5205dd37e7dbae..740e79a65e15f0 100644
--- a/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html
+++ b/deps/npm/docs/output/configuring-npm/npm-shrinkwrap-json.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npm-shrinkwrapjson----11130">
+<h1 id="----npm-shrinkwrapjson----11150">
     <span>npm-shrinkwrap.json</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">A publishable lockfile</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/npmrc.html b/deps/npm/docs/output/configuring-npm/npmrc.html
index 0980887d978241..76eca4327e8c69 100644
--- a/deps/npm/docs/output/configuring-npm/npmrc.html
+++ b/deps/npm/docs/output/configuring-npm/npmrc.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----npmrc----11130">
+<h1 id="----npmrc----11150">
     <span>.npmrc</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">The npm config files</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/package-json.html b/deps/npm/docs/output/configuring-npm/package-json.html
index b7b4f7545043b0..05565040705356 100644
--- a/deps/npm/docs/output/configuring-npm/package-json.html
+++ b/deps/npm/docs/output/configuring-npm/package-json.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----packagejson----11130">
+<h1 id="----packagejson----11150">
     <span>package.json</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Specifics of npm's package.json handling</span>
 </header>
diff --git a/deps/npm/docs/output/configuring-npm/package-lock-json.html b/deps/npm/docs/output/configuring-npm/package-lock-json.html
index 9cefaff6c908e1..63c60f97b4c5ab 100644
--- a/deps/npm/docs/output/configuring-npm/package-lock-json.html
+++ b/deps/npm/docs/output/configuring-npm/package-lock-json.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----package-lockjson----11130">
+<h1 id="----package-lockjson----11150">
     <span>package-lock.json</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">A manifestation of the manifest</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/config.html b/deps/npm/docs/output/using-npm/config.html
index 83655e009e7117..364b56910260da 100644
--- a/deps/npm/docs/output/using-npm/config.html
+++ b/deps/npm/docs/output/using-npm/config.html
@@ -186,16 +186,16 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----config----11130">
+<h1 id="----config----11150">
     <span>Config</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">About npm configuration</span>
 </header>
 
 <section id="table_of_contents">
 <h2 id="table-of-contents">Table of contents</h2>
-<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><ul><li><a href="#command-line-flags">Command Line Flags</a></li><li><a href="#environment-variables">Environment Variables</a></li><li><a href="#npmrc-files">npmrc Files</a></li><li><a href="#default-configs">Default Configs</a></li></ul><li><a href="#shorthands-and-other-cli-niceties">Shorthands and Other CLI Niceties</a></li><li><a href="#config-settings">Config Settings</a></li><ul><li><a href="#auth"><code>_auth</code></a></li><li><a href="#access"><code>access</code></a></li><li><a href="#all"><code>all</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-same-version"><code>allow-same-version</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#audit-level"><code>audit-level</code></a></li><li><a href="#auth-type"><code>auth-type</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#browser"><code>browser</code></a></li><li><a href="#bypass-2fa"><code>bypass-2fa</code></a></li><li><a href="#ca"><code>ca</code></a></li><li><a href="#cache"><code>cache</code></a></li><li><a href="#cafile"><code>cafile</code></a></li><li><a href="#call"><code>call</code></a></li><li><a href="#cidr"><code>cidr</code></a></li><li><a href="#color"><code>color</code></a></li><li><a href="#commit-hooks"><code>commit-hooks</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#depth"><code>depth</code></a></li><li><a href="#description2"><code>description</code></a></li><li><a href="#diff"><code>diff</code></a></li><li><a href="#diff-dst-prefix"><code>diff-dst-prefix</code></a></li><li><a href="#diff-ignore-all-space"><code>diff-ignore-all-space</code></a></li><li><a href="#diff-name-only"><code>diff-name-only</code></a></li><li><a href="#diff-no-prefix"><code>diff-no-prefix</code></a></li><li><a href="#diff-src-prefix"><code>diff-src-prefix</code></a></li><li><a href="#diff-text"><code>diff-text</code></a></li><li><a href="#diff-unified"><code>diff-unified</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#editor"><code>editor</code></a></li><li><a href="#engine-strict"><code>engine-strict</code></a></li><li><a href="#expect-result-count"><code>expect-result-count</code></a></li><li><a href="#expect-results"><code>expect-results</code></a></li><li><a href="#expires"><code>expires</code></a></li><li><a href="#fetch-retries"><code>fetch-retries</code></a></li><li><a href="#fetch-retry-factor"><code>fetch-retry-factor</code></a></li><li><a href="#fetch-retry-maxtimeout"><code>fetch-retry-maxtimeout</code></a></li><li><a href="#fetch-retry-mintimeout"><code>fetch-retry-mintimeout</code></a></li><li><a href="#fetch-timeout"><code>fetch-timeout</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#format-package-lock"><code>format-package-lock</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#git"><code>git</code></a></li><li><a href="#git-tag-version"><code>git-tag-version</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#globalconfig"><code>globalconfig</code></a></li><li><a href="#heading"><code>heading</code></a></li><li><a href="#https-proxy"><code>https-proxy</code></a></li><li><a href="#if-present"><code>if-present</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#include-attestations"><code>include-attestations</code></a></li><li><a href="#include-staged"><code>include-staged</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#init-author-email"><code>init-author-email</code></a></li><li><a href="#init-author-name"><code>init-author-name</code></a></li><li><a href="#init-author-url"><code>init-author-url</code></a></li><li><a href="#init-license"><code>init-license</code></a></li><li><a href="#init-module"><code>init-module</code></a></li><li><a href="#init-private"><code>init-private</code></a></li><li><a href="#init-type"><code>init-type</code></a></li><li><a href="#init-version"><code>init-version</code></a></li><li><a href="#install-links"><code>install-links</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#legacy-peer-deps"><code>legacy-peer-deps</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#link"><code>link</code></a></li><li><a href="#local-address"><code>local-address</code></a></li><li><a href="#location"><code>location</code></a></li><li><a href="#lockfile-version"><code>lockfile-version</code></a></li><li><a href="#loglevel"><code>loglevel</code></a></li><li><a href="#logs-dir"><code>logs-dir</code></a></li><li><a href="#logs-max"><code>logs-max</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#maxsockets"><code>maxsockets</code></a></li><li><a href="#message"><code>message</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#name"><code>name</code></a></li><li><a href="#node-gyp"><code>node-gyp</code></a></li><li><a href="#node-options"><code>node-options</code></a></li><li><a href="#noproxy"><code>noproxy</code></a></li><li><a href="#offline"><code>offline</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#omit-lockfile-registry-resolved"><code>omit-lockfile-registry-resolved</code></a></li><li><a href="#orgs"><code>orgs</code></a></li><li><a href="#orgs-permission"><code>orgs-permission</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#pack-destination"><code>pack-destination</code></a></li><li><a href="#package"><code>package</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#packages"><code>packages</code></a></li><li><a href="#packages-all"><code>packages-all</code></a></li><li><a href="#packages-and-scopes-permission"><code>packages-and-scopes-permission</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#password"><code>password</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#prefer-offline"><code>prefer-offline</code></a></li><li><a href="#prefer-online"><code>prefer-online</code></a></li><li><a href="#prefix"><code>prefix</code></a></li><li><a href="#preid"><code>preid</code></a></li><li><a href="#progress"><code>progress</code></a></li><li><a href="#provenance"><code>provenance</code></a></li><li><a href="#provenance-file"><code>provenance-file</code></a></li><li><a href="#proxy"><code>proxy</code></a></li><li><a href="#read-only"><code>read-only</code></a></li><li><a href="#rebuild-bundle"><code>rebuild-bundle</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#replace-registry-host"><code>replace-registry-host</code></a></li><li><a href="#save"><code>save</code></a></li><li><a href="#save-bundle"><code>save-bundle</code></a></li><li><a href="#save-dev"><code>save-dev</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#save-optional"><code>save-optional</code></a></li><li><a href="#save-peer"><code>save-peer</code></a></li><li><a href="#save-prefix"><code>save-prefix</code></a></li><li><a href="#save-prod"><code>save-prod</code></a></li><li><a href="#sbom-format"><code>sbom-format</code></a></li><li><a href="#sbom-type"><code>sbom-type</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#scopes"><code>scopes</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li><li><a href="#searchexclude"><code>searchexclude</code></a></li><li><a href="#searchlimit"><code>searchlimit</code></a></li><li><a href="#searchopts"><code>searchopts</code></a></li><li><a href="#searchstaleness"><code>searchstaleness</code></a></li><li><a href="#shell"><code>shell</code></a></li><li><a href="#sign-git-commit"><code>sign-git-commit</code></a></li><li><a href="#sign-git-tag"><code>sign-git-tag</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#strict-ssl"><code>strict-ssl</code></a></li><li><a href="#tag"><code>tag</code></a></li><li><a href="#tag-version-prefix"><code>tag-version-prefix</code></a></li><li><a href="#timing"><code>timing</code></a></li><li><a href="#token-description"><code>token-description</code></a></li><li><a href="#umask"><code>umask</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#update-notifier"><code>update-notifier</code></a></li><li><a href="#usage"><code>usage</code></a></li><li><a href="#user-agent"><code>user-agent</code></a></li><li><a href="#userconfig"><code>userconfig</code></a></li><li><a href="#version"><code>version</code></a></li><li><a href="#versions"><code>versions</code></a></li><li><a href="#viewer"><code>viewer</code></a></li><li><a href="#which"><code>which</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#workspaces-update"><code>workspaces-update</code></a></li><li><a href="#yes"><code>yes</code></a></li><li><a href="#also"><code>also</code></a></li><li><a href="#cache-max"><code>cache-max</code></a></li><li><a href="#cache-min"><code>cache-min</code></a></li><li><a href="#cert"><code>cert</code></a></li><li><a href="#dev"><code>dev</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#initauthoremail"><code>init.author.email</code></a></li><li><a href="#initauthorname"><code>init.author.name</code></a></li><li><a href="#initauthorurl"><code>init.author.url</code></a></li><li><a href="#initlicense"><code>init.license</code></a></li><li><a href="#initmodule"><code>init.module</code></a></li><li><a href="#initversion"><code>init.version</code></a></li><li><a href="#key"><code>key</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#only"><code>only</code></a></li><li><a href="#optional"><code>optional</code></a></li><li><a href="#production"><code>production</code></a></li><li><a href="#shrinkwrap"><code>shrinkwrap</code></a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
+<div id="_table_of_contents"><ul><li><a href="#description">Description</a></li><ul><li><a href="#command-line-flags">Command Line Flags</a></li><li><a href="#environment-variables">Environment Variables</a></li><li><a href="#npmrc-files">npmrc Files</a></li><li><a href="#default-configs">Default Configs</a></li></ul><li><a href="#shorthands-and-other-cli-niceties">Shorthands and Other CLI Niceties</a></li><li><a href="#config-settings">Config Settings</a></li><ul><li><a href="#auth"><code>_auth</code></a></li><li><a href="#access"><code>access</code></a></li><li><a href="#all"><code>all</code></a></li><li><a href="#allow-directory"><code>allow-directory</code></a></li><li><a href="#allow-file"><code>allow-file</code></a></li><li><a href="#allow-git"><code>allow-git</code></a></li><li><a href="#allow-remote"><code>allow-remote</code></a></li><li><a href="#allow-same-version"><code>allow-same-version</code></a></li><li><a href="#audit"><code>audit</code></a></li><li><a href="#audit-level"><code>audit-level</code></a></li><li><a href="#auth-type"><code>auth-type</code></a></li><li><a href="#before"><code>before</code></a></li><li><a href="#bin-links"><code>bin-links</code></a></li><li><a href="#browser"><code>browser</code></a></li><li><a href="#bypass-2fa"><code>bypass-2fa</code></a></li><li><a href="#ca"><code>ca</code></a></li><li><a href="#cache"><code>cache</code></a></li><li><a href="#cafile"><code>cafile</code></a></li><li><a href="#call"><code>call</code></a></li><li><a href="#cidr"><code>cidr</code></a></li><li><a href="#color"><code>color</code></a></li><li><a href="#commit-hooks"><code>commit-hooks</code></a></li><li><a href="#cpu"><code>cpu</code></a></li><li><a href="#depth"><code>depth</code></a></li><li><a href="#description2"><code>description</code></a></li><li><a href="#diff"><code>diff</code></a></li><li><a href="#diff-dst-prefix"><code>diff-dst-prefix</code></a></li><li><a href="#diff-ignore-all-space"><code>diff-ignore-all-space</code></a></li><li><a href="#diff-name-only"><code>diff-name-only</code></a></li><li><a href="#diff-no-prefix"><code>diff-no-prefix</code></a></li><li><a href="#diff-src-prefix"><code>diff-src-prefix</code></a></li><li><a href="#diff-text"><code>diff-text</code></a></li><li><a href="#diff-unified"><code>diff-unified</code></a></li><li><a href="#dry-run"><code>dry-run</code></a></li><li><a href="#editor"><code>editor</code></a></li><li><a href="#engine-strict"><code>engine-strict</code></a></li><li><a href="#expect-result-count"><code>expect-result-count</code></a></li><li><a href="#expect-results"><code>expect-results</code></a></li><li><a href="#expires"><code>expires</code></a></li><li><a href="#fetch-retries"><code>fetch-retries</code></a></li><li><a href="#fetch-retry-factor"><code>fetch-retry-factor</code></a></li><li><a href="#fetch-retry-maxtimeout"><code>fetch-retry-maxtimeout</code></a></li><li><a href="#fetch-retry-mintimeout"><code>fetch-retry-mintimeout</code></a></li><li><a href="#fetch-timeout"><code>fetch-timeout</code></a></li><li><a href="#force"><code>force</code></a></li><li><a href="#foreground-scripts"><code>foreground-scripts</code></a></li><li><a href="#format-package-lock"><code>format-package-lock</code></a></li><li><a href="#fund"><code>fund</code></a></li><li><a href="#git"><code>git</code></a></li><li><a href="#git-tag-version"><code>git-tag-version</code></a></li><li><a href="#global"><code>global</code></a></li><li><a href="#globalconfig"><code>globalconfig</code></a></li><li><a href="#heading"><code>heading</code></a></li><li><a href="#https-proxy"><code>https-proxy</code></a></li><li><a href="#if-present"><code>if-present</code></a></li><li><a href="#ignore-scripts"><code>ignore-scripts</code></a></li><li><a href="#include"><code>include</code></a></li><li><a href="#include-attestations"><code>include-attestations</code></a></li><li><a href="#include-staged"><code>include-staged</code></a></li><li><a href="#include-workspace-root"><code>include-workspace-root</code></a></li><li><a href="#init-author-email"><code>init-author-email</code></a></li><li><a href="#init-author-name"><code>init-author-name</code></a></li><li><a href="#init-author-url"><code>init-author-url</code></a></li><li><a href="#init-license"><code>init-license</code></a></li><li><a href="#init-module"><code>init-module</code></a></li><li><a href="#init-private"><code>init-private</code></a></li><li><a href="#init-type"><code>init-type</code></a></li><li><a href="#init-version"><code>init-version</code></a></li><li><a href="#install-links"><code>install-links</code></a></li><li><a href="#install-strategy"><code>install-strategy</code></a></li><li><a href="#json"><code>json</code></a></li><li><a href="#legacy-peer-deps"><code>legacy-peer-deps</code></a></li><li><a href="#libc"><code>libc</code></a></li><li><a href="#link"><code>link</code></a></li><li><a href="#local-address"><code>local-address</code></a></li><li><a href="#location"><code>location</code></a></li><li><a href="#lockfile-version"><code>lockfile-version</code></a></li><li><a href="#loglevel"><code>loglevel</code></a></li><li><a href="#logs-dir"><code>logs-dir</code></a></li><li><a href="#logs-max"><code>logs-max</code></a></li><li><a href="#long"><code>long</code></a></li><li><a href="#maxsockets"><code>maxsockets</code></a></li><li><a href="#message"><code>message</code></a></li><li><a href="#min-release-age"><code>min-release-age</code></a></li><li><a href="#name"><code>name</code></a></li><li><a href="#node-gyp"><code>node-gyp</code></a></li><li><a href="#node-options"><code>node-options</code></a></li><li><a href="#noproxy"><code>noproxy</code></a></li><li><a href="#offline"><code>offline</code></a></li><li><a href="#omit"><code>omit</code></a></li><li><a href="#omit-lockfile-registry-resolved"><code>omit-lockfile-registry-resolved</code></a></li><li><a href="#orgs"><code>orgs</code></a></li><li><a href="#orgs-permission"><code>orgs-permission</code></a></li><li><a href="#os"><code>os</code></a></li><li><a href="#otp"><code>otp</code></a></li><li><a href="#pack-destination"><code>pack-destination</code></a></li><li><a href="#package"><code>package</code></a></li><li><a href="#package-lock"><code>package-lock</code></a></li><li><a href="#package-lock-only"><code>package-lock-only</code></a></li><li><a href="#packages"><code>packages</code></a></li><li><a href="#packages-all"><code>packages-all</code></a></li><li><a href="#packages-and-scopes-permission"><code>packages-and-scopes-permission</code></a></li><li><a href="#parseable"><code>parseable</code></a></li><li><a href="#password"><code>password</code></a></li><li><a href="#prefer-dedupe"><code>prefer-dedupe</code></a></li><li><a href="#prefer-offline"><code>prefer-offline</code></a></li><li><a href="#prefer-online"><code>prefer-online</code></a></li><li><a href="#prefix"><code>prefix</code></a></li><li><a href="#preid"><code>preid</code></a></li><li><a href="#progress"><code>progress</code></a></li><li><a href="#provenance"><code>provenance</code></a></li><li><a href="#provenance-file"><code>provenance-file</code></a></li><li><a href="#proxy"><code>proxy</code></a></li><li><a href="#read-only"><code>read-only</code></a></li><li><a href="#rebuild-bundle"><code>rebuild-bundle</code></a></li><li><a href="#registry"><code>registry</code></a></li><li><a href="#replace-registry-host"><code>replace-registry-host</code></a></li><li><a href="#save"><code>save</code></a></li><li><a href="#save-bundle"><code>save-bundle</code></a></li><li><a href="#save-dev"><code>save-dev</code></a></li><li><a href="#save-exact"><code>save-exact</code></a></li><li><a href="#save-optional"><code>save-optional</code></a></li><li><a href="#save-peer"><code>save-peer</code></a></li><li><a href="#save-prefix"><code>save-prefix</code></a></li><li><a href="#save-prod"><code>save-prod</code></a></li><li><a href="#sbom-format"><code>sbom-format</code></a></li><li><a href="#sbom-type"><code>sbom-type</code></a></li><li><a href="#scope"><code>scope</code></a></li><li><a href="#scopes"><code>scopes</code></a></li><li><a href="#script-shell"><code>script-shell</code></a></li><li><a href="#searchexclude"><code>searchexclude</code></a></li><li><a href="#searchlimit"><code>searchlimit</code></a></li><li><a href="#searchopts"><code>searchopts</code></a></li><li><a href="#searchstaleness"><code>searchstaleness</code></a></li><li><a href="#shell"><code>shell</code></a></li><li><a href="#sign-git-commit"><code>sign-git-commit</code></a></li><li><a href="#sign-git-tag"><code>sign-git-tag</code></a></li><li><a href="#strict-peer-deps"><code>strict-peer-deps</code></a></li><li><a href="#strict-ssl"><code>strict-ssl</code></a></li><li><a href="#tag"><code>tag</code></a></li><li><a href="#tag-version-prefix"><code>tag-version-prefix</code></a></li><li><a href="#timing"><code>timing</code></a></li><li><a href="#token-description"><code>token-description</code></a></li><li><a href="#umask"><code>umask</code></a></li><li><a href="#unicode"><code>unicode</code></a></li><li><a href="#update-notifier"><code>update-notifier</code></a></li><li><a href="#usage"><code>usage</code></a></li><li><a href="#user-agent"><code>user-agent</code></a></li><li><a href="#userconfig"><code>userconfig</code></a></li><li><a href="#version"><code>version</code></a></li><li><a href="#versions"><code>versions</code></a></li><li><a href="#viewer"><code>viewer</code></a></li><li><a href="#which"><code>which</code></a></li><li><a href="#workspace"><code>workspace</code></a></li><li><a href="#workspaces"><code>workspaces</code></a></li><li><a href="#workspaces-update"><code>workspaces-update</code></a></li><li><a href="#yes"><code>yes</code></a></li><li><a href="#also"><code>also</code></a></li><li><a href="#cache-max"><code>cache-max</code></a></li><li><a href="#cache-min"><code>cache-min</code></a></li><li><a href="#cert"><code>cert</code></a></li><li><a href="#dev"><code>dev</code></a></li><li><a href="#global-style"><code>global-style</code></a></li><li><a href="#initauthoremail"><code>init.author.email</code></a></li><li><a href="#initauthorname"><code>init.author.name</code></a></li><li><a href="#initauthorurl"><code>init.author.url</code></a></li><li><a href="#initlicense"><code>init.license</code></a></li><li><a href="#initmodule"><code>init.module</code></a></li><li><a href="#initversion"><code>init.version</code></a></li><li><a href="#key"><code>key</code></a></li><li><a href="#legacy-bundling"><code>legacy-bundling</code></a></li><li><a href="#only"><code>only</code></a></li><li><a href="#optional"><code>optional</code></a></li><li><a href="#production"><code>production</code></a></li><li><a href="#shrinkwrap"><code>shrinkwrap</code></a></li></ul><li><a href="#see-also">See also</a></li></ul></div>
 </section>
 
 <div id="_content"><h3 id="description">Description</h3>
@@ -323,6 +323,34 @@ <h4 id="all"><code>all</code></h4>
 <p>When running <code>npm outdated</code> and <code>npm ls</code>, setting <code>--all</code> will show all
 outdated or installed packages, rather than only those directly depended
 upon by the current project.</p>
+<h4 id="allow-directory"><code>allow-directory</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any directories to be installed. <code>none</code> prevents any
+directories from being installed. <code>root</code> only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like <code>npm view</code></p>
+<h4 id="allow-file"><code>allow-file</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any tarball file to be installed. <code>none</code> prevents any tarball
+file from being installed. <code>root</code> only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like <code>npm view</code></p>
 <h4 id="allow-git"><code>allow-git</code></h4>
 <ul>
 <li>Default: "all"</li>
@@ -331,11 +359,26 @@ <h4 id="allow-git"><code>allow-git</code></h4>
 <p>Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.</p>
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
 <p><code>all</code> allows any git dependencies to be fetched and installed. <code>none</code>
 prevents any git dependencies from being fetched and installed. <code>root</code> only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like <code>npm view</code></p>
+<h4 id="allow-remote"><code>allow-remote</code></h4>
+<ul>
+<li>Default: "all"</li>
+<li>Type: "all", "none", or "root"</li>
+</ul>
+<p>Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.</p>
+<p><code>all</code> allows any url to be installed. <code>none</code> prevents any url from being
+installed. <code>root</code> only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like <code>npm view</code></p>
 <h4 id="allow-same-version"><code>allow-same-version</code></h4>
 <ul>
@@ -380,7 +423,11 @@ <h4 id="before"><code>before</code></h4>
 <code>--before</code> filter, the most recent version less than or equal to that tag
 will be used. For example, <code>foo@latest</code> might install <code>foo@1.2</code> even though
 <code>latest</code> is <code>2.0</code>.</p>
-<p>This config cannot be used with: <code>min-release-age</code></p>
+<p>If <code>before</code> and <code>min-release-age</code> are both set in the same source, <code>before</code>
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli &gt; env &gt; project &gt; user &gt;
+global), so a higher-priority source can always relax or override a
+lower-priority one.</p>
 <h4 id="bin-links"><code>bin-links</code></h4>
 <ul>
 <li>Default: true</li>
@@ -990,8 +1037,11 @@ <h4 id="min-release-age"><code>min-release-age</code></h4>
 are no versions available for the current set of dependencies, the command
 will error.</p>
 <p>This flag is a complement to <code>before</code>, which accepts an exact date instead
-of a relative number of days.</p>
-<p>This config cannot be used with: <code>before</code></p>
+of a relative number of days. The two may coexist (e.g. <code>min-release-age</code> in
+your <code>.npmrc</code> is preserved when npm internally spawns a sub-process with
+<code>--before</code> while preparing a <code>git:</code> or <code>github:</code> dependency); when both
+apply, <code>before</code> wins within a single source and across sources the standard
+precedence rules apply.</p>
 <p>This value is not exported to the environment for child processes.</p>
 <h4 id="name"><code>name</code></h4>
 <ul>
diff --git a/deps/npm/docs/output/using-npm/dependency-selectors.html b/deps/npm/docs/output/using-npm/dependency-selectors.html
index 35ad12b72bacd2..f624240e2ce4b1 100644
--- a/deps/npm/docs/output/using-npm/dependency-selectors.html
+++ b/deps/npm/docs/output/using-npm/dependency-selectors.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----dependency-selectors----11130">
+<h1 id="----dependency-selectors----11150">
     <span>Dependency Selectors</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Dependency Selector Syntax &amp; Querying</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/developers.html b/deps/npm/docs/output/using-npm/developers.html
index 45ef5924245796..d9e4e3aff91678 100644
--- a/deps/npm/docs/output/using-npm/developers.html
+++ b/deps/npm/docs/output/using-npm/developers.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----developers----11130">
+<h1 id="----developers----11150">
     <span>Developers</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Developer guide</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/logging.html b/deps/npm/docs/output/using-npm/logging.html
index c34d3d7c8f32fd..075cc73a67a09f 100644
--- a/deps/npm/docs/output/using-npm/logging.html
+++ b/deps/npm/docs/output/using-npm/logging.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----logging----11130">
+<h1 id="----logging----11150">
     <span>Logging</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Why, What &amp; How we Log</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/orgs.html b/deps/npm/docs/output/using-npm/orgs.html
index 7beb2e2cd5e0c2..53ae0de316be80 100644
--- a/deps/npm/docs/output/using-npm/orgs.html
+++ b/deps/npm/docs/output/using-npm/orgs.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----organizations----11130">
+<h1 id="----organizations----11150">
     <span>Organizations</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Working with teams &amp; organizations</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/package-spec.html b/deps/npm/docs/output/using-npm/package-spec.html
index e75963512474ca..7124466377618f 100644
--- a/deps/npm/docs/output/using-npm/package-spec.html
+++ b/deps/npm/docs/output/using-npm/package-spec.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----package-spec----11130">
+<h1 id="----package-spec----11150">
     <span>Package spec</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Package name specifier</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/registry.html b/deps/npm/docs/output/using-npm/registry.html
index 54d3618031c5c3..71cea945e1251b 100644
--- a/deps/npm/docs/output/using-npm/registry.html
+++ b/deps/npm/docs/output/using-npm/registry.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----registry----11130">
+<h1 id="----registry----11150">
     <span>Registry</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">The JavaScript Package Registry</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/removal.html b/deps/npm/docs/output/using-npm/removal.html
index 068f758e2e872f..a4ec8e6adb23ab 100644
--- a/deps/npm/docs/output/using-npm/removal.html
+++ b/deps/npm/docs/output/using-npm/removal.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----removal----11130">
+<h1 id="----removal----11150">
     <span>Removal</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Cleaning the slate</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/scope.html b/deps/npm/docs/output/using-npm/scope.html
index 26a0718f94a470..f0dee65b1afa0b 100644
--- a/deps/npm/docs/output/using-npm/scope.html
+++ b/deps/npm/docs/output/using-npm/scope.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----scope----11130">
+<h1 id="----scope----11150">
     <span>Scope</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Scoped packages</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/scripts.html b/deps/npm/docs/output/using-npm/scripts.html
index dc8aed1c724c2c..8c2de4a8c1fdc5 100644
--- a/deps/npm/docs/output/using-npm/scripts.html
+++ b/deps/npm/docs/output/using-npm/scripts.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----scripts----11130">
+<h1 id="----scripts----11150">
     <span>Scripts</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">How npm handles the "scripts" field</span>
 </header>
diff --git a/deps/npm/docs/output/using-npm/workspaces.html b/deps/npm/docs/output/using-npm/workspaces.html
index af84abf262b3db..3b0b1090bf8620 100644
--- a/deps/npm/docs/output/using-npm/workspaces.html
+++ b/deps/npm/docs/output/using-npm/workspaces.html
@@ -186,9 +186,9 @@
 
 <section id="content">
 <header class="title">
-<h1 id="----workspaces----11130">
+<h1 id="----workspaces----11150">
     <span>Workspaces</span>
-    <span class="version">@11.13.0</span>
+    <span class="version">@11.15.0</span>
 </h1>
 <span class="description">Working with workspaces</span>
 </header>
diff --git a/deps/npm/lib/commands/ci.js b/deps/npm/lib/commands/ci.js
index f6c97aea30f70a..354d68ad7adffd 100644
--- a/deps/npm/lib/commands/ci.js
+++ b/deps/npm/lib/commands/ci.js
@@ -21,7 +21,10 @@ class CI extends ArboristWorkspaceCmd {
     'strict-peer-deps',
     'foreground-scripts',
     'ignore-scripts',
+    'allow-directory',
+    'allow-file',
     'allow-git',
+    'allow-remote',
     'audit',
     'bin-links',
     'fund',
diff --git a/deps/npm/lib/commands/dedupe.js b/deps/npm/lib/commands/dedupe.js
index a931cabd646043..347031b60a78a6 100644
--- a/deps/npm/lib/commands/dedupe.js
+++ b/deps/npm/lib/commands/dedupe.js
@@ -14,7 +14,10 @@ class Dedupe extends ArboristWorkspaceCmd {
     'omit',
     'include',
     'ignore-scripts',
+    'allow-directory',
+    'allow-file',
     'allow-git',
+    'allow-remote',
     'audit',
     'bin-links',
     'fund',
diff --git a/deps/npm/lib/commands/install.js b/deps/npm/lib/commands/install.js
index 5970fddfdfe4fa..287b585f132313 100644
--- a/deps/npm/lib/commands/install.js
+++ b/deps/npm/lib/commands/install.js
@@ -27,7 +27,10 @@ class Install extends ArboristWorkspaceCmd {
     'package-lock-only',
     'foreground-scripts',
     'ignore-scripts',
+    'allow-directory',
+    'allow-file',
     'allow-git',
+    'allow-remote',
     'audit',
     'before',
     'min-release-age',
diff --git a/deps/npm/lib/commands/link.js b/deps/npm/lib/commands/link.js
index e166a0051299a7..ca656ad18f5ca0 100644
--- a/deps/npm/lib/commands/link.js
+++ b/deps/npm/lib/commands/link.js
@@ -25,7 +25,10 @@ class Link extends ArboristWorkspaceCmd {
     'omit',
     'include',
     'ignore-scripts',
+    'allow-directory',
+    'allow-file',
     'allow-git',
+    'allow-remote',
     'audit',
     'bin-links',
     'fund',
diff --git a/deps/npm/lib/commands/outdated.js b/deps/npm/lib/commands/outdated.js
index 9140cdbc9fea51..882ad2cc9d28a2 100644
--- a/deps/npm/lib/commands/outdated.js
+++ b/deps/npm/lib/commands/outdated.js
@@ -31,6 +31,7 @@ class Outdated extends ArboristWorkspaceCmd {
     'global',
     'workspace',
     'before',
+    'min-release-age',
   ]
 
   #tree
diff --git a/deps/npm/lib/commands/publish.js b/deps/npm/lib/commands/publish.js
index 98478ae1e95f1d..854633e1d29e08 100644
--- a/deps/npm/lib/commands/publish.js
+++ b/deps/npm/lib/commands/publish.js
@@ -1,4 +1,4 @@
-const { log, output } = require('proc-log')
+const { log, output, META } = require('proc-log')
 const semver = require('semver')
 const pack = require('libnpmpack')
 const libpub = require('libnpmpublish').publish
@@ -14,11 +14,17 @@ const { getContents, logTar } = require('../utils/tar.js')
 const { flatten } = require('@npmcli/config/lib/definitions')
 const pkgJson = require('@npmcli/package-json')
 const BaseCommand = require('../base-cmd.js')
-const { oidc } = require('../../lib/utils/oidc.js')
+const { oidc } = require('../utils/oidc.js')
 
 class Publish extends BaseCommand {
   static description = 'Publish a package'
   static name = 'publish'
+  static stage = false
+
+  get isStage () {
+    return this.constructor.stage
+  }
+
   static params = [
     'tag',
     'access',
@@ -60,13 +66,17 @@ class Publish extends BaseCommand {
         if (err.code !== 'EPRIVATE') {
           throw err
         }
-        log.warn('publish', `Skipping workspace ${this.npm.chalk.cyan(name)}, marked as ${this.npm.chalk.bold('private')}`)
+        log.warn(this.#command, `Skipping workspace ${this.npm.chalk.cyan(name)}, marked as ${this.npm.chalk.bold('private')}`)
       }
     }
   }
 
+  get #command () {
+    return this.isStage ? 'stage' : 'publish'
+  }
+
   async #publish (args, { workspace } = {}) {
-    log.verbose('publish', replaceInfo(args))
+    log.verbose(this.#command, replaceInfo(args))
 
     const unicode = this.npm.config.get('unicode')
     const dryRun = this.npm.config.get('dry-run')
@@ -138,7 +148,6 @@ class Publish extends BaseCommand {
     const noCreds = !(creds.token || creds.username || creds.certfile && creds.keyfile)
     const outputRegistry = replaceInfo(registry)
 
-    // if a workspace package is marked private then we skip it
     if (workspace && manifest.private) {
       throw Object.assign(
         new Error(`This package has been marked as private
@@ -150,7 +159,7 @@ class Publish extends BaseCommand {
     if (noCreds) {
       const msg = `This command requires you to be logged in to ${outputRegistry}`
       if (dryRun) {
-        log.warn('', `${msg} (dry-run)`)
+        log.warn(this.#command, `${msg} (dry-run)`)
       } else {
         throw Object.assign(new Error(msg), { code: 'ENEEDAUTH' })
       }
@@ -171,20 +180,36 @@ class Publish extends BaseCommand {
     }
 
     const access = opts.access === null ? 'default' : opts.access
-    let msg = `Publishing to ${outputRegistry} with tag ${defaultTag} and ${access} access`
+    const verb = this.isStage ? 'Staging' : 'Publishing'
+    let msg = `${verb} to ${outputRegistry} with tag ${defaultTag} and ${access} access`
     if (dryRun) {
       msg = `${msg} (dry-run)`
     }
 
     log.notice('', msg)
 
+    let stageId
     if (!dryRun) {
-      await otplease(this.npm, opts, o => libpub(manifest, tarballData, o))
+      if (this.isStage) {
+        // Stage intentionally bypasses otplease — 2FA is deferred to approve/reject
+        const res = await libpub(manifest, tarballData, {
+          ...opts,
+          command: this.#command,
+          stage: true,
+        })
+        stageId = res.stageId
+      } else {
+        await otplease(this.npm, opts, o => libpub(manifest, tarballData, o))
+      }
     }
 
     // In json mode we don't log until the publish has completed as this will add it to the output only if completes successfully
     if (json) {
-      logPkg()
+      if (stageId) {
+        pkgContents.stageId = stageId
+      }
+      logTar(pkgContents, {
+        unicode, json, key: pkgContents.name, redact: stageId ? false : undefined })
     }
 
     if (spec.type === 'directory' && !ignoreScripts) {
@@ -204,7 +229,15 @@ class Publish extends BaseCommand {
     }
 
     if (!json && !silent) {
-      output.standard(`+ ${pkgContents.id}`)
+      if (this.isStage) {
+        const stagedMsg = stageId
+          ? `+ ${pkgContents.id} (staged with id ${stageId})`
+          : `+ ${pkgContents.id} (staged)`
+        output.standard(stagedMsg, { [META]: true, redact: false })
+        log.notice(this.#command, `package ${pkgContents.id} has been staged with tag ${defaultTag}`)
+      } else {
+        output.standard(`+ ${pkgContents.id}`)
+      }
     }
   }
 
@@ -245,8 +278,8 @@ class Publish extends BaseCommand {
       const changes = []
       const pkg = await pkgJson.fix(spec.fetchSpec, { changes })
       if (changes.length && logWarnings) {
-        log.warn('publish', 'npm auto-corrected some errors in your package.json when publishing.  Please run "npm pkg fix" to address these errors.')
-        log.warn('publish', `errors corrected:\n${changes.join('\n')}`)
+        log.warn(this.#command, 'npm auto-corrected some errors in your package.json when publishing.  Please run "npm pkg fix" to address these errors.')
+        log.warn(this.#command, `errors corrected:\n${changes.join('\n')}`)
       }
       // Prepare is the special function for publishing, different than normalize
       const { content } = await pkg.prepare()
diff --git a/deps/npm/lib/commands/stage/approve.js b/deps/npm/lib/commands/stage/approve.js
new file mode 100644
index 00000000000000..619015d0c8a55e
--- /dev/null
+++ b/deps/npm/lib/commands/stage/approve.js
@@ -0,0 +1,35 @@
+const { log, output, META } = require('proc-log')
+const npmFetch = require('npm-registry-fetch')
+const { otplease } = require('../../utils/auth.js')
+const { validateUUID } = require('../../utils/validate-uuid.js')
+const BaseCommand = require('../../base-cmd.js')
+
+class StageApprove extends BaseCommand {
+  static description = 'Approve a staged package, publishing it to the npm registry'
+  static name = 'approve'
+  static usage = ['<stage-id>']
+  static params = ['otp', 'registry']
+  static positionals = 1
+
+  async exec (args) {
+    if (!args[0]) {
+      throw this.usageError('Missing required <stage-id>')
+    }
+    const stageId = args[0]
+    validateUUID(stageId, 'stage-id')
+    const opts = { ...this.npm.flatOptions }
+
+    log.notice('', `Approving staged package ${stageId}`)
+
+    await otplease(this.npm, opts, o =>
+      npmFetch.json(`/-/stage/${stageId}/approve`, {
+        ...o,
+        method: 'POST',
+      })
+    )
+
+    output.standard(`Staged package ${stageId} approved and published successfully.`, { [META]: true, redact: false })
+  }
+}
+
+module.exports = StageApprove
diff --git a/deps/npm/lib/commands/stage/download.js b/deps/npm/lib/commands/stage/download.js
new file mode 100644
index 00000000000000..e5b7711aee54d3
--- /dev/null
+++ b/deps/npm/lib/commands/stage/download.js
@@ -0,0 +1,70 @@
+const { log, output, META } = require('proc-log')
+const { writeFile } = require('node:fs/promises')
+const { resolve } = require('node:path')
+const tar = require('tar')
+const npmFetch = require('npm-registry-fetch')
+const { getContents, logTar } = require('../../utils/tar.js')
+const { validateUUID } = require('../../utils/validate-uuid.js')
+const BaseCommand = require('../../base-cmd.js')
+
+class StageDownload extends BaseCommand {
+  static description = 'Download the tarball of a staged package for inspection'
+  static name = 'download'
+  static usage = ['<stage-id>']
+  static params = ['json', 'registry']
+  static positionals = 1
+
+  async exec (args) {
+    if (!args[0]) {
+      throw this.usageError('Missing required <stage-id>')
+    }
+    const stageId = args[0]
+    validateUUID(stageId, 'stage-id')
+    const opts = { ...this.npm.flatOptions }
+    const unicode = this.npm.config.get('unicode')
+    const json = this.npm.config.get('json')
+
+    log.notice('', `Downloading staged package ${stageId}`)
+
+    const res = await npmFetch(`/-/stage/${stageId}/tarball`, opts)
+    const data = Buffer.from(await res.arrayBuffer())
+
+    const manifest = await this.#readManifestFromTarball(data)
+    const pkgContents = await getContents(manifest, data)
+    logTar(pkgContents, { unicode, json, key: pkgContents.name })
+
+    const safeName = pkgContents.name.replace('@', '').replace('/', '-')
+    const filename = `${safeName}-${pkgContents.version}-${stageId}.tgz`
+    const dest = resolve(process.cwd(), filename)
+
+    await writeFile(dest, data)
+    if (!json) {
+      output.standard(filename, { [META]: true, redact: false })
+    }
+  }
+
+  async #readManifestFromTarball (tarballData) {
+    let manifestJson
+    const stream = tar.t({
+      onentry (entry) {
+        if (entry.path === 'package/package.json') {
+          const chunks = []
+          entry.on('data', c => chunks.push(c))
+          entry.on('end', () => {
+            manifestJson = JSON.parse(Buffer.concat(chunks).toString())
+          })
+        } else {
+          entry.resume()
+        }
+      },
+    })
+    // node-tar uses Minipass which processes synchronously on .end()
+    stream.end(tarballData)
+    if (!manifestJson) {
+      throw new Error('Could not read package.json from tarball')
+    }
+    return manifestJson
+  }
+}
+
+module.exports = StageDownload
diff --git a/deps/npm/lib/commands/stage/index.js b/deps/npm/lib/commands/stage/index.js
new file mode 100644
index 00000000000000..51b41b4f0249d9
--- /dev/null
+++ b/deps/npm/lib/commands/stage/index.js
@@ -0,0 +1,25 @@
+const BaseCommand = require('../../base-cmd.js')
+
+class Stage extends BaseCommand {
+  static description = 'Stage packages for publishing, deferring proof-of-presence (2FA) to a later point in time'
+  static name = 'stage'
+
+  static subcommands = {
+    publish: require('./publish.js'),
+    list: require('./list.js'),
+    view: require('./view.js'),
+    approve: require('./approve.js'),
+    reject: require('./reject.js'),
+    download: require('./download.js'),
+  }
+
+  static async completion (opts) {
+    const argv = opts.conf.argv.remain
+    if (argv.length === 2) {
+      return Object.keys(Stage.subcommands)
+    }
+    return []
+  }
+}
+
+module.exports = Stage
diff --git a/deps/npm/lib/commands/stage/list.js b/deps/npm/lib/commands/stage/list.js
new file mode 100644
index 00000000000000..bcfb45affb00b0
--- /dev/null
+++ b/deps/npm/lib/commands/stage/list.js
@@ -0,0 +1,72 @@
+const { output, META } = require('proc-log')
+const npa = require('npm-package-arg')
+const npmFetch = require('npm-registry-fetch')
+const { logStageItem } = require('../../utils/key-values.js')
+const BaseCommand = require('../../base-cmd.js')
+
+class StageList extends BaseCommand {
+  static description = 'List all staged package versions'
+  static name = 'list'
+  static usage = ['[<package-spec>]']
+  static params = ['json', 'registry']
+
+  async exec (args) {
+    let packageFilter = null
+    if (args[0]) {
+      const spec = npa(args[0])
+      if (spec.rawSpec !== '*') {
+        throw this.usageError('Version specifiers are not supported for listing staged packages')
+      }
+      packageFilter = spec.name
+    }
+    const opts = { ...this.npm.flatOptions }
+    const json = this.npm.config.get('json')
+
+    const allItems = await this.#fetchAllPages(opts, packageFilter)
+
+    if (json) {
+      output.standard(JSON.stringify(allItems, null, 2), { [META]: true, redact: false })
+      return
+    }
+
+    if (allItems.length === 0) {
+      if (packageFilter) {
+        output.standard(`No staged versions of package name "${packageFilter}".`)
+      } else {
+        output.standard('No staged packages found.')
+      }
+      return
+    }
+
+    for (let i = 0; i < allItems.length; i++) {
+      if (i > 0) {
+        output.standard('')
+      }
+      logStageItem(allItems[i], { chalk: this.npm.chalk })
+    }
+  }
+
+  async #fetchAllPages (opts, packageFilter) {
+    const items = []
+    let page = 0
+    const perPage = 100
+    while (true) {
+      const query = { page, perPage }
+      if (packageFilter) {
+        query.package = packageFilter
+      }
+      const res = await npmFetch.json('/-/stage', {
+        ...opts,
+        query,
+      })
+      items.push(...res.items)
+      if (items.length >= res.total || res.items.length < perPage) {
+        break
+      }
+      page++
+    }
+    return items
+  }
+}
+
+module.exports = StageList
diff --git a/deps/npm/lib/commands/stage/publish.js b/deps/npm/lib/commands/stage/publish.js
new file mode 100644
index 00000000000000..ff3fa3ad2b9ca3
--- /dev/null
+++ b/deps/npm/lib/commands/stage/publish.js
@@ -0,0 +1,13 @@
+const Publish = require('../publish.js')
+
+class StagePublish extends Publish {
+  static description = 'Stage a package for publishing, deferring proof-of-presence (2FA) to a later point in time'
+  static name = 'publish'
+  static stage = true
+  static params = Publish.params
+  static usage = Publish.usage
+  static workspaces = true
+  static ignoreImplicitWorkspace = false
+}
+
+module.exports = StagePublish
diff --git a/deps/npm/lib/commands/stage/reject.js b/deps/npm/lib/commands/stage/reject.js
new file mode 100644
index 00000000000000..2f29a95ea4e964
--- /dev/null
+++ b/deps/npm/lib/commands/stage/reject.js
@@ -0,0 +1,37 @@
+const { log, output, META } = require('proc-log')
+const npmFetch = require('npm-registry-fetch')
+const { otplease } = require('../../utils/auth.js')
+const { validateUUID } = require('../../utils/validate-uuid.js')
+const BaseCommand = require('../../base-cmd.js')
+
+class StageReject extends BaseCommand {
+  static description = 'Reject a staged package, removing it from the registry'
+  static name = 'reject'
+  static usage = ['<stage-id>']
+  static params = ['otp', 'registry']
+  static positionals = 1
+
+  async exec (args) {
+    if (!args[0]) {
+      throw this.usageError('Missing required <stage-id>')
+    }
+    const stageId = args[0]
+    validateUUID(stageId, 'stage-id')
+    const opts = { ...this.npm.flatOptions }
+
+    log.notice('', `Rejecting staged package ${stageId}`)
+    log.warn('', 'Rejecting will permanently delete this staged publish record and tarball from the registry.')
+
+    await otplease(this.npm, opts, o =>
+      npmFetch(`/-/stage/${stageId}`, {
+        ...o,
+        method: 'DELETE',
+        ignoreBody: true,
+      })
+    )
+
+    output.standard(`Staged package ${stageId} has been rejected.`, { [META]: true, redact: false })
+  }
+}
+
+module.exports = StageReject
diff --git a/deps/npm/lib/commands/stage/view.js b/deps/npm/lib/commands/stage/view.js
new file mode 100644
index 00000000000000..7f7f6634568704
--- /dev/null
+++ b/deps/npm/lib/commands/stage/view.js
@@ -0,0 +1,34 @@
+const { output, META } = require('proc-log')
+const npmFetch = require('npm-registry-fetch')
+const { logStageItem } = require('../../utils/key-values.js')
+const { validateUUID } = require('../../utils/validate-uuid.js')
+const BaseCommand = require('../../base-cmd.js')
+
+class StageView extends BaseCommand {
+  static description = 'View details of a specific staged package'
+  static name = 'view'
+  static usage = ['<stage-id>']
+  static params = ['json', 'registry']
+  static positionals = 1
+
+  async exec (args) {
+    if (!args[0]) {
+      throw this.usageError('Missing required <stage-id>')
+    }
+    const stageId = args[0]
+    validateUUID(stageId, 'stage-id')
+    const opts = { ...this.npm.flatOptions }
+    const json = this.npm.config.get('json')
+
+    const item = await npmFetch.json(`/-/stage/${stageId}`, opts)
+
+    if (json) {
+      output.standard(JSON.stringify(item, null, 2), { [META]: true, redact: false })
+      return
+    }
+
+    logStageItem(item, { chalk: this.npm.chalk })
+  }
+}
+
+module.exports = StageView
diff --git a/deps/npm/lib/commands/trust/circleci.js b/deps/npm/lib/commands/trust/circleci.js
index 34d25b80182688..5444ccd09ce6e8 100644
--- a/deps/npm/lib/commands/trust/circleci.js
+++ b/deps/npm/lib/commands/trust/circleci.js
@@ -1,9 +1,8 @@
 const Definition = require('@npmcli/config/lib/definitions/definition.js')
 const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
 const TrustCommand = require('../../trust-cmd.js')
-
-// UUID validation regex
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const { trustDefinitions } = require('../../trust-cmd.js')
+const { validateUUID } = require('../../utils/validate-uuid.js')
 
 class TrustCircleCI extends TrustCommand {
   static description = 'Create a trusted relationship between a package and CircleCI'
@@ -13,7 +12,7 @@ class TrustCircleCI extends TrustCommand {
   static providerEntity = 'CircleCI pipeline'
 
   static usage = [
-    '[package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [-y|--yes]',
+    '[package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [--allow-publish] [--allow-stage-publish] [-y|--yes]',
   ]
 
   static definitions = [
@@ -46,6 +45,8 @@ class TrustCircleCI extends TrustCommand {
       type: [null, String, Array],
       description: 'CircleCI context UUID to match',
     }),
+    trustDefinitions['allow-publish'],
+    trustDefinitions['allow-stage-publish'],
     // globals are alphabetical
     globalDefinitions['dry-run'],
     globalDefinitions.json,
@@ -54,9 +55,7 @@ class TrustCircleCI extends TrustCommand {
   ]
 
   validateUuid (value, fieldName) {
-    if (!UUID_REGEX.test(value)) {
-      throw new Error(`${fieldName} must be a valid UUID`)
-    }
+    validateUUID(value, fieldName)
   }
 
   validateVcsOrigin (value) {
diff --git a/deps/npm/lib/commands/trust/github.js b/deps/npm/lib/commands/trust/github.js
index 870314b717a759..c3434fe40770eb 100644
--- a/deps/npm/lib/commands/trust/github.js
+++ b/deps/npm/lib/commands/trust/github.js
@@ -1,6 +1,7 @@
 const Definition = require('@npmcli/config/lib/definitions/definition.js')
 const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
 const TrustCommand = require('../../trust-cmd.js')
+const { trustDefinitions } = require('../../trust-cmd.js')
 const path = require('node:path')
 
 class TrustGitHub extends TrustCommand {
@@ -16,7 +17,7 @@ class TrustGitHub extends TrustCommand {
   static entityKey = 'repository'
 
   static usage = [
-    '[package] --file [--repo|--repository] [--env|--environment] [-y|--yes]',
+    '[package] --file [--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]',
   ]
 
   static definitions = [
@@ -38,6 +39,8 @@ class TrustGitHub extends TrustCommand {
       description: 'CI environment name',
       alias: ['env'],
     }),
+    trustDefinitions['allow-publish'],
+    trustDefinitions['allow-stage-publish'],
     // globals are alphabetical
     globalDefinitions['dry-run'],
     globalDefinitions.json,
diff --git a/deps/npm/lib/commands/trust/gitlab.js b/deps/npm/lib/commands/trust/gitlab.js
index e6456244ea1850..809e05ed200201 100644
--- a/deps/npm/lib/commands/trust/gitlab.js
+++ b/deps/npm/lib/commands/trust/gitlab.js
@@ -1,6 +1,7 @@
 const Definition = require('@npmcli/config/lib/definitions/definition.js')
 const globalDefinitions = require('@npmcli/config/lib/definitions/definitions.js')
 const TrustCommand = require('../../trust-cmd.js')
+const { trustDefinitions } = require('../../trust-cmd.js')
 const path = require('node:path')
 
 class TrustGitLab extends TrustCommand {
@@ -16,7 +17,7 @@ class TrustGitLab extends TrustCommand {
   static entityKey = 'project'
 
   static usage = [
-    '[package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]',
+    '[package] --file [--project|--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]',
   ]
 
   static definitions = [
@@ -37,6 +38,8 @@ class TrustGitLab extends TrustCommand {
       description: 'CI environment name',
       alias: ['env'],
     }),
+    trustDefinitions['allow-publish'],
+    trustDefinitions['allow-stage-publish'],
     // globals are alphabetical
     globalDefinitions['dry-run'],
     globalDefinitions.json,
diff --git a/deps/npm/lib/commands/update.js b/deps/npm/lib/commands/update.js
index ed1416d70c13e2..a7fa14d8fcf24f 100644
--- a/deps/npm/lib/commands/update.js
+++ b/deps/npm/lib/commands/update.js
@@ -21,6 +21,7 @@ class Update extends ArboristWorkspaceCmd {
     'ignore-scripts',
     'audit',
     'before',
+    'min-release-age',
     'bin-links',
     'fund',
     'dry-run',
diff --git a/deps/npm/lib/trust-cmd.js b/deps/npm/lib/trust-cmd.js
index 5fab8df1d21aa2..7fabe3e421aa6a 100644
--- a/deps/npm/lib/trust-cmd.js
+++ b/deps/npm/lib/trust-cmd.js
@@ -6,9 +6,29 @@ const { read: _read } = require('read')
 const { input, output, log, META } = require('proc-log')
 const gitinfo = require('hosted-git-info')
 const pkgJson = require('@npmcli/package-json')
+const Definition = require('@npmcli/config/lib/definitions/definition.js')
 
 const NPM_FRONTEND = 'https://www.npmjs.com'
 
+const PERMISSIONS = {
+  CREATE_PACKAGE: 'createPackage',
+  CREATE_STAGED_PACKAGE: 'createStagedPackage',
+}
+
+const trustDefinitions = {
+  'allow-publish': new Definition('allow-publish', {
+    default: false,
+    type: Boolean,
+    description: 'Allow npm publish for this trusted publisher configuration',
+  }),
+  'allow-stage-publish': new Definition('allow-stage-publish', {
+    default: false,
+    type: Boolean,
+    description: 'Allow npm stage publish for this trusted publisher configuration',
+    alias: ['allow-staged-publish'],
+  }),
+}
+
 class TrustCommand extends BaseCommand {
   // Helper to format template strings with color
   // Blue text with reset color for interpolated values
@@ -45,8 +65,22 @@ class TrustCommand extends BaseCommand {
     }))
   }
 
+  static permissionLabels = {
+    [PERMISSIONS.CREATE_PACKAGE]: 'publish',
+    [PERMISSIONS.CREATE_STAGED_PACKAGE]: 'stage publish',
+  }
+
+  static formatPermissions (permissions) {
+    if (!Array.isArray(permissions) || permissions.length === 0) {
+      return null
+    }
+    return permissions
+      .map(p => TrustCommand.permissionLabels[p] || p)
+      .join(', ')
+  }
+
   logOptions (options, pad = true) {
-    const { values, warnings, fromPackageJson, urls } = { warnings: [], ...options }
+    const { values, warnings, fromPackageJson, urls, permissions } = { warnings: [], ...options }
     if (warnings && warnings.length > 0) {
       for (const warningMsg of warnings) {
         log.warn('trust', warningMsg)
@@ -55,8 +89,12 @@ class TrustCommand extends BaseCommand {
 
     const json = this.config.get('json')
     if (json) {
+      const jsonValues = { ...options.values }
+      if (permissions) {
+        jsonValues.permissions = permissions
+      }
       // Disable redaction: trust config values (e.g. CircleCI UUIDs) are not secrets
-      output.standard(JSON.stringify(options.values, null, 2), { [META]: true, redact: false })
+      output.standard(JSON.stringify(jsonValues, null, 2), { [META]: true, redact: false })
       return
     }
 
@@ -82,6 +120,10 @@ class TrustCommand extends BaseCommand {
           lines.push(parts.join(' '))
         }
       }
+      const formattedPermissions = TrustCommand.formatPermissions(permissions)
+      if (formattedPermissions) {
+        lines.push(`${chalk.reset('permissions')}: ${chalk.green(formattedPermissions)}`)
+      }
       if (pad) {
         output.standard()
       }
@@ -165,6 +207,22 @@ class TrustCommand extends BaseCommand {
     const { providerName, providerEntity, providerHostname } = this.constructor
     const dryRun = this.config.get('dry-run')
     const yes = this.config.get('yes') // deep-lore this allows for --no-yes
+
+    const allowPublish = flags['allow-publish']
+    const allowStagePublish = flags['allow-stage-publish']
+
+    if (!allowPublish && !allowStagePublish) {
+      throw new Error('At least one permission flag is required (--allow-publish, --allow-stage-publish)')
+    }
+
+    const permissions = []
+    if (allowPublish) {
+      permissions.push(PERMISSIONS.CREATE_PACKAGE)
+    }
+    if (allowStagePublish) {
+      permissions.push(PERMISSIONS.CREATE_STAGED_PACKAGE)
+    }
+
     const options = await this.flagsToOptions({ positionalArgs, flags, providerHostname })
     this.dialogue`Establishing trust between ${options.values.package} package and ${providerName}`
     this.dialogue`Anyone with ${providerEntity} write access can publish to ${options.values.package}`
@@ -172,12 +230,13 @@ class TrustCommand extends BaseCommand {
     if (!this.registryIsDefault) {
       this.warn`Registry ${this.npm.config.get('registry')} may not support trusted publishing`
     }
-    this.logOptions(options)
+    this.logOptions({ ...options, permissions })
     if (dryRun) {
       return
     }
     await this.confirmOperation(yes)
     const trustConfig = this.constructor.optionsToBody(options.values)
+    trustConfig.permissions = permissions
     const response = await this.createConfig(options.values.package, [trustConfig])
     const body = await response.json()
     this.dialogue`Trust configuration created successfully for ${options.values.package} with the following settings:`
@@ -273,8 +332,9 @@ class TrustCommand extends BaseCommand {
     const items = Array.isArray(body) ? body : [body]
     for (const config of items) {
       const values = this.constructor.bodyToOptions(config)
+      const permissions = config.permissions
       output.standard()
-      this.logOptions({ values }, false)
+      this.logOptions({ values, permissions }, false)
     }
     output.standard()
   }
@@ -282,3 +342,4 @@ class TrustCommand extends BaseCommand {
 
 module.exports = TrustCommand
 module.exports.NPM_FRONTEND = NPM_FRONTEND
+module.exports.trustDefinitions = trustDefinitions
diff --git a/deps/npm/lib/utils/cmd-list.js b/deps/npm/lib/utils/cmd-list.js
index 9cd2346f0ff98f..0166b1cc862ba2 100644
--- a/deps/npm/lib/utils/cmd-list.js
+++ b/deps/npm/lib/utils/cmd-list.js
@@ -55,6 +55,7 @@ const commands = [
   'search',
   'set',
   'shrinkwrap',
+  'stage',
   'star',
   'stars',
   'start',
diff --git a/deps/npm/lib/utils/display.js b/deps/npm/lib/utils/display.js
index 122a7f6e8c577a..72e76bd36731b0 100644
--- a/deps/npm/lib/utils/display.js
+++ b/deps/npm/lib/utils/display.js
@@ -1,6 +1,7 @@
 const { log, output, input, META } = require('proc-log')
 const { explain } = require('./explain-eresolve.js')
 const { formatWithOptions } = require('./format')
+const { redactLog } = require('@npmcli/redact')
 
 // This is the general approach to color:
 // Eventually this will be exposed somewhere we can refer to these by name.
@@ -98,14 +99,16 @@ const getArrayOrObject = (items) => {
   return Object.assign({}, ...items.filter(o => isPlainObject(o)))
 }
 
+const redactValue = (obj) => JSON.parse(redactLog(JSON.stringify(obj)))
+
 const getJsonBuffer = ({ [JSON_ERROR_KEY]: metaError }, buffer) => {
   const items = []
   // meta also contains the meta object passed to flush
   const errors = metaError ? [metaError] : []
   // index 1 is the meta, 2 is the logged argument
-  for (const [, { [JSON_ERROR_KEY]: error }, obj] of buffer) {
+  for (const [, { [JSON_ERROR_KEY]: error, redact = true }, obj] of buffer) {
     if (obj) {
-      items.push(obj)
+      items.push(redact ? redactValue(obj) : obj)
     }
     if (error) {
       errors.push(error)
@@ -291,7 +294,9 @@ class Display {
         if (this.#json) {
           const json = getJsonBuffer(meta, this.#outputState.buffer)
           if (json) {
-            this.#writeOutput(output.KEYS.standard, meta, JSON.stringify(json, null, 2))
+            // Per-item redaction already applied in getJsonBuffer, skip string-level redaction
+            const jsonMeta = { ...meta, redact: false }
+            this.#writeOutput(output.KEYS.standard, jsonMeta, JSON.stringify(json, null, 2))
           }
         } else {
           this.#outputState.buffer.forEach((item) => this.#writeOutput(...item))
diff --git a/deps/npm/lib/utils/key-values.js b/deps/npm/lib/utils/key-values.js
new file mode 100644
index 00000000000000..cf54304da6b4b2
--- /dev/null
+++ b/deps/npm/lib/utils/key-values.js
@@ -0,0 +1,42 @@
+const { output, META } = require('proc-log')
+
+const defaultPredicate = (key, value, chalk) => {
+  if (value === null || value === undefined) {
+    return null
+  }
+  return chalk.green(value)
+}
+
+function logObject (values, { chalk, json, predicate = defaultPredicate }) {
+  if (json) {
+    output.standard(JSON.stringify(values, null, 2), { [META]: true, redact: false })
+    return
+  }
+
+  const lines = []
+  for (const [key, value] of Object.entries(values)) {
+    const formatted = predicate(key, value, chalk)
+    if (formatted !== null) {
+      lines.push(`${chalk.cyan(key)}: ${formatted}`)
+    }
+  }
+  if (lines.length) {
+    output.standard(lines.join('\n'), { [META]: true, redact: false })
+  }
+}
+
+function logStageItem (item, { chalk }) {
+  const { id, packageName, version, tag, createdAt, actor, actorType, shasum, ...rest } = item
+  logObject({
+    id,
+    'package name': packageName,
+    version,
+    tag,
+    'date staged': createdAt,
+    'staged by': actorType ? `${actor} (${actorType})` : actor,
+    shasum,
+    ...rest,
+  }, { chalk })
+}
+
+module.exports = { logObject, logStageItem, defaultPredicate }
diff --git a/deps/npm/lib/utils/sbom-cyclonedx.js b/deps/npm/lib/utils/sbom-cyclonedx.js
index f8283397989d5b..fe368e968baaa7 100644
--- a/deps/npm/lib/utils/sbom-cyclonedx.js
+++ b/deps/npm/lib/utils/sbom-cyclonedx.js
@@ -170,13 +170,20 @@ const toCyclonedxItem = (node, { packageType }) => {
 }
 
 const toCyclonedxDependency = (node, nodes) => {
-  return {
-    ref: toCyclonedxID(node),
-    dependsOn: [...node.edgesOut.values()]
+  // A node can have multiple outgoing edges resolving to the same
+  // `name@version` (e.g. via npm aliases like `foo: npm:bar@1` alongside a
+  // direct `bar: ^1` dep), which would produce duplicate entries in
+  // `dependsOn`. CycloneDX 1.5 requires unique items, so dedupe by ref.
+  const dependsOn = [...new Set(
+    [...node.edgesOut.values()]
       // Filter out edges that are linking to nodes not in the list
       .filter(edge => nodes.find(n => n === edge.to))
       .map(edge => toCyclonedxID(edge.to))
-      .filter(id => id),
+      .filter(id => id)
+  )]
+  return {
+    ref: toCyclonedxID(node),
+    dependsOn,
   }
 }
 
diff --git a/deps/npm/lib/utils/sbom-spdx.js b/deps/npm/lib/utils/sbom-spdx.js
index 38824f263681d0..8ea75c688bc862 100644
--- a/deps/npm/lib/utils/sbom-spdx.js
+++ b/deps/npm/lib/utils/sbom-spdx.js
@@ -48,11 +48,23 @@ const spdxOutput = ({ npm, nodes, packageType }) => {
     }
     seen.add(node)
 
+    // A node can have multiple outgoing edges resolving to the same
+    // `name@version` of the same edge type (e.g. via npm aliases), which
+    // would produce identical relationship triples. Dedupe per source node.
+    const seenRels = new Set()
     const rels = [...node.edgesOut.values()]
       // Filter out edges that are linking to nodes not in the list
       .filter(edge => nodes.find(n => n === edge.to))
       .map(edge => toSpdxRelationship(node, edge))
       .filter(rel => rel)
+      .filter(rel => {
+        const key = `${rel.spdxElementId}|${rel.relatedSpdxElement}|${rel.relationshipType}`
+        if (seenRels.has(key)) {
+          return false
+        }
+        seenRels.add(key)
+        return true
+      })
 
     relationships.push(...rels)
   }
diff --git a/deps/npm/lib/utils/tar.js b/deps/npm/lib/utils/tar.js
index a744dca3132578..6b6870678c0973 100644
--- a/deps/npm/lib/utils/tar.js
+++ b/deps/npm/lib/utils/tar.js
@@ -1,15 +1,16 @@
 const tar = require('tar')
 const ssri = require('ssri')
-const { log, output } = require('proc-log')
+const { log, output, META } = require('proc-log')
 const formatBytes = require('./format-bytes.js')
 const localeCompare = require('@isaacs/string-locale-compare')('en', {
   sensitivity: 'case',
   numeric: true,
 })
 
-const logTar = (tarball, { unicode = false, json, key } = {}) => {
+const logTar = (tarball, { unicode = false, json, key, redact } = {}) => {
   if (json) {
-    output.buffer(key == null ? tarball : { [key]: tarball })
+    const meta = redact === false ? { [META]: true, redact: false } : undefined
+    output.buffer(key == null ? tarball : { [key]: tarball }, meta)
     return
   }
   log.notice('')
diff --git a/deps/npm/lib/utils/validate-uuid.js b/deps/npm/lib/utils/validate-uuid.js
new file mode 100644
index 00000000000000..d5842429303f60
--- /dev/null
+++ b/deps/npm/lib/utils/validate-uuid.js
@@ -0,0 +1,10 @@
+// UUID validation regex
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const validateUUID = (value, fieldName) => {
+  if (!UUID_REGEX.test(value)) {
+    throw new Error(`${fieldName} must be a valid UUID`)
+  }
+}
+
+module.exports = { UUID_REGEX, validateUUID }
diff --git a/deps/npm/man/man1/npm-access.1 b/deps/npm/man/man1/npm-access.1
index 13c9af41efc167..6490de4ada7a33 100644
--- a/deps/npm/man/man1/npm-access.1
+++ b/deps/npm/man/man1/npm-access.1
@@ -1,4 +1,4 @@
-.TH "NPM-ACCESS" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-ACCESS" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-access\fR - Set access level on published packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-adduser.1 b/deps/npm/man/man1/npm-adduser.1
index a9ce18423f7286..849f6a40416269 100644
--- a/deps/npm/man/man1/npm-adduser.1
+++ b/deps/npm/man/man1/npm-adduser.1
@@ -1,4 +1,4 @@
-.TH "NPM-ADDUSER" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-ADDUSER" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-adduser\fR - Add a registry user account
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-audit.1 b/deps/npm/man/man1/npm-audit.1
index 6760fe1e954125..c0704aafc31b73 100644
--- a/deps/npm/man/man1/npm-audit.1
+++ b/deps/npm/man/man1/npm-audit.1
@@ -1,4 +1,4 @@
-.TH "NPM-AUDIT" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-AUDIT" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-audit\fR - Run a security audit
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-bugs.1 b/deps/npm/man/man1/npm-bugs.1
index 474b08f5d76a26..77f78edd37ee28 100644
--- a/deps/npm/man/man1/npm-bugs.1
+++ b/deps/npm/man/man1/npm-bugs.1
@@ -1,4 +1,4 @@
-.TH "NPM-BUGS" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-BUGS" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-bugs\fR - Report bugs for a package in a web browser
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-cache.1 b/deps/npm/man/man1/npm-cache.1
index e20349de377056..8ed27305563e99 100644
--- a/deps/npm/man/man1/npm-cache.1
+++ b/deps/npm/man/man1/npm-cache.1
@@ -1,4 +1,4 @@
-.TH "NPM-CACHE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-CACHE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-cache\fR - Manipulates packages cache
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-ci.1 b/deps/npm/man/man1/npm-ci.1
index 21f461e0fdd1db..fb0a6b25221d2c 100644
--- a/deps/npm/man/man1/npm-ci.1
+++ b/deps/npm/man/man1/npm-ci.1
@@ -1,4 +1,4 @@
-.TH "NPM-CI" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-CI" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-ci\fR - Clean install a project
 .SS "Synopsis"
@@ -168,6 +168,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -177,9 +201,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
diff --git a/deps/npm/man/man1/npm-completion.1 b/deps/npm/man/man1/npm-completion.1
index ad07723f8e19dd..9dbfd321c9a643 100644
--- a/deps/npm/man/man1/npm-completion.1
+++ b/deps/npm/man/man1/npm-completion.1
@@ -1,4 +1,4 @@
-.TH "NPM-COMPLETION" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-COMPLETION" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-completion\fR - Tab Completion for npm
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-config.1 b/deps/npm/man/man1/npm-config.1
index cb4f7c4a21f478..f73f7d0815a9be 100644
--- a/deps/npm/man/man1/npm-config.1
+++ b/deps/npm/man/man1/npm-config.1
@@ -1,4 +1,4 @@
-.TH "NPM-CONFIG" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-CONFIG" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-config\fR - Manage the npm configuration files
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-dedupe.1 b/deps/npm/man/man1/npm-dedupe.1
index 97eb2af71fde23..f0c0134b20e5f2 100644
--- a/deps/npm/man/man1/npm-dedupe.1
+++ b/deps/npm/man/man1/npm-dedupe.1
@@ -1,4 +1,4 @@
-.TH "NPM-DEDUPE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DEDUPE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-dedupe\fR - Reduce duplication in the package tree
 .SS "Synopsis"
@@ -165,6 +165,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -174,9 +198,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
diff --git a/deps/npm/man/man1/npm-deprecate.1 b/deps/npm/man/man1/npm-deprecate.1
index 8c44f55a1a52b0..5d4fdd380cef63 100644
--- a/deps/npm/man/man1/npm-deprecate.1
+++ b/deps/npm/man/man1/npm-deprecate.1
@@ -1,4 +1,4 @@
-.TH "NPM-DEPRECATE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DEPRECATE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-deprecate\fR - Deprecate a version of a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-diff.1 b/deps/npm/man/man1/npm-diff.1
index 5b4ab2fcebcb1d..4f0e943ec7b4a3 100644
--- a/deps/npm/man/man1/npm-diff.1
+++ b/deps/npm/man/man1/npm-diff.1
@@ -1,4 +1,4 @@
-.TH "NPM-DIFF" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DIFF" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-diff\fR - The registry diff command
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-dist-tag.1 b/deps/npm/man/man1/npm-dist-tag.1
index 768fe6d575ea48..0faa3fd6b2b388 100644
--- a/deps/npm/man/man1/npm-dist-tag.1
+++ b/deps/npm/man/man1/npm-dist-tag.1
@@ -1,4 +1,4 @@
-.TH "NPM-DIST-TAG" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DIST-TAG" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-dist-tag\fR - Modify package distribution tags
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-docs.1 b/deps/npm/man/man1/npm-docs.1
index ed9f35f00bebea..ad5cfb87e86115 100644
--- a/deps/npm/man/man1/npm-docs.1
+++ b/deps/npm/man/man1/npm-docs.1
@@ -1,4 +1,4 @@
-.TH "NPM-DOCS" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DOCS" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-docs\fR - Open documentation for a package in a web browser
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-doctor.1 b/deps/npm/man/man1/npm-doctor.1
index d7f5ef43edf1f4..eafa7a811ffc65 100644
--- a/deps/npm/man/man1/npm-doctor.1
+++ b/deps/npm/man/man1/npm-doctor.1
@@ -1,4 +1,4 @@
-.TH "NPM-DOCTOR" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-DOCTOR" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-doctor\fR - Check the health of your npm environment
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-edit.1 b/deps/npm/man/man1/npm-edit.1
index 83753a5fc423ab..d7f2c198a7046f 100644
--- a/deps/npm/man/man1/npm-edit.1
+++ b/deps/npm/man/man1/npm-edit.1
@@ -1,4 +1,4 @@
-.TH "NPM-EDIT" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-EDIT" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-edit\fR - Edit an installed package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-exec.1 b/deps/npm/man/man1/npm-exec.1
index d6f20fe3b587b6..3c9b5dff8b96bf 100644
--- a/deps/npm/man/man1/npm-exec.1
+++ b/deps/npm/man/man1/npm-exec.1
@@ -1,4 +1,4 @@
-.TH "NPM-EXEC" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-EXEC" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-exec\fR - Run a command from a local or remote npm package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-explain.1 b/deps/npm/man/man1/npm-explain.1
index 3f981b60850469..551df063471993 100644
--- a/deps/npm/man/man1/npm-explain.1
+++ b/deps/npm/man/man1/npm-explain.1
@@ -1,4 +1,4 @@
-.TH "NPM-EXPLAIN" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-EXPLAIN" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-explain\fR - Explain installed packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-explore.1 b/deps/npm/man/man1/npm-explore.1
index f8fad8822edd5b..abbc9975b705ef 100644
--- a/deps/npm/man/man1/npm-explore.1
+++ b/deps/npm/man/man1/npm-explore.1
@@ -1,4 +1,4 @@
-.TH "NPM-EXPLORE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-EXPLORE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-explore\fR - Browse an installed package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-find-dupes.1 b/deps/npm/man/man1/npm-find-dupes.1
index 5ea1a5e19df5b9..bae0c98a90073d 100644
--- a/deps/npm/man/man1/npm-find-dupes.1
+++ b/deps/npm/man/man1/npm-find-dupes.1
@@ -1,4 +1,4 @@
-.TH "NPM-FIND-DUPES" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-FIND-DUPES" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-find-dupes\fR - Find duplication in the package tree
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-fund.1 b/deps/npm/man/man1/npm-fund.1
index fc0e31efb0f96e..188d91950db7fa 100644
--- a/deps/npm/man/man1/npm-fund.1
+++ b/deps/npm/man/man1/npm-fund.1
@@ -1,4 +1,4 @@
-.TH "NPM-FUND" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-FUND" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-fund\fR - Retrieve funding information
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-get.1 b/deps/npm/man/man1/npm-get.1
index e05435badd204c..10a03171c209b9 100644
--- a/deps/npm/man/man1/npm-get.1
+++ b/deps/npm/man/man1/npm-get.1
@@ -1,4 +1,4 @@
-.TH "NPM-GET" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-GET" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-get\fR - Get a value from the npm configuration
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-help-search.1 b/deps/npm/man/man1/npm-help-search.1
index ed23a840be992b..d42e5d0d84bc9b 100644
--- a/deps/npm/man/man1/npm-help-search.1
+++ b/deps/npm/man/man1/npm-help-search.1
@@ -1,4 +1,4 @@
-.TH "NPM-HELP-SEARCH" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-HELP-SEARCH" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-help-search\fR - Search npm help documentation
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-help.1 b/deps/npm/man/man1/npm-help.1
index 191480d5c3fe4e..e4e34292fea758 100644
--- a/deps/npm/man/man1/npm-help.1
+++ b/deps/npm/man/man1/npm-help.1
@@ -1,4 +1,4 @@
-.TH "NPM-HELP" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-HELP" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-help\fR - Get help on npm
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-init.1 b/deps/npm/man/man1/npm-init.1
index 6c7f7af97d5a0e..66444a2bd30a9a 100644
--- a/deps/npm/man/man1/npm-init.1
+++ b/deps/npm/man/man1/npm-init.1
@@ -1,4 +1,4 @@
-.TH "NPM-INIT" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-INIT" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-init\fR - Create a package.json file
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-install-ci-test.1 b/deps/npm/man/man1/npm-install-ci-test.1
index c1855691bfbc14..d9991dd61f8fc9 100644
--- a/deps/npm/man/man1/npm-install-ci-test.1
+++ b/deps/npm/man/man1/npm-install-ci-test.1
@@ -1,4 +1,4 @@
-.TH "NPM-INSTALL-CI-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-INSTALL-CI-TEST" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-install-ci-test\fR - Install a project with a clean slate and run tests
 .SS "Synopsis"
@@ -116,6 +116,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -125,9 +149,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
diff --git a/deps/npm/man/man1/npm-install-test.1 b/deps/npm/man/man1/npm-install-test.1
index ce4172bf42b0ad..33311b005154fb 100644
--- a/deps/npm/man/man1/npm-install-test.1
+++ b/deps/npm/man/man1/npm-install-test.1
@@ -1,4 +1,4 @@
-.TH "NPM-INSTALL-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-INSTALL-TEST" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-install-test\fR - Install package(s) and run tests
 .SS "Synopsis"
@@ -193,6 +193,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -202,9 +226,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
@@ -228,7 +264,7 @@ If passed to \fBnpm install\fR, will rebuild the npm tree such that only version
 .P
 If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
 .P
-This config cannot be used with: \fBmin-release-age\fR
+If \fBbefore\fR and \fBmin-release-age\fR are both set in the same source, \fBbefore\fR wins (an explicit absolute date overrides a relative window). Across sources, the standard precedence applies (cli > env > project > user > global), so a higher-priority source can always relax or override a lower-priority one.
 .SS "\fBmin-release-age\fR"
 .RS 0
 .IP \(bu 4
@@ -240,9 +276,7 @@ Type: null or Number
 .P
 If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
 .P
-This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
-.P
-This config cannot be used with: \fBbefore\fR
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days. The two may coexist (e.g. \fBmin-release-age\fR in your \fB.npmrc\fR is preserved when npm internally spawns a sub-process with \fB--before\fR while preparing a \fBgit:\fR or \fBgithub:\fR dependency); when both apply, \fBbefore\fR wins within a single source and across sources the standard precedence rules apply.
 .P
 This value is not exported to the environment for child processes.
 .SS "\fBbin-links\fR"
diff --git a/deps/npm/man/man1/npm-install.1 b/deps/npm/man/man1/npm-install.1
index 92df99f6437c96..10163784e45dee 100644
--- a/deps/npm/man/man1/npm-install.1
+++ b/deps/npm/man/man1/npm-install.1
@@ -1,4 +1,4 @@
-.TH "NPM-INSTALL" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-INSTALL" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-install\fR - Install a package
 .SS "Synopsis"
@@ -583,6 +583,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -592,9 +616,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
@@ -618,7 +654,7 @@ If passed to \fBnpm install\fR, will rebuild the npm tree such that only version
 .P
 If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
 .P
-This config cannot be used with: \fBmin-release-age\fR
+If \fBbefore\fR and \fBmin-release-age\fR are both set in the same source, \fBbefore\fR wins (an explicit absolute date overrides a relative window). Across sources, the standard precedence applies (cli > env > project > user > global), so a higher-priority source can always relax or override a lower-priority one.
 .SS "\fBmin-release-age\fR"
 .RS 0
 .IP \(bu 4
@@ -630,9 +666,7 @@ Type: null or Number
 .P
 If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
 .P
-This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
-.P
-This config cannot be used with: \fBbefore\fR
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days. The two may coexist (e.g. \fBmin-release-age\fR in your \fB.npmrc\fR is preserved when npm internally spawns a sub-process with \fB--before\fR while preparing a \fBgit:\fR or \fBgithub:\fR dependency); when both apply, \fBbefore\fR wins within a single source and across sources the standard precedence rules apply.
 .P
 This value is not exported to the environment for child processes.
 .SS "\fBbin-links\fR"
diff --git a/deps/npm/man/man1/npm-link.1 b/deps/npm/man/man1/npm-link.1
index 749145e10948f0..0eb208243b715b 100644
--- a/deps/npm/man/man1/npm-link.1
+++ b/deps/npm/man/man1/npm-link.1
@@ -1,4 +1,4 @@
-.TH "NPM-LINK" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-LINK" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-link\fR - Symlink a package folder
 .SS "Synopsis"
@@ -224,6 +224,30 @@ Type: Boolean
 If true, npm does not run scripts specified in package.json files.
 .P
 Note that commands explicitly intended to run a particular script, such as \fBnpm start\fR, \fBnpm stop\fR, \fBnpm restart\fR, \fBnpm test\fR, and \fBnpm run\fR will still run their intended script if \fBignore-scripts\fR is set, but they will \fInot\fR run any pre- or post-scripts.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -233,9 +257,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBaudit\fR"
 .RS 0
 .IP \(bu 4
diff --git a/deps/npm/man/man1/npm-ll.1 b/deps/npm/man/man1/npm-ll.1
index d7eb6abb2be468..774052db1d799c 100644
--- a/deps/npm/man/man1/npm-ll.1
+++ b/deps/npm/man/man1/npm-ll.1
@@ -1,4 +1,4 @@
-.TH "NPM-LL" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-LL" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-ll\fR - List installed packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-login.1 b/deps/npm/man/man1/npm-login.1
index 159897bd393f39..58ecb80834d259 100644
--- a/deps/npm/man/man1/npm-login.1
+++ b/deps/npm/man/man1/npm-login.1
@@ -1,4 +1,4 @@
-.TH "NPM-LOGIN" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-LOGIN" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-login\fR - Login to a registry user account
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-logout.1 b/deps/npm/man/man1/npm-logout.1
index 2f8be327eb1816..6248c2010970f8 100644
--- a/deps/npm/man/man1/npm-logout.1
+++ b/deps/npm/man/man1/npm-logout.1
@@ -1,4 +1,4 @@
-.TH "NPM-LOGOUT" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-LOGOUT" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-logout\fR - Log out of the registry
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-ls.1 b/deps/npm/man/man1/npm-ls.1
index 0a6f9a49df3c5d..7f4e7ee59e3244 100644
--- a/deps/npm/man/man1/npm-ls.1
+++ b/deps/npm/man/man1/npm-ls.1
@@ -1,4 +1,4 @@
-.TH "NPM-LS" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-LS" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-ls\fR - List installed packages
 .SS "Synopsis"
@@ -20,7 +20,7 @@ Positional arguments are \fBname@version-range\fR identifiers, which will limit
 .P
 .RS 2
 .nf
-npm@11.13.0 /path/to/npm
+npm@11.15.0 /path/to/npm
 └─┬ init-package-json@0.0.4
   └── promzard@0.1.5
 .fi
diff --git a/deps/npm/man/man1/npm-org.1 b/deps/npm/man/man1/npm-org.1
index 4afed2e97b2cc5..7bcc7393e4de30 100644
--- a/deps/npm/man/man1/npm-org.1
+++ b/deps/npm/man/man1/npm-org.1
@@ -1,4 +1,4 @@
-.TH "NPM-ORG" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-ORG" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-org\fR - Manage orgs
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-outdated.1 b/deps/npm/man/man1/npm-outdated.1
index 59a87bd862c9c7..8d82a119fcc6de 100644
--- a/deps/npm/man/man1/npm-outdated.1
+++ b/deps/npm/man/man1/npm-outdated.1
@@ -1,4 +1,4 @@
-.TH "NPM-OUTDATED" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-OUTDATED" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-outdated\fR - Check for outdated packages
 .SS "Synopsis"
@@ -180,7 +180,7 @@ If passed to \fBnpm install\fR, will rebuild the npm tree such that only version
 .P
 If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
 .P
-This config cannot be used with: \fBmin-release-age\fR
+If \fBbefore\fR and \fBmin-release-age\fR are both set in the same source, \fBbefore\fR wins (an explicit absolute date overrides a relative window). Across sources, the standard precedence applies (cli > env > project > user > global), so a higher-priority source can always relax or override a lower-priority one.
 .SS "\fBmin-release-age\fR"
 .RS 0
 .IP \(bu 4
@@ -192,9 +192,7 @@ Type: null or Number
 .P
 If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
 .P
-This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
-.P
-This config cannot be used with: \fBbefore\fR
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days. The two may coexist (e.g. \fBmin-release-age\fR in your \fB.npmrc\fR is preserved when npm internally spawns a sub-process with \fB--before\fR while preparing a \fBgit:\fR or \fBgithub:\fR dependency); when both apply, \fBbefore\fR wins within a single source and across sources the standard precedence rules apply.
 .P
 This value is not exported to the environment for child processes.
 .SS "See Also"
diff --git a/deps/npm/man/man1/npm-owner.1 b/deps/npm/man/man1/npm-owner.1
index 9be1dad02c0ca6..883d500a403958 100644
--- a/deps/npm/man/man1/npm-owner.1
+++ b/deps/npm/man/man1/npm-owner.1
@@ -1,4 +1,4 @@
-.TH "NPM-OWNER" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-OWNER" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-owner\fR - Manage package owners
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-pack.1 b/deps/npm/man/man1/npm-pack.1
index 7491a4154ec658..cb23bdb9d82541 100644
--- a/deps/npm/man/man1/npm-pack.1
+++ b/deps/npm/man/man1/npm-pack.1
@@ -1,4 +1,4 @@
-.TH "NPM-PACK" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PACK" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-pack\fR - Create a tarball from a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-ping.1 b/deps/npm/man/man1/npm-ping.1
index cf20722885fa78..6ac9326abf40b6 100644
--- a/deps/npm/man/man1/npm-ping.1
+++ b/deps/npm/man/man1/npm-ping.1
@@ -1,4 +1,4 @@
-.TH "NPM-PING" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PING" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-ping\fR - Ping npm registry
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-pkg.1 b/deps/npm/man/man1/npm-pkg.1
index 8622f1fe5aaba7..841cf44e420d69 100644
--- a/deps/npm/man/man1/npm-pkg.1
+++ b/deps/npm/man/man1/npm-pkg.1
@@ -1,4 +1,4 @@
-.TH "NPM-PKG" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PKG" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-pkg\fR - Manages your package.json
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-prefix.1 b/deps/npm/man/man1/npm-prefix.1
index 83b8d8cc0df771..fbfadd6959fef2 100644
--- a/deps/npm/man/man1/npm-prefix.1
+++ b/deps/npm/man/man1/npm-prefix.1
@@ -1,4 +1,4 @@
-.TH "NPM-PREFIX" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PREFIX" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-prefix\fR - Display prefix
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-profile.1 b/deps/npm/man/man1/npm-profile.1
index 703f320dc298c3..e8cb8f6c6a6a14 100644
--- a/deps/npm/man/man1/npm-profile.1
+++ b/deps/npm/man/man1/npm-profile.1
@@ -1,4 +1,4 @@
-.TH "NPM-PROFILE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PROFILE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-profile\fR - Change settings on your registry profile
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-prune.1 b/deps/npm/man/man1/npm-prune.1
index 7f3d08ca5633d2..1afac2948d2e5d 100644
--- a/deps/npm/man/man1/npm-prune.1
+++ b/deps/npm/man/man1/npm-prune.1
@@ -1,4 +1,4 @@
-.TH "NPM-PRUNE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PRUNE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-prune\fR - Remove extraneous packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-publish.1 b/deps/npm/man/man1/npm-publish.1
index f527741ac1963a..88f976cf9fe908 100644
--- a/deps/npm/man/man1/npm-publish.1
+++ b/deps/npm/man/man1/npm-publish.1
@@ -1,4 +1,4 @@
-.TH "NPM-PUBLISH" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-PUBLISH" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-publish\fR - Publish a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-query.1 b/deps/npm/man/man1/npm-query.1
index d8e792f3d0be1f..eef55eeddd7af1 100644
--- a/deps/npm/man/man1/npm-query.1
+++ b/deps/npm/man/man1/npm-query.1
@@ -1,4 +1,4 @@
-.TH "NPM-QUERY" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-QUERY" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-query\fR - Dependency selector query
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-rebuild.1 b/deps/npm/man/man1/npm-rebuild.1
index c19b76fe7597ec..457e8013fb0e5c 100644
--- a/deps/npm/man/man1/npm-rebuild.1
+++ b/deps/npm/man/man1/npm-rebuild.1
@@ -1,4 +1,4 @@
-.TH "NPM-REBUILD" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-REBUILD" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-rebuild\fR - Rebuild a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-repo.1 b/deps/npm/man/man1/npm-repo.1
index 71c912c1f672b6..8ad564f7ddcaeb 100644
--- a/deps/npm/man/man1/npm-repo.1
+++ b/deps/npm/man/man1/npm-repo.1
@@ -1,4 +1,4 @@
-.TH "NPM-REPO" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-REPO" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-repo\fR - Open package repository page in the browser
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-restart.1 b/deps/npm/man/man1/npm-restart.1
index 75f8758112eb29..e65ef425c25cca 100644
--- a/deps/npm/man/man1/npm-restart.1
+++ b/deps/npm/man/man1/npm-restart.1
@@ -1,4 +1,4 @@
-.TH "NPM-RESTART" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-RESTART" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-restart\fR - Restart a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-root.1 b/deps/npm/man/man1/npm-root.1
index b8b6f31b2d979c..cc07c34f7efeeb 100644
--- a/deps/npm/man/man1/npm-root.1
+++ b/deps/npm/man/man1/npm-root.1
@@ -1,4 +1,4 @@
-.TH "NPM-ROOT" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-ROOT" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-root\fR - Display npm root
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-run.1 b/deps/npm/man/man1/npm-run.1
index c6c0bf5325f5d9..ef4291544ae20a 100644
--- a/deps/npm/man/man1/npm-run.1
+++ b/deps/npm/man/man1/npm-run.1
@@ -1,4 +1,4 @@
-.TH "NPM-RUN" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-RUN" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-run\fR - Run arbitrary package scripts
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-sbom.1 b/deps/npm/man/man1/npm-sbom.1
index 34d5972e568556..150c4b165f86bf 100644
--- a/deps/npm/man/man1/npm-sbom.1
+++ b/deps/npm/man/man1/npm-sbom.1
@@ -1,4 +1,4 @@
-.TH "NPM-SBOM" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-SBOM" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-sbom\fR - Generate a Software Bill of Materials (SBOM)
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-search.1 b/deps/npm/man/man1/npm-search.1
index b901d6872d770c..f8d393b45317a6 100644
--- a/deps/npm/man/man1/npm-search.1
+++ b/deps/npm/man/man1/npm-search.1
@@ -1,4 +1,4 @@
-.TH "NPM-SEARCH" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-SEARCH" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-search\fR - Search for packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-set.1 b/deps/npm/man/man1/npm-set.1
index a9a1506e540526..13895c62176d38 100644
--- a/deps/npm/man/man1/npm-set.1
+++ b/deps/npm/man/man1/npm-set.1
@@ -1,4 +1,4 @@
-.TH "NPM-SET" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-SET" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-set\fR - Set a value in the npm configuration
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-shrinkwrap.1 b/deps/npm/man/man1/npm-shrinkwrap.1
index 2c872c9723d832..d7eadbd5438feb 100644
--- a/deps/npm/man/man1/npm-shrinkwrap.1
+++ b/deps/npm/man/man1/npm-shrinkwrap.1
@@ -1,4 +1,4 @@
-.TH "NPM-SHRINKWRAP" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-SHRINKWRAP" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-shrinkwrap\fR - Lock down dependency versions for publication
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-stage.1 b/deps/npm/man/man1/npm-stage.1
new file mode 100644
index 00000000000000..bbef577334aa9f
--- /dev/null
+++ b/deps/npm/man/man1/npm-stage.1
@@ -0,0 +1,178 @@
+.TH "NPM-STAGE" "1" "May 2026" "NPM@11.15.0" ""
+.SH "NAME"
+\fBnpm-stage\fR - Stage packages for publishing
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage
+.fi
+.RE
+.P
+Note: This command is unaware of workspaces.
+.SS "Description"
+.P
+Staged publishing allows package maintainers to require proof-of-presence for all publishes. Proof-of-presence is where a human is involved, interjects, and provides authentication (2FA) during an action \[em] in this case, publishing an npm package.
+.P
+Typically when maintainers use automated workflows to publish, proof-of-presence is lacking as there's no convenient way to interject the process and provide 2FA, as is the case for publishing with a granular access token with bypass and the trusted publishing flow. Staged publishing allows users to have their automated workflows stage a package without a 2FA prompt, deferring the act of 2FA, allowing the maintainer to approve the staged package and publish at a later point.
+.P
+The \fBnpm stage publish\fR command packs the current working directory and places that version of the package into the registry in a state where it's not available for public access, allowing maintainers to approve the package at a later point in time. The act of staging does not prompt for 2FA and can be done with any token type, the act of approving will.
+.P
+Key behaviors:
+.RS 0
+.IP \(bu 4
+Staged packages share the same semver version unique index as published packages \[em] you cannot publish a version that already exists as a staged version for that package.
+.IP \(bu 4
+You can still publish packages normally while you have staged packages pending.
+.IP \(bu 4
+You can stage multiple versions of the same package.
+.IP \(bu 4
+\fBnpm stage publish\fR has parity with \fBnpm publish\fR and will respect \fB"private": true\fR in \fBpackage.json\fR, refusing to stage the package.
+.RE 0
+
+.SS "Prerequisites"
+.P
+Before using \fBnpm stage\fR commands, ensure the following requirements are met:
+.RS 0
+.IP \(bu 4
+\fBWrite permissions on the package:\fR You must have write access to the package you're configuring.
+.IP \(bu 4
+\fBPackage must exist:\fR The package you're configuring must already exist on the npm registry.
+.IP \(bu 4
+\fB2FA enabled on your account:\fR Commands that require 2FA will prompt you to authenticate. If you don't already have 2FA enabled on your account, you must enable it before using these commands.
+.RE 0
+
+.SS "Subcommands"
+.RS 0
+.IP \(bu 4
+\fBnpm stage publish \[lB]<package-spec>\[rB]\fR - Stage a package for publishing
+.IP \(bu 4
+\fBnpm stage list \[lB]<package-spec>\[rB]\fR - List all staged package versions
+.IP \(bu 4
+\fBnpm stage view <stage-id>\fR - View details of a specific staged package
+.IP \(bu 4
+\fBnpm stage approve <stage-id>\fR - Approve a staged package for publishing
+.IP \(bu 4
+\fBnpm stage reject <stage-id>\fR - Reject a staged package
+.IP \(bu 4
+\fBnpm stage download <stage-id>\fR - Download the tarball for inspection
+.RE 0
+
+.SS "2FA Requirements by Subcommand"
+.P
+| Command | Requires 2FA | Notes | | --- | --- | --- | | \fBnpm stage publish\fR | No | Designed for automated workflows; defers 2FA to approval | | \fBnpm stage list\fR | No | View staged packages | | \fBnpm stage view\fR | No | View staged package details | | \fBnpm stage approve\fR | Yes | Prompts for 2FA to publish the staged package | | \fBnpm stage reject\fR | Yes | Prompts for 2FA to permanently remove the staged package | | \fBnpm stage download\fR | No | Downloads the tarball for local inspection |
+.SS "Tag Behavior"
+.P
+The \fB--tag\fR flag follows the same logic as \fBnpm publish\fR. If no tag is provided, the \fBlatest\fR tag is used by default. For pre-release versions (e.g., \fB1.0.0-beta.1\fR) and non-latest semver versions, the tag must be explicitly provided \[em] otherwise the CLI will error, just as \fBnpm publish\fR would.
+.P
+The tag is an immutable property of the staged package. Once a package is staged with a given tag, the tag cannot be changed. If you need to stage the same version with a different tag, you must first reject the existing staged package using \fBnpm stage reject\fR and then re-stage it with the desired tag.
+.SS "Token Behavior"
+.P
+The key difference with staged publishing is that \fBnpm stage publish\fR never requires a 2FA prompt, regardless of token type. This is what makes it suitable for automated workflows. The goal of \fBnpm stage publish\fR is deferring proof-of-presence to a later point in time.
+.P
+| Token Type | \fBnpm stage publish\fR | \fBnpm publish\fR | | --- | --- | --- | | GAT with bypass | Can stage | Can publish (if allowed by package publishing access) | | GAT without bypass | Can stage | 2FA prompt (if allowed by package publishing access) | | Session token | Can stage | 2FA prompt | | Trust token (OIDC) | Can stage (if allowed) | Can publish (if allowed) |
+.SS "Trust Relationship Permissions"
+.P
+With staged publishing, trust relationships now support granular command permissions. Shortlived tokens issued through trust relationships can only be used with \fBnpm stage publish\fR and \fBnpm publish\fR. Shortlived tokens cannot run \fBnpm stage\fR subcommands.
+.P
+\fBnpm trust <provider>\fR supports \fB--allow-publish\fR and \fB--allow-stage-publish\fR to control which commands are available through each trust relationship.
+.SS "Best Practices"
+.P
+\fBNote:\fR The addition of staged publishing does not make your account or org more secure. Maintainers must still use the best practices listed below.
+.RS 0
+.IP 1. 4
+\fBDelete Granular Access Tokens (GAT) with bypass 2FA enabled.\fR Now with staged publishing, we've eliminated the need for a GAT token that can bypass 2FA. We encourage you to delete all your tokens with bypass enabled and switch to using a trust relationship in your automated workflows, or create a GAT without bypass and use \fBnpm stage publish\fR.
+.IP 2. 4
+\fBDisallow tokens from publishing at the package level.\fR All packages have their own access controls under "package access" allowing packages to be published with bypass tokens, which is no longer a necessity. We encourage you to select "Require two-factor authentication and disallow tokens (recommended)" for all your packages on the package access page.
+.IP 3. 4
+\fBConfigure trust relationship permissions to prevent \fBnpm publish\fB.\fR We encourage you to only enable \fBnpm stage publish\fR on your trust relationships and disable \fBnpm publish\fR.
+.RE 0
+
+.SS "Configuration"
+.SS "\fBnpm stage publish\fR"
+.P
+Stage a package for publishing, deferring proof-of-presence (2FA) to a later point in time
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage publish <package-spec>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--tag\fR | "latest" | String | If you ask npm to install a package and don't tell it a specific version, then it will install the specified tag. It is the tag added to the package@version specified in the \fBnpm dist-tag add\fR command, if no explicit tag is given. When used by the \fBnpm diff\fR command, this is the tag used to fetch the tarball that will be compared with the local files by default. If used in the \fBnpm publish\fR command, this is the tag that will be added to the package submitted to the registry. | | \fB--access\fR | 'public' for new packages, existing packages it will not change the current level | null, "restricted", or "public" | If you do not want your scoped package to be publicly viewable (and installable) set \fB--access=restricted\fR. Unscoped packages cannot be set to \fBrestricted\fR. Note: This defaults to not changing the current access level for existing packages. Specifying a value of \fBrestricted\fR or \fBpublic\fR during publish will change the access for an existing package the same way that \fBnpm access set status\fR would. | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--otp\fR | null | null or String | This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR. If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one. | | \fB--workspace\fR, \fB-w\fR | | String (can be set multiple times) | Enable running a command in the context of the configured workspaces of the current project while filtering by running only the workspaces defined by this configuration option. Valid values for the \fBworkspace\fR config are either: * Workspace names * Path to a workspace directory * Path to a parent workspace directory (will result in selecting all workspaces within that folder) When set for the \fBnpm init\fR command, this may be set to the folder of a workspace which does not yet exist, to create the folder and set it up as a brand new workspace within the project. | | \fB--workspaces\fR | null | null or Boolean | Set to true to run the command in the context of \fBall\fR configured workspaces. Explicitly setting this to false will cause commands like \fBinstall\fR to ignore workspaces altogether. When not set explicitly: - Commands that operate on the \fBnode_modules\fR tree (install, update, etc.) will link workspaces into the \fBnode_modules\fR folder. - Commands that do other things (test, exec, publish, etc.) will operate on the root project, \fIunless\fR one or more workspaces are specified in the \fBworkspace\fR config. | | \fB--include-workspace-root\fR | false | Boolean | Include the workspace root when workspaces are enabled for a command. When false, specifying individual workspaces via the \fBworkspace\fR config, or all workspaces via the \fBworkspaces\fR flag, will cause npm to operate only on the specified workspaces, and not on the root project. | | \fB--provenance\fR | false | Boolean | When publishing from a supported cloud CI/CD system, the package will be publicly linked to where it was built and published from. |
+.SS "\fBnpm stage list\fR"
+.P
+List all staged package versions
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage list \[lB]<package-spec>\[rB]
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "\fBnpm stage view\fR"
+.P
+View details of a specific staged package
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage view <stage-id>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "\fBnpm stage approve\fR"
+.P
+Approve a staged package, publishing it to the npm registry
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage approve <stage-id>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--otp\fR | null | null or String | This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR. If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "\fBnpm stage reject\fR"
+.P
+Reject a staged package, removing it from the registry
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage reject <stage-id>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--otp\fR | null | null or String | This is a one-time password from a two-factor authenticator. It's needed when publishing or changing package permissions with \fBnpm access\fR. If not set, and a registry response fails with a challenge for a one-time password, npm will prompt on the command line for one. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "\fBnpm stage download\fR"
+.P
+Download the tarball of a staged package for inspection
+.SS "Synopsis"
+.P
+.RS 2
+.nf
+npm stage download <stage-id>
+.fi
+.RE
+.SS "Flags"
+.P
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. |
+.SS "See Also"
+.RS 0
+.IP \(bu 4
+npm help publish
+.IP \(bu 4
+npm help unpublish
+.IP \(bu 4
+npm help trust
+.RE 0
diff --git a/deps/npm/man/man1/npm-star.1 b/deps/npm/man/man1/npm-star.1
index ffc44d6728e6c4..ff2f6219714d1b 100644
--- a/deps/npm/man/man1/npm-star.1
+++ b/deps/npm/man/man1/npm-star.1
@@ -1,4 +1,4 @@
-.TH "NPM-STAR" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-STAR" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-star\fR - Mark your favorite packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-stars.1 b/deps/npm/man/man1/npm-stars.1
index 40e1fac243e72e..34f968d1331f75 100644
--- a/deps/npm/man/man1/npm-stars.1
+++ b/deps/npm/man/man1/npm-stars.1
@@ -1,4 +1,4 @@
-.TH "NPM-STARS" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-STARS" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-stars\fR - View packages marked as favorites
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-start.1 b/deps/npm/man/man1/npm-start.1
index e5d324c7a459c5..5af8739d5978e5 100644
--- a/deps/npm/man/man1/npm-start.1
+++ b/deps/npm/man/man1/npm-start.1
@@ -1,4 +1,4 @@
-.TH "NPM-START" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-START" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-start\fR - Start a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-stop.1 b/deps/npm/man/man1/npm-stop.1
index 4f3f31a8111ddb..e869b3a796f120 100644
--- a/deps/npm/man/man1/npm-stop.1
+++ b/deps/npm/man/man1/npm-stop.1
@@ -1,4 +1,4 @@
-.TH "NPM-STOP" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-STOP" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-stop\fR - Stop a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-team.1 b/deps/npm/man/man1/npm-team.1
index a3a69befb065d4..0bc981401b0da4 100644
--- a/deps/npm/man/man1/npm-team.1
+++ b/deps/npm/man/man1/npm-team.1
@@ -1,4 +1,4 @@
-.TH "NPM-TEAM" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-TEAM" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-team\fR - Manage organization teams and team memberships
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-test.1 b/deps/npm/man/man1/npm-test.1
index 50a813a18c1f08..a506a985023502 100644
--- a/deps/npm/man/man1/npm-test.1
+++ b/deps/npm/man/man1/npm-test.1
@@ -1,4 +1,4 @@
-.TH "NPM-TEST" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-TEST" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-test\fR - Test a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-token.1 b/deps/npm/man/man1/npm-token.1
index 396df16d27d5c2..646db6a114a570 100644
--- a/deps/npm/man/man1/npm-token.1
+++ b/deps/npm/man/man1/npm-token.1
@@ -1,4 +1,4 @@
-.TH "NPM-TOKEN" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-TOKEN" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-token\fR - Manage your authentication tokens
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-trust.1 b/deps/npm/man/man1/npm-trust.1
index 91744a56b13b4d..61e2e39efa94fc 100644
--- a/deps/npm/man/man1/npm-trust.1
+++ b/deps/npm/man/man1/npm-trust.1
@@ -1,4 +1,4 @@
-.TH "NPM-TRUST" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-TRUST" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-trust\fR - Manage trusted publishing relationships between packages and CI/CD providers
 .SS "Synopsis"
@@ -29,6 +29,19 @@ For a comprehensive overview of trusted publishing, see the \fBnpm trusted publi
 The \fB\[lB]package\[rB]\fR argument specifies the package name. If omitted, npm will use the name from the \fBpackage.json\fR in the current directory.
 .P
 Each trust relationship has its own set of configuration options and flags based on the OIDC claims provided by that provider. OIDC claims come from the CI/CD provider and include information such as repository name, workflow file, or environment. Since each provider's claims differ, the available flags and configuration keys are not universal\[em]npm matches the claims supported by each provider's OIDC configuration. For specific details on which claims and flags are supported for a given provider, use \fBnpm trust <provider> --help\fR.
+.SS "Permissions"
+.P
+When creating a trust relationship, you must specify at least one permission flag to indicate which operations the trusted publisher is allowed to perform:
+.RS 0
+.IP \(bu 4
+\fB--allow-publish\fR: Allows the trusted publisher to run \fBnpm publish\fR for the package.
+.IP \(bu 4
+\fB--allow-stage-publish\fR: Allows the trusted publisher to run \fBnpm stage\fR for the package. The alias \fB--allow-staged-publish\fR is also accepted.
+.RE 0
+
+.P
+At least one of these flags is required when creating a trust configuration. You can specify both to grant both permissions.
+.SS "Provider Options"
 .P
 The required options depend on the CI/CD provider you're configuring. Detailed information about each option is available in the \fBmanaging trusted publisher configurations\fR \fI\(lahttps://docs.npmjs.com/trusted-publishers#managing-trusted-publisher-configurations\(ra\fR section of the npm documentation. If a provider is repository-based and the option is not provided, npm will use the \fBrepository.url\fR field from your \fBpackage.json\fR, if available.
 .P
@@ -57,12 +70,12 @@ Create a trusted relationship between a package and GitHub Actions
 .P
 .RS 2
 .nf
-npm trust github \[lB]package\[rB] --file \[lB]--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]-y|--yes\[rB]
+npm trust github \[lB]package\[rB] --file \[lB]--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]--allow-publish\[rB] \[lB]--allow-stage-publish\[rB] \[lB]-y|--yes\[rB]
 .fi
 .RE
 .SS "Flags"
 .P
-| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of workflow file within a repositories .GitHub folder (must end in yaml, yml) | | \fB--repository\fR, \fB--repo\fR | null | String | Name of the repository in the format owner/repo | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of workflow file within a repositories .GitHub folder (must end in yaml, yml) | | \fB--repository\fR, \fB--repo\fR | null | String | Name of the repository in the format owner/repo | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--allow-publish\fR | false | Boolean | Allow npm publish for this trusted publisher configuration | | \fB--allow-stage-publish\fR, \fB--allow-staged-publish\fR | false | Boolean | Allow npm stage publish for this trusted publisher configuration | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
 .SS "\fBnpm trust gitlab\fR"
 .P
 Create a trusted relationship between a package and GitLab CI/CD
@@ -70,12 +83,12 @@ Create a trusted relationship between a package and GitLab CI/CD
 .P
 .RS 2
 .nf
-npm trust gitlab \[lB]package\[rB] --file \[lB]--project|--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]-y|--yes\[rB]
+npm trust gitlab \[lB]package\[rB] --file \[lB]--project|--repo|--repository\[rB] \[lB]--env|--environment\[rB] \[lB]--allow-publish\[rB] \[lB]--allow-stage-publish\[rB] \[lB]-y|--yes\[rB]
 .fi
 .RE
 .SS "Flags"
 .P
-| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of pipeline file (e.g., .gitlab-ci.yml) | | \fB--project\fR | null | String | Name of the project in the format group/project or group/subgroup/project | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--file\fR | null | String (required) | Name of pipeline file (e.g., .gitlab-ci.yml) | | \fB--project\fR | null | String | Name of the project in the format group/project or group/subgroup/project | | \fB--environment\fR, \fB--env\fR | null | String | CI environment name | | \fB--allow-publish\fR | false | Boolean | Allow npm publish for this trusted publisher configuration | | \fB--allow-stage-publish\fR, \fB--allow-staged-publish\fR | false | Boolean | Allow npm stage publish for this trusted publisher configuration | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
 .SS "\fBnpm trust circleci\fR"
 .P
 Create a trusted relationship between a package and CircleCI
@@ -83,12 +96,12 @@ Create a trusted relationship between a package and CircleCI
 .P
 .RS 2
 .nf
-npm trust circleci \[lB]package\[rB] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> \[lB]--context-id <uuid>...\[rB] \[lB]-y|--yes\[rB]
+npm trust circleci \[lB]package\[rB] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> \[lB]--context-id <uuid>...\[rB] \[lB]--allow-publish\[rB] \[lB]--allow-stage-publish\[rB] \[lB]-y|--yes\[rB]
 .fi
 .RE
 .SS "Flags"
 .P
-| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--org-id\fR | null | String (required) | CircleCI organization UUID | | \fB--project-id\fR | null | String (required) | CircleCI project UUID | | \fB--pipeline-definition-id\fR | null | String (required) | CircleCI pipeline definition UUID | | \fB--vcs-origin\fR | null | String (required) | CircleCI repository origin in format 'provider/owner/repo' | | \fB--context-id\fR | null | null or String (can be set multiple times) | CircleCI context UUID to match | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
+| Flag | Default | Type | Description | | --- | --- | --- | --- | | \fB--org-id\fR | null | String (required) | CircleCI organization UUID | | \fB--project-id\fR | null | String (required) | CircleCI project UUID | | \fB--pipeline-definition-id\fR | null | String (required) | CircleCI pipeline definition UUID | | \fB--vcs-origin\fR | null | String (required) | CircleCI repository origin in format 'provider/owner/repo' | | \fB--context-id\fR | null | null or String (can be set multiple times) | CircleCI context UUID to match | | \fB--allow-publish\fR | false | Boolean | Allow npm publish for this trusted publisher configuration | | \fB--allow-stage-publish\fR, \fB--allow-staged-publish\fR | false | Boolean | Allow npm stage publish for this trusted publisher configuration | | \fB--dry-run\fR | false | Boolean | Indicates that you don't want npm to make any changes and that it should only report what it would have done. This can be passed into any of the commands that modify your local installation, eg, \fBinstall\fR, \fBupdate\fR, \fBdedupe\fR, \fBuninstall\fR, as well as \fBpack\fR and \fBpublish\fR. Note: This is NOT honored by other network related commands, eg \fBdist-tags\fR, \fBowner\fR, etc. | | \fB--json\fR | false | Boolean | Whether or not to output JSON data, rather than the normal output. * In \fBnpm pkg set\fR it enables parsing set values with JSON.parse() before saving them to your \fBpackage.json\fR. Not supported by all npm commands. | | \fB--registry\fR | "https://registry.npmjs.org/" | URL | The base URL of the npm registry. | | \fB--yes\fR, \fB-y\fR | null | null or Boolean | Automatically answer "yes" to any prompts that npm might print on the command line. |
 .SS "\fBnpm trust list\fR"
 .P
 List trusted relationships for a package
diff --git a/deps/npm/man/man1/npm-undeprecate.1 b/deps/npm/man/man1/npm-undeprecate.1
index 86b6ed7fc73ae7..46d9f977f7c98a 100644
--- a/deps/npm/man/man1/npm-undeprecate.1
+++ b/deps/npm/man/man1/npm-undeprecate.1
@@ -1,4 +1,4 @@
-.TH "NPM-UNDEPRECATE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-UNDEPRECATE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-undeprecate\fR - Undeprecate a version of a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-uninstall.1 b/deps/npm/man/man1/npm-uninstall.1
index 0d89545bc3d13a..d58ca50d2ba9ce 100644
--- a/deps/npm/man/man1/npm-uninstall.1
+++ b/deps/npm/man/man1/npm-uninstall.1
@@ -1,4 +1,4 @@
-.TH "NPM-UNINSTALL" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-UNINSTALL" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-uninstall\fR - Remove a package
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-unpublish.1 b/deps/npm/man/man1/npm-unpublish.1
index 465ee175b738e8..bc1c5ed7b2c5ba 100644
--- a/deps/npm/man/man1/npm-unpublish.1
+++ b/deps/npm/man/man1/npm-unpublish.1
@@ -1,4 +1,4 @@
-.TH "NPM-UNPUBLISH" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-UNPUBLISH" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-unpublish\fR - Remove a package from the registry
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-unstar.1 b/deps/npm/man/man1/npm-unstar.1
index 60a6e600a49ddc..bb96432baee821 100644
--- a/deps/npm/man/man1/npm-unstar.1
+++ b/deps/npm/man/man1/npm-unstar.1
@@ -1,4 +1,4 @@
-.TH "NPM-UNSTAR" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-UNSTAR" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-unstar\fR - Remove an item from your favorite packages
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-update.1 b/deps/npm/man/man1/npm-update.1
index 0eacbf369b37d5..75aa70256aff10 100644
--- a/deps/npm/man/man1/npm-update.1
+++ b/deps/npm/man/man1/npm-update.1
@@ -1,4 +1,4 @@
-.TH "NPM-UPDATE" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-UPDATE" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-update\fR - Update packages
 .SS "Synopsis"
@@ -300,7 +300,7 @@ If passed to \fBnpm install\fR, will rebuild the npm tree such that only version
 .P
 If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
 .P
-This config cannot be used with: \fBmin-release-age\fR
+If \fBbefore\fR and \fBmin-release-age\fR are both set in the same source, \fBbefore\fR wins (an explicit absolute date overrides a relative window). Across sources, the standard precedence applies (cli > env > project > user > global), so a higher-priority source can always relax or override a lower-priority one.
 .SS "\fBmin-release-age\fR"
 .RS 0
 .IP \(bu 4
@@ -312,9 +312,7 @@ Type: null or Number
 .P
 If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
 .P
-This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
-.P
-This config cannot be used with: \fBbefore\fR
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days. The two may coexist (e.g. \fBmin-release-age\fR in your \fB.npmrc\fR is preserved when npm internally spawns a sub-process with \fB--before\fR while preparing a \fBgit:\fR or \fBgithub:\fR dependency); when both apply, \fBbefore\fR wins within a single source and across sources the standard precedence rules apply.
 .P
 This value is not exported to the environment for child processes.
 .SS "\fBbin-links\fR"
diff --git a/deps/npm/man/man1/npm-version.1 b/deps/npm/man/man1/npm-version.1
index 70feae9fc4509b..7321a301400e4a 100644
--- a/deps/npm/man/man1/npm-version.1
+++ b/deps/npm/man/man1/npm-version.1
@@ -1,4 +1,4 @@
-.TH "NPM-VERSION" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-VERSION" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-version\fR - Bump a package version
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-view.1 b/deps/npm/man/man1/npm-view.1
index e587954fc4be25..0ef6c63b3dc6d8 100644
--- a/deps/npm/man/man1/npm-view.1
+++ b/deps/npm/man/man1/npm-view.1
@@ -1,4 +1,4 @@
-.TH "NPM-VIEW" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-VIEW" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-view\fR - View registry info
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm-whoami.1 b/deps/npm/man/man1/npm-whoami.1
index a944920ca2e7c5..e7f660e4628eaa 100644
--- a/deps/npm/man/man1/npm-whoami.1
+++ b/deps/npm/man/man1/npm-whoami.1
@@ -1,4 +1,4 @@
-.TH "NPM-WHOAMI" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-WHOAMI" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-whoami\fR - Display npm username
 .SS "Synopsis"
diff --git a/deps/npm/man/man1/npm.1 b/deps/npm/man/man1/npm.1
index a32d7b13b182e9..e2f3b3e81bb9f5 100644
--- a/deps/npm/man/man1/npm.1
+++ b/deps/npm/man/man1/npm.1
@@ -1,4 +1,4 @@
-.TH "NPM" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPM" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm\fR - javascript package manager
 .SS "Synopsis"
@@ -12,7 +12,7 @@ npm
 Note: This command is unaware of workspaces.
 .SS "Version"
 .P
-11.13.0
+11.15.0
 .SS "Description"
 .P
 npm is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently.
diff --git a/deps/npm/man/man1/npx.1 b/deps/npm/man/man1/npx.1
index 8878334eb8a297..cfe09b033681af 100644
--- a/deps/npm/man/man1/npx.1
+++ b/deps/npm/man/man1/npx.1
@@ -1,4 +1,4 @@
-.TH "NPX" "1" "April 2026" "NPM@11.13.0" ""
+.TH "NPX" "1" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpx\fR - Run a command from a local or remote npm package
 .SS "Synopsis"
diff --git a/deps/npm/man/man5/folders.5 b/deps/npm/man/man5/folders.5
index c9d7a23cfd2916..b7eb083b084bb5 100644
--- a/deps/npm/man/man5/folders.5
+++ b/deps/npm/man/man5/folders.5
@@ -1,4 +1,4 @@
-.TH "FOLDERS" "5" "April 2026" "NPM@11.13.0" ""
+.TH "FOLDERS" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBFolders\fR - Folder structures used by npm
 .SS "Description"
diff --git a/deps/npm/man/man5/install.5 b/deps/npm/man/man5/install.5
index c43ef43f621d5d..c5e7b921cd50dd 100644
--- a/deps/npm/man/man5/install.5
+++ b/deps/npm/man/man5/install.5
@@ -1,4 +1,4 @@
-.TH "INSTALL" "5" "April 2026" "NPM@11.13.0" ""
+.TH "INSTALL" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBInstall\fR - Download and install node and npm
 .SS "Description"
diff --git a/deps/npm/man/man5/npm-global.5 b/deps/npm/man/man5/npm-global.5
index c9d7a23cfd2916..b7eb083b084bb5 100644
--- a/deps/npm/man/man5/npm-global.5
+++ b/deps/npm/man/man5/npm-global.5
@@ -1,4 +1,4 @@
-.TH "FOLDERS" "5" "April 2026" "NPM@11.13.0" ""
+.TH "FOLDERS" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBFolders\fR - Folder structures used by npm
 .SS "Description"
diff --git a/deps/npm/man/man5/npm-json.5 b/deps/npm/man/man5/npm-json.5
index f26a307d85a111..0d4d8d0480c8cd 100644
--- a/deps/npm/man/man5/npm-json.5
+++ b/deps/npm/man/man5/npm-json.5
@@ -1,4 +1,4 @@
-.TH "PACKAGE.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.TH "PACKAGE.JSON" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBpackage.json\fR - Specifics of npm's package.json handling
 .SS "Description"
diff --git a/deps/npm/man/man5/npm-shrinkwrap-json.5 b/deps/npm/man/man5/npm-shrinkwrap-json.5
index dff972eeacec67..68d66807e0f5c6 100644
--- a/deps/npm/man/man5/npm-shrinkwrap-json.5
+++ b/deps/npm/man/man5/npm-shrinkwrap-json.5
@@ -1,4 +1,4 @@
-.TH "NPM-SHRINKWRAP.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.TH "NPM-SHRINKWRAP.JSON" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBnpm-shrinkwrap.json\fR - A publishable lockfile
 .SS "Description"
diff --git a/deps/npm/man/man5/npmrc.5 b/deps/npm/man/man5/npmrc.5
index ff767b87c10dcb..3cf3729867b79d 100644
--- a/deps/npm/man/man5/npmrc.5
+++ b/deps/npm/man/man5/npmrc.5
@@ -1,4 +1,4 @@
-.TH ".NPMRC" "5" "April 2026" "NPM@11.13.0" ""
+.TH ".NPMRC" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fB.npmrc\fR - The npm config files
 .SS "Description"
diff --git a/deps/npm/man/man5/package-json.5 b/deps/npm/man/man5/package-json.5
index f26a307d85a111..0d4d8d0480c8cd 100644
--- a/deps/npm/man/man5/package-json.5
+++ b/deps/npm/man/man5/package-json.5
@@ -1,4 +1,4 @@
-.TH "PACKAGE.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.TH "PACKAGE.JSON" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBpackage.json\fR - Specifics of npm's package.json handling
 .SS "Description"
diff --git a/deps/npm/man/man5/package-lock-json.5 b/deps/npm/man/man5/package-lock-json.5
index f66b38335b28ff..7e0bd7fcd68729 100644
--- a/deps/npm/man/man5/package-lock-json.5
+++ b/deps/npm/man/man5/package-lock-json.5
@@ -1,4 +1,4 @@
-.TH "PACKAGE-LOCK.JSON" "5" "April 2026" "NPM@11.13.0" ""
+.TH "PACKAGE-LOCK.JSON" "5" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBpackage-lock.json\fR - A manifestation of the manifest
 .SS "Description"
diff --git a/deps/npm/man/man7/config.7 b/deps/npm/man/man7/config.7
index 1b93498c84818e..3dcb6d67ecea85 100644
--- a/deps/npm/man/man7/config.7
+++ b/deps/npm/man/man7/config.7
@@ -1,4 +1,4 @@
-.TH "CONFIG" "7" "April 2026" "NPM@11.13.0" ""
+.TH "CONFIG" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBConfig\fR - About npm configuration
 .SS "Description"
@@ -194,6 +194,30 @@ Type: Boolean
 
 .P
 When running \fBnpm outdated\fR and \fBnpm ls\fR, setting \fB--all\fR will show all outdated or installed packages, rather than only those directly depended upon by the current project.
+.SS "\fBallow-directory\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from directories. That is, dependencies that point to a directory instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any directories to be installed. \fBnone\fR prevents any directories from being installed. \fBroot\fR only allows directories defined in your project's package.json to be installed. Also allows directory dependencies to be used for other commands like \fBnpm view\fR
+.SS "\fBallow-file\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to install dependencies from tarball files. That is, dependencies that point to a local tarball file instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any tarball file to be installed. \fBnone\fR prevents any tarball file from being installed. \fBroot\fR only allows tarball files defined in your project's package.json to be installed. Also allows tarball file dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-git\fR"
 .RS 0
 .IP \(bu 4
@@ -203,9 +227,21 @@ Type: "all", "none", or "root"
 .RE 0
 
 .P
-Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+Limits the ability for npm to fetch dependencies from git references. That is, dependencies that point to a git repo instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
+.P
+\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched and installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+.SS "\fBallow-remote\fR"
+.RS 0
+.IP \(bu 4
+Default: "all"
+.IP \(bu 4
+Type: "all", "none", or "root"
+.RE 0
+
+.P
+Limits the ability for npm to fetch dependencies from urls. That is, dependencies that point to a tarball url instead of a version or semver range. Please note that this could leave your tree incomplete and some packages may not function as intended or designed. Changing this setting will not remove dependencies that are already installed.
 .P
-\fBall\fR allows any git dependencies to be fetched and installed. \fBnone\fR prevents any git dependencies from being fetched and installed. \fBroot\fR only allows git dependencies defined in your project's package.json to be fetched installed. Also allows git dependencies to be fetched for other commands like \fBnpm view\fR
+\fBall\fR allows any url to be installed. \fBnone\fR prevents any url from being installed. \fBroot\fR only allows urls defined in your project's package.json to be installed. Also allows url dependencies to be used for other commands like \fBnpm view\fR
 .SS "\fBallow-same-version\fR"
 .RS 0
 .IP \(bu 4
@@ -259,7 +295,7 @@ If passed to \fBnpm install\fR, will rebuild the npm tree such that only version
 .P
 If the requested version is a \fBdist-tag\fR and the given tag does not pass the \fB--before\fR filter, the most recent version less than or equal to that tag will be used. For example, \fBfoo@latest\fR might install \fBfoo@1.2\fR even though \fBlatest\fR is \fB2.0\fR.
 .P
-This config cannot be used with: \fBmin-release-age\fR
+If \fBbefore\fR and \fBmin-release-age\fR are both set in the same source, \fBbefore\fR wins (an explicit absolute date overrides a relative window). Across sources, the standard precedence applies (cli > env > project > user > global), so a higher-priority source can always relax or override a lower-priority one.
 .SS "\fBbin-links\fR"
 .RS 0
 .IP \(bu 4
@@ -1116,9 +1152,7 @@ Type: null or Number
 .P
 If set, npm will build the npm tree such that only versions that were available more than the given number of days ago will be installed. If there are no versions available for the current set of dependencies, the command will error.
 .P
-This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days.
-.P
-This config cannot be used with: \fBbefore\fR
+This flag is a complement to \fBbefore\fR, which accepts an exact date instead of a relative number of days. The two may coexist (e.g. \fBmin-release-age\fR in your \fB.npmrc\fR is preserved when npm internally spawns a sub-process with \fB--before\fR while preparing a \fBgit:\fR or \fBgithub:\fR dependency); when both apply, \fBbefore\fR wins within a single source and across sources the standard precedence rules apply.
 .P
 This value is not exported to the environment for child processes.
 .SS "\fBname\fR"
diff --git a/deps/npm/man/man7/dependency-selectors.7 b/deps/npm/man/man7/dependency-selectors.7
index 3b5e9f8faa2333..95849879c7256f 100644
--- a/deps/npm/man/man7/dependency-selectors.7
+++ b/deps/npm/man/man7/dependency-selectors.7
@@ -1,4 +1,4 @@
-.TH "SELECTORS" "7" "April 2026" "NPM@11.13.0" ""
+.TH "SELECTORS" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBSelectors\fR - Dependency Selector Syntax & Querying
 .SS "Description"
diff --git a/deps/npm/man/man7/developers.7 b/deps/npm/man/man7/developers.7
index 6ed01ced244362..2f7d9113a180bc 100644
--- a/deps/npm/man/man7/developers.7
+++ b/deps/npm/man/man7/developers.7
@@ -1,4 +1,4 @@
-.TH "DEVELOPERS" "7" "April 2026" "NPM@11.13.0" ""
+.TH "DEVELOPERS" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBDevelopers\fR - Developer guide
 .SS "Description"
diff --git a/deps/npm/man/man7/logging.7 b/deps/npm/man/man7/logging.7
index 0a114670022595..f5c65d13c25680 100644
--- a/deps/npm/man/man7/logging.7
+++ b/deps/npm/man/man7/logging.7
@@ -1,4 +1,4 @@
-.TH "LOGGING" "7" "April 2026" "NPM@11.13.0" ""
+.TH "LOGGING" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBLogging\fR - Why, What & How we Log
 .SS "Description"
diff --git a/deps/npm/man/man7/orgs.7 b/deps/npm/man/man7/orgs.7
index 502ef7d6f9b521..d9c76b7bc683cd 100644
--- a/deps/npm/man/man7/orgs.7
+++ b/deps/npm/man/man7/orgs.7
@@ -1,4 +1,4 @@
-.TH "ORGANIZATIONS" "7" "April 2026" "NPM@11.13.0" ""
+.TH "ORGANIZATIONS" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBOrganizations\fR - Working with teams & organizations
 .SS "Description"
diff --git a/deps/npm/man/man7/package-spec.7 b/deps/npm/man/man7/package-spec.7
index 3644ebecde9732..9e4eb36e857b0f 100644
--- a/deps/npm/man/man7/package-spec.7
+++ b/deps/npm/man/man7/package-spec.7
@@ -1,4 +1,4 @@
-.TH "SPEC" "7" "April 2026" "NPM@11.13.0" ""
+.TH "SPEC" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBspec\fR - Package name specifier
 .SS "Description"
diff --git a/deps/npm/man/man7/registry.7 b/deps/npm/man/man7/registry.7
index 62edddcc6d591b..41ce62cdc6b792 100644
--- a/deps/npm/man/man7/registry.7
+++ b/deps/npm/man/man7/registry.7
@@ -1,4 +1,4 @@
-.TH "REGISTRY" "7" "April 2026" "NPM@11.13.0" ""
+.TH "REGISTRY" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBRegistry\fR - The JavaScript Package Registry
 .SS "Description"
diff --git a/deps/npm/man/man7/removal.7 b/deps/npm/man/man7/removal.7
index 3758202663fa2e..144c6ca788afc6 100644
--- a/deps/npm/man/man7/removal.7
+++ b/deps/npm/man/man7/removal.7
@@ -1,4 +1,4 @@
-.TH "REMOVAL" "7" "April 2026" "NPM@11.13.0" ""
+.TH "REMOVAL" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBRemoval\fR - Cleaning the slate
 .SS "Synopsis"
diff --git a/deps/npm/man/man7/scope.7 b/deps/npm/man/man7/scope.7
index fec92c73e43eab..7491b29be87116 100644
--- a/deps/npm/man/man7/scope.7
+++ b/deps/npm/man/man7/scope.7
@@ -1,4 +1,4 @@
-.TH "SCOPE" "7" "April 2026" "NPM@11.13.0" ""
+.TH "SCOPE" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBScope\fR - Scoped packages
 .SS "Description"
diff --git a/deps/npm/man/man7/scripts.7 b/deps/npm/man/man7/scripts.7
index f6d85659db5872..4c24ce5e54c772 100644
--- a/deps/npm/man/man7/scripts.7
+++ b/deps/npm/man/man7/scripts.7
@@ -1,4 +1,4 @@
-.TH "SCRIPTS" "7" "April 2026" "NPM@11.13.0" ""
+.TH "SCRIPTS" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBScripts\fR - How npm handles the "scripts" field
 .SS "Description"
diff --git a/deps/npm/man/man7/workspaces.7 b/deps/npm/man/man7/workspaces.7
index e32fbf3c9b124f..9cd6628201a000 100644
--- a/deps/npm/man/man7/workspaces.7
+++ b/deps/npm/man/man7/workspaces.7
@@ -1,4 +1,4 @@
-.TH "WORKSPACES" "7" "April 2026" "NPM@11.13.0" ""
+.TH "WORKSPACES" "7" "May 2026" "NPM@11.15.0" ""
 .SH "NAME"
 \fBWorkspaces\fR - Working with workspaces
 .SS "Description"
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js
index fdbbd4679bd80a..f16844ea73d7d1 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js
@@ -13,7 +13,6 @@ const { lstat, readlink } = require('node:fs/promises')
 const { depth } = require('treeverse')
 const { log, time } = require('proc-log')
 const { redact } = require('@npmcli/redact')
-const semver = require('semver')
 
 const {
   OK,
@@ -29,6 +28,15 @@ const Shrinkwrap = require('../shrinkwrap.js')
 const { defaultLockfileVersion } = Shrinkwrap
 const Node = require('../node.js')
 const Link = require('../link.js')
+
+// Maps a parsed spec.type to the corresponding allow-* arborist option name.
+// Hoisted to module scope so #checkAllow doesn't re-allocate it per call.
+const ALLOW_OPTION_FOR_TYPE = {
+  git: 'allowGit',
+  remote: 'allowRemote',
+  file: 'allowFile',
+  directory: 'allowDirectory',
+}
 const addRmPkgDeps = require('../add-rm-pkg-deps.js')
 const optionalSet = require('../optional-set.js')
 const { checkEngine, checkPlatform } = require('npm-install-checks')
@@ -294,10 +302,6 @@ module.exports = cls => class IdealTreeBuilder extends cls {
           }).then(meta => Object.assign(root, { meta }))
         } else {
           return this.loadVirtual({ root })
-            .then(tree => {
-              this.#applyRootOverridesToWorkspaces(tree)
-              return tree
-            })
         }
       })
 
@@ -406,6 +410,7 @@ module.exports = cls => class IdealTreeBuilder extends cls {
         global: this.options.global,
         installLinks: this.installLinks,
         legacyPeerDeps: this.legacyPeerDeps,
+        loadOverrides: true,
         root,
       })
     }
@@ -450,6 +455,11 @@ module.exports = cls => class IdealTreeBuilder extends cls {
       const paths = await readdirScoped(nm).catch(() => [])
       for (const p of paths) {
         const name = p.replace(/\\/g, '/')
+        // Match loadActual behavior: hidden entries and retired scoped package
+        // folders are not installed global packages.
+        if (/^(@[^/]+\/)?\./.test(name)) {
+          continue
+        }
         const updateName = this[_updateNames].includes(name)
         if (this[_updateAll] || updateName) {
           if (updateName) {
@@ -648,6 +658,45 @@ module.exports = cls => class IdealTreeBuilder extends cls {
     return vuln.range
   }
 
+  // Enforces the allow-git / allow-file / allow-directory / allow-remote configs at the arborist resolution layer, before any branching into the symlink (Link) path or the manifest-fetch path.
+  // Pacote also enforces these inside FetcherBase.get() as defense-in-depth, but the symlink branch never reaches pacote, and the manifest cache here would bypass pacote on a cached hit.
+  // Throws the same { code: EALLOW${TYPE} } shape pacote uses, so callers and downstream consumers stay consistent.
+  #checkAllow (spec, edge) {
+    const optName = ALLOW_OPTION_FOR_TYPE[spec.type]
+    if (!optName) {
+      return
+    }
+    const allow = this.options[optName] ?? 'all'
+    if (allow === 'all') {
+      return
+    }
+    const isRoot = !!(edge?.from?.isProjectRoot || edge?.from?.isWorkspace)
+    if (allow !== 'none' && isRoot) {
+      return
+    }
+    throw Object.assign(
+      new Error(`Fetching${allow === 'root' ? ' non-root' : ''} packages of type "${spec.type}" have been disabled`),
+      {
+        code: `EALLOW${spec.type.toUpperCase()}`,
+        package: spec.toString(),
+      }
+    )
+  }
+
+  // Builds a Node representing a spec we failed to load (allow-* gate, network failure, ENOTARGET, etc.) and records it in #loadFailures so #pruneFailedOptional can later decide whether the failure is fatal or silently dropped for optional deps.
+  #failureNode (name, parent, error, edge) {
+    error.requiredBy = edge?.from?.location || '.'
+    const n = new Node({
+      name,
+      parent,
+      error,
+      installLinks: this.installLinks,
+      legacyPeerDeps: this.legacyPeerDeps,
+    })
+    this.#loadFailures.add(n)
+    return n
+  }
+
   #queueNamedUpdates () {
     // ignore top nodes, since they are not loaded the same way, and
     // probably have their own project associated with them.
@@ -913,8 +962,21 @@ This is a one-time fix-up, please be patient...
       // be forced to agree on a version of z.
       const required = new Set([edge.from])
       const parent = edge.peer ? virtualRoot : null
-      const dep = vrDep && vrDep.satisfies(edge) ? vrDep
-        : await this.#nodeFromEdge(edge, parent, null, required)
+      let dep = vrDep && vrDep.satisfies(edge) ? vrDep : null
+
+      // A peerOptional conflict can be resolved by finding an existing node in the tree that satisfies the edge, avoiding a registry fetch that may introduce an extraneous package. See npm/cli#9249.
+      // Skip the shortcut when the user has signaled an explicit re-fetch intent (npm update by name, explicit request, or audit fix), so we honor those signals rather than silently keeping the existing node.
+      const skipExistingShortcut = this[_updateNames].includes(edge.name)
+        || this.#explicitRequests.has(edge)
+        || (edge.to && this.auditReport?.isVulnerable(edge.to))
+      if (!dep && edge.type === 'peerOptional' && !skipExistingShortcut) {
+        dep = this.#findHoistableNode(
+          /* istanbul ignore next - resolveParent is always set for non-root nodes */
+          edge.from.resolveParent || edge.from, edge)
+      }
+      if (!dep) {
+        dep = await this.#nodeFromEdge(edge, parent, null, required)
+      }
 
       /* istanbul ignore next */
       debug(() => {
@@ -1026,7 +1088,7 @@ This is a one-time fix-up, please be patient...
             // This can't be changed or removed till we figure out why
             // The test is named "tarball deps with transitive tarball deps"
             promises.push(() =>
-              this.#fetchManifest(npa.resolve(e.name, e.spec, fromPath(placed, e)), parent)
+              this.#fetchManifest(npa.resolve(e.name, e.spec, fromPath(placed, e)), parent, e)
                 .catch(() => null)
             )
           }
@@ -1044,6 +1106,24 @@ This is a one-time fix-up, please be patient...
     return this.#buildDepStep()
   }
 
+  // BFS descendants of `root` for a node satisfying `edge`.
+  // Prefers nodes closer to root.  Skips bundled nodes.
+  #findHoistableNode (root, edge) {
+    const queue = [...root.children.values()]
+    while (queue.length) {
+      const node = queue.shift()
+      if (node.name === edge.name
+        && !node.inDepBundle
+        && node.satisfies(edge)) {
+        return node
+      }
+      for (const child of node.children.values()) {
+        queue.push(child)
+      }
+    }
+    return null
+  }
+
   // loads a node from an edge, and then loads its peer deps (and their peer deps, on down the line) into a virtual root parent.
   async #nodeFromEdge (edge, parent_, secondEdge, required) {
     // create a virtual root node with the same deps as the node that is requesting this one, so that we can get all the peer deps in a context where they're likely to be resolvable.
@@ -1199,12 +1279,14 @@ This is a one-time fix-up, please be patient...
     return problems
   }
 
-  async #fetchManifest (spec, parent) {
+  async #fetchManifest (spec, parent, edge) {
+    // Enforce allow-* gates before consulting the manifest cache so a cached entry from a different edge cannot bypass the policy.
+    this.#checkAllow(spec, edge)
     const options = {
       ...this.options,
       avoid: this.#avoidRange(spec.name),
       fullMetadata: true,
-      _isRoot: parent?.isProjectRoot || parent?.isWorkspace,
+      _isRoot: !!(edge?.from?.isProjectRoot || edge?.from?.isWorkspace),
     }
     // get the intended spec and stored metadata from yarn.lock file,
     // if available and valid.
@@ -1221,6 +1303,14 @@ This is a one-time fix-up, please be patient...
   }
 
   async #nodeFromSpec (name, spec, parent, edge) {
+    // Enforce allow-git / allow-file / allow-directory / allow-remote before any branching, so the symlink (Link) path is enforced as well as the manifest-fetch path.
+    // Route the failure through #loadFailures so optional-dep semantics apply (e.g. a transitive optionalDependencies entry that resolves to a disallowed git URL is silently dropped rather than failing the install).
+    try {
+      this.#checkAllow(spec, edge)
+    } catch (error) {
+      return this.#failureNode(name, parent, error, edge)
+    }
+
     // pacote will slap integrity on its options, so we have to clone the object so it doesn't get mutated.
     // Don't bother to load the manifest for link deps, because the target might be within another package that doesn't exist yet.
     const { installLinks, legacyPeerDeps } = this
@@ -1275,23 +1365,26 @@ This is a one-time fix-up, please be patient...
 
     // spec isn't a directory, and either isn't a workspace or the workspace we have
     // doesn't satisfy the edge. try to fetch a manifest and build a node from that.
-    return this.#fetchManifest(spec, parent)
-      .then(pkg => new Node({ name, pkg, parent, installLinks, legacyPeerDeps }), error => {
-        error.requiredBy = edge.from.location || '.'
-
-        // failed to load the spec, either because of enotarget or
-        // fetch failure of some other sort.  save it so we can verify
-        // later that it's optional; otherwise, the error is fatal.
-        const n = new Node({
-          name,
-          parent,
-          error,
-          installLinks,
-          legacyPeerDeps,
-        })
-        this.#loadFailures.add(n)
-        return n
-      })
+    return this.#fetchManifest(spec, parent, edge)
+      .then(
+        pkg => {
+          // When a proxy/upstream registry returns an incomplete manifest
+          // (e.g. missing version field for platform-specific packages it
+          // hasn't cached), treat it as a load failure so that optional deps
+          // are properly pruned instead of written to the lockfile without
+          // version metadata.  Only apply to registry specs — file: deps
+          // legitimately omit version.
+          if (!pkg.version && spec.registry) {
+            const error = Object.assign(
+              new Error(`incomplete manifest for ${name}, missing version`),
+              { code: 'EINCOMPLETEMANIFEST' }
+            )
+            return this.#failureNode(name, parent, error, edge)
+          }
+          return new Node({ name, pkg, parent, installLinks, legacyPeerDeps })
+        },
+        error => this.#failureNode(name, parent, error, edge)
+      )
   }
 
   // load all peer deps and meta-peer deps into the node's parent
@@ -1507,32 +1600,6 @@ This is a one-time fix-up, please be patient...
     timeEnd()
   }
 
-  #applyRootOverridesToWorkspaces (tree) {
-    const rootOverrides = tree.root.package.overrides || {}
-
-    for (const node of tree.root.inventory.values()) {
-      if (!node.isWorkspace) {
-        continue
-      }
-
-      for (const depName of Object.keys(rootOverrides)) {
-        const edge = node.edgesOut.get(depName)
-        const rootNode = tree.root.children.get(depName)
-
-        // safely skip if either edge or rootNode doesn't exist yet
-        if (!edge || !rootNode) {
-          continue
-        }
-
-        const resolvedRootVersion = rootNode.package.version
-        if (!semver.satisfies(resolvedRootVersion, edge.spec)) {
-          edge.detach()
-          node.children.delete(depName)
-        }
-      }
-    }
-  }
-
   #idealTreePrune () {
     for (const node of this.idealTree.inventory.values()) {
       if (node.extraneous) {
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/index.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/index.js
index 4c1faffa786f35..eda38947462609 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/index.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/index.js
@@ -288,6 +288,16 @@ class Arborist extends Base {
     return ret
   }
 
+  // Build an ideal tree (or reuse an already-built one) and return the
+  // resulting lockfile contents as a string, without writing to disk.
+  // Useful for callers that want to inspect, diff, or store a lockfile
+  // somewhere other than the project's `package-lock.json`.
+  async lockfileString (options = {}) {
+    await this.buildIdealTree(options)
+
+    return this.idealTree.meta.toString(options)
+  }
+
   async dedupe (options = {}) {
     // allow the user to set options on the ctor as well.
     // XXX: deprecate separate method options objects.
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js
index 1f086e97b3cd59..a285da0a45c9a2 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js
@@ -97,7 +97,9 @@ module.exports = cls => class IsolatedReifier extends cls {
     }
     this.counter = 0
 
-    this.idealGraph.workspaces = await Promise.all(Array.from(idealTree.fsChildren.values(), w => this.#workspaceProxy(w)))
+    // Skip extraneous fsChildren: workspaces removed from the root manifest can linger in fsChildren via the lockfile, and re-materializing them here would re-create a directory the user just deleted.
+    const fsChildren = Array.from(idealTree.fsChildren.values()).filter(w => !w.extraneous)
+    this.idealGraph.workspaces = await Promise.all(fsChildren.map(w => this.#workspaceProxy(w)))
     const processed = new Set()
     const queue = [idealTree, ...idealTree.fsChildren]
     while (queue.length !== 0) {
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js
index 26ad0016be3a95..c9f08de776e462 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/arborist/reify.js
@@ -4,6 +4,7 @@ const hgi = require('hosted-git-info')
 const npa = require('npm-package-arg')
 const packageContents = require('@npmcli/installed-package-contents')
 const pacote = require('pacote')
+const { pickRegistry } = require('npm-registry-fetch')
 const promiseAllRejectLate = require('promise-all-reject-late')
 const runScript = require('@npmcli/run-script')
 const { callLimit: promiseCallLimit } = require('promise-call-limit')
@@ -11,7 +12,7 @@ const { depth: dfwalk } = require('treeverse')
 const { dirname, resolve, relative, join, sep } = require('node:path')
 const { log, time } = require('proc-log')
 const { existsSync } = require('node:fs')
-const { lstat, mkdir, readdir, rm, symlink } = require('node:fs/promises')
+const { lstat, mkdir, readdir, readlink, rm, symlink } = require('node:fs/promises')
 const { moveFile } = require('@npmcli/fs')
 const { subset, intersects } = require('semver')
 const { walkUp } = require('walk-up-path')
@@ -126,7 +127,11 @@ module.exports = cls => class Reifier extends cls {
     await this[_diffTrees]()
     await this.#reifyPackages()
     if (linked) {
-      await this.#cleanOrphanedStoreEntries()
+      // The sweep mutates node_modules on disk, so skip it for dry runs and lockfile-only installs (those modes also short-circuit #reifyPackages).
+      // The sweep itself scopes to in-filter workspaces when a filter is active, so it's safe to run for filtered installs too.
+      if (!this.options.dryRun && !this.options.packageLockOnly) {
+        await this.#cleanOrphanedStoreEntries()
+      }
       // swap back in the idealTree
       // so that the lockfile is preserved
       this.idealTree = oldTree
@@ -737,7 +742,14 @@ module.exports = cls => class Reifier extends cls {
         ...this.options,
         resolved: node.resolved,
         integrity: node.integrity,
-        _isRoot: node.parent?.isProjectRoot || node.parent?.isWorkspace,
+        // A node counts as "root" for allow-* enforcement if it satisfies at least one valid dependency edge declared by the project root or a workspace.
+        // node.parent is unsafe here: after hoisting, transitive packages can have the project root as their tree parent.
+        _isRoot: [...node.edgesIn].some(e =>
+          e.valid && (e.from?.isProjectRoot || e.from?.isWorkspace)
+        ),
+        // pacote's npa re-parses our `name@URL` spec as type=remote, so allowRemote would mis-fire on registry tarballs.
+        // Override only when we can prove the URL is registry-mediated; see #isRegistryResolvedTarball.
+        ...(this.#isRegistryResolvedTarball(node) ? { allowRemote: 'all' } : {}),
       })
       // store nodes don't use Node class so node.package doesn't get updated
       if (node.isInStore) {
@@ -861,6 +873,24 @@ module.exports = cls => class Reifier extends cls {
     return wrapper
   }
 
+  // When extracting a registry-resolved package, the spec we hand to pacote is name@URL.
+  // pacote re-parses that with npa and gets spec.type === 'remote', so without an override the allow-remote gate would fire on every registry tarball (both =none and =root mis-fire).
+  // Returns true only when we are confident this is a registry-mediated install: the node's inbound edges must all be registry-typed (no exotic spec smuggled the URL in) AND the resolved URL's host must match the registry npm-registry-fetch selected for this spec, so a tampered lockfile pointing at an attacker host still hits the gate.
+  #isRegistryResolvedTarball (node) {
+    if (!node.resolved || !node.isRegistryDependency) {
+      return false
+    }
+    try {
+      // Hostnames are case-insensitive; lowercase both sides for safety even though WHATWG URL already normalizes.
+      const resolvedHost = new URL(node.resolved).hostname.toLowerCase()
+      // pickRegistry only consults spec.scope, so a bare-name (tag) parse is sufficient and avoids a node.version dependency.
+      const registryHost = new URL(pickRegistry(npa(node.name), this.options)).hostname.toLowerCase()
+      return resolvedHost === registryHost
+    } catch {
+      return false
+    }
+  }
+
   #registryResolved (resolved) {
     // the default registry url is a magic value meaning "the currently
     // configured registry".
@@ -1321,35 +1351,175 @@ module.exports = cls => class Reifier extends cls {
 
   // After a linked install, scan node_modules/.store/ and remove any directories that are not referenced by the current ideal tree.
   // Store entries become orphaned when dependencies are updated or removed, because the diff never sees the old store keys.
+  // Then sweep the top-level node_modules/ for orphaned symlinks (e.g. an uninstalled dep whose store entry was just removed) so we don't leave dangling links.
   async #cleanOrphanedStoreEntries () {
-    const storeDir = resolve(this.path, 'node_modules', '.store')
+    const nmDir = resolve(this.path, 'node_modules')
+    const storeDir = resolve(nmDir, '.store')
+
     let entries
     try {
       entries = await readdir(storeDir)
     } catch {
-      return
+      entries = null
     }
 
-    // Collect valid store keys from the isolated ideal tree (location: node_modules/.store/{key}/node_modules/{pkg})
+    // Collect valid store keys and valid top-level links per node_modules directory.
+    // Store entries have location node_modules/.store/{key}/node_modules/{pkg}.
+    // Top-level links have location {prefix}/node_modules/{pkg} or {prefix}/node_modules/@scope/{pkg}, where {prefix} is empty for the root project and the workspace's localLocation for workspace deps.
+    // Locations are normalized to forward slashes here because IsolatedNode/IsolatedLink locations are built with path.join, which uses backslashes on Windows.
     const validKeys = new Set()
+    const nmDirs = new Map()
+    const NM_PREFIX = 'node_modules/'
+    const STORE_MARKER = '/.store/'
     for (const child of this.idealTree.children.values()) {
+      const loc = child.location.replace(/\\/g, '/')
       if (child.isInStore) {
-        const key = child.location.split(sep)[2]
+        const key = loc.split('/')[2]
         validKeys.add(key)
+        continue
+      }
+      if (!child.isLink) {
+        continue
+      }
+      const nmIdx = loc.lastIndexOf(NM_PREFIX)
+      if (nmIdx === -1 || loc.includes(STORE_MARKER)) {
+        continue
+      }
+      const prefix = loc.slice(0, nmIdx)
+      const dir = resolve(this.path, prefix, 'node_modules')
+      const rest = loc.slice(nmIdx + NM_PREFIX.length)
+      let entry
+      if (rest.startsWith('@')) {
+        const [scope, name] = rest.split('/')
+        entry = `${scope}${sep}${name}`
+      } else {
+        entry = rest.split('/')[0]
+      }
+      let set = nmDirs.get(dir)
+      if (!set) {
+        set = new Set()
+        nmDirs.set(dir, set)
+      }
+      set.add(entry)
+    }
+
+    // Determine which node_modules directories to sweep.
+    // For an unfiltered install, sweep the project root and every workspace's node_modules even if no top-level links remain (e.g. last dep was just uninstalled).
+    // For a filtered install (npm install -w <ws>), restrict the sweep to the in-scope workspaces so out-of-scope workspaces are left untouched, mirroring what the diff would do.
+    // When --include-workspace-root is set, the filter scope pulls in root deps too, so the root node_modules is included in the sweep.
+    const filteredNames = this.options.workspaces
+    const isFiltered = Array.isArray(filteredNames) && filteredNames.length > 0
+    if (isFiltered) {
+      const allowedDirs = new Set()
+      for (const ws of this.idealTree.fsChildren) {
+        if (filteredNames.includes(ws.packageName) || filteredNames.includes(ws.name)) {
+          allowedDirs.add(resolve(ws.path, 'node_modules'))
+        }
+      }
+      if (this.options.includeWorkspaceRoot) {
+        allowedDirs.add(nmDir)
+      }
+      for (const dir of [...nmDirs.keys()]) {
+        if (!allowedDirs.has(dir)) {
+          nmDirs.delete(dir)
+        }
+      }
+      for (const dir of allowedDirs) {
+        if (!nmDirs.has(dir)) {
+          nmDirs.set(dir, new Set())
+        }
+      }
+    } else {
+      if (!nmDirs.has(nmDir)) {
+        nmDirs.set(nmDir, new Set())
+      }
+      for (const ws of this.idealTree.fsChildren) {
+        const wsNmDir = resolve(ws.path, 'node_modules')
+        if (!nmDirs.has(wsNmDir)) {
+          nmDirs.set(wsNmDir, new Set())
+        }
+      }
+    }
+
+    if (entries) {
+      const orphaned = entries.filter(e => !validKeys.has(e))
+      if (orphaned.length) {
+        log.silly('reify', 'cleaning orphaned store entries', orphaned)
+        await promiseAllRejectLate(
+          orphaned.map(e =>
+            rm(resolve(storeDir, e), { recursive: true, force: true })
+              .catch(/* istanbul ignore next -- rm with force rarely fails */
+                er => log.warn('cleanup', `Failed to remove orphaned store entry ${e}`, er))
+          )
+        )
+      }
+    }
+
+    for (const [dir, valid] of nmDirs) {
+      await this.#cleanOrphanedTopLevelLinks(dir, valid)
+    }
+  }
+
+  // Remove node_modules/ entries that aren't represented in the ideal tree.
+  // Run for the project root and each workspace's node_modules.
+  // The linked diff path can't see these because #buildLinkedActualForDiff derives the actual tree from the ideal, so removed deps are never compared.
+  // Only symlinks whose target resolves inside the project root are removed — that covers store links (node_modules/.store/...) and workspace self-links (e.g. node_modules/<ws> -> ../packages/<ws>) that npm itself created.
+  // Symlinks pointing outside the project (e.g. `npm link foo` without --save targeting the global prefix, or hand-made `ln -s` to an external path) and real directories are preserved.
+  async #cleanOrphanedTopLevelLinks (nmDir, validTopLevel) {
+    const projectPrefix = resolve(this.path) + sep
+    let dirents
+    try {
+      dirents = await readdir(nmDir, { withFileTypes: true })
+    } catch {
+      return
+    }
+
+    const isOurOrphan = async (linkPath) => {
+      let target
+      try {
+        target = await readlink(linkPath)
+      } catch {
+        /* istanbul ignore next -- readlink of an entry we just listed as a symlink should not fail */
+        return false
+      }
+      return resolve(dirname(linkPath), target).startsWith(projectPrefix)
+    }
+
+    const orphaned = []
+    for (const ent of dirents) {
+      // skip npm-managed entries (.bin, .store, .package-lock.json, etc)
+      if (ent.name.startsWith('.')) {
+        continue
+      }
+      if (ent.name.startsWith('@')) {
+        let scoped
+        try {
+          scoped = await readdir(resolve(nmDir, ent.name), { withFileTypes: true })
+        } catch {
+          /* istanbul ignore next -- readdir of an entry we just listed should not fail */
+          continue
+        }
+        for (const pkgEnt of scoped) {
+          const key = `${ent.name}${sep}${pkgEnt.name}`
+          if (!validTopLevel.has(key) && pkgEnt.isSymbolicLink() && await isOurOrphan(resolve(nmDir, key))) {
+            orphaned.push(key)
+          }
+        }
+      } else if (!validTopLevel.has(ent.name) && ent.isSymbolicLink() && await isOurOrphan(resolve(nmDir, ent.name))) {
+        orphaned.push(ent.name)
       }
     }
 
-    const orphaned = entries.filter(e => !validKeys.has(e))
     if (!orphaned.length) {
       return
     }
 
-    log.silly('reify', 'cleaning orphaned store entries', orphaned)
+    log.silly('reify', 'cleaning orphaned top-level links', orphaned)
     await promiseAllRejectLate(
-      orphaned.map(e =>
-        rm(resolve(storeDir, e), { recursive: true, force: true })
+      orphaned.map(name =>
+        rm(resolve(nmDir, name), { recursive: true, force: true })
           .catch(/* istanbul ignore next -- rm with force rarely fails */
-            er => log.warn('cleanup', `Failed to remove orphaned store entry ${e}`, er))
+            er => log.warn('cleanup', `Failed to remove orphaned link ${name}`, er))
       )
     )
   }
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/link.js b/deps/npm/node_modules/@npmcli/arborist/lib/link.js
index 42bc1faf488609..3824dc81ffb3cb 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/link.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/link.js
@@ -109,6 +109,26 @@ class Link extends Node {
   // so this is a no-op
   [_loadDeps] () {}
 
+  // When a Link receives overrides (via edgesIn), forward them to the target node which holds the actual edgesOut — but only when the OverrideSet has at least one rule that names a dep the target actually depends on.
+  // Without this scope, the link forwards a generic ancestor OverrideSet that has no real effect on the target's edges, but still flips the target to "has overrides", which changes downstream `canReplaceWith` / placement decisions and causes `npm ci` to re-resolve lockfile-pinned edges from the registry.
+  // See npm/cli#9357.
+  recalculateOutEdgesOverrides () {
+    if (!this.target || !this.overrides) {
+      return
+    }
+    let hasMatchingRule = false
+    for (const rule of this.overrides.ruleset.values()) {
+      if (this.target.edgesOut.has(rule.name)) {
+        hasMatchingRule = true
+        break
+      }
+    }
+    if (!hasMatchingRule) {
+      return
+    }
+    this.target.updateOverridesEdgeInAdded(this.overrides)
+  }
+
   // links can't have children, only their targets can
   // fix it to an empty list so that we can still call
   // things that iterate over them, just as a no-op
diff --git a/deps/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js b/deps/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js
index 751c549fed63bc..6af902cdf8a48e 100644
--- a/deps/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js
+++ b/deps/npm/node_modules/@npmcli/arborist/lib/shrinkwrap.js
@@ -929,10 +929,24 @@ class Shrinkwrap {
           continue
         }
         const loc = relpath(this.path, node.path)
-        this.data.packages[loc] = Shrinkwrap.metaFromNode(
+        // Drop lockfile entries for extraneous nodes outside node_modules. These are stale workspace entries: the workspace was removed from package.json or its directory was deleted, so it should not be tracked in package-lock.json.
+        if (node.extraneous && !/(^|\/)node_modules\//.test(loc) && loc !== 'node_modules') {
+          continue
+        }
+        const meta = Shrinkwrap.metaFromNode(
           node,
           this.path,
           this.resolveOptions)
+        // Skip inert nodes — these are optional deps that failed to load
+        // (e.g. 404 from a proxy registry that hasn't cached the package,
+        // or incomplete manifest missing version field).
+        // #pruneFailedOptional marks them inert so they won't be reified;
+        // writing them to the lockfile produces invalid entries like
+        // {"optional": true} that cause "Invalid Version:" errors.
+        if (node.inert && !node.package.version) {
+          continue
+        }
+        this.data.packages[loc] = meta
       }
     } else if (this.#awaitingUpdate.size > 0) {
       for (const loc of this.#awaitingUpdate.keys()) {
diff --git a/deps/npm/node_modules/@npmcli/arborist/package.json b/deps/npm/node_modules/@npmcli/arborist/package.json
index d0f823e61d3481..c8c464e8d3a7e4 100644
--- a/deps/npm/node_modules/@npmcli/arborist/package.json
+++ b/deps/npm/node_modules/@npmcli/arborist/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/arborist",
-  "version": "9.4.3",
+  "version": "9.6.0",
   "description": "Manage node_modules trees",
   "dependencies": {
     "@gar/promise-retry": "^1.0.0",
diff --git a/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js b/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js
index c3e5cd2b430189..d54e1845d60777 100644
--- a/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js
+++ b/deps/npm/node_modules/@npmcli/config/lib/definitions/definitions.js
@@ -187,6 +187,36 @@ const definitions = {
   `,
     flatten,
   }),
+  'allow-directory': new Definition('allow-directory', {
+    default: 'all',
+    type: ['all', 'none', 'root'],
+    description: `
+      Limits the ability for npm to install dependencies from directories.
+      That is, dependencies that point to a directory instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      \`all\` allows any directories to be installed.
+      \`none\` prevents any directories from being installed.
+      \`root\` only allows directories defined in your project's package.json to be installed.  Also allows directory dependencies to be used for other commands like \`npm view\`
+  `,
+    flatten,
+  }),
+  'allow-file': new Definition('allow-file', {
+    default: 'all',
+    type: ['all', 'none', 'root'],
+    description: `
+      Limits the ability for npm to install dependencies from tarball files.
+      That is, dependencies that point to a local tarball file instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      \`all\` allows any tarball file to be installed.
+      \`none\` prevents any tarball file from being installed.
+      \`root\` only allows tarball files defined in your project's package.json to be installed.  Also allows tarball file dependencies to be used for other commands like \`npm view\`
+  `,
+    flatten,
+  }),
   'allow-git': new Definition('allow-git', {
     default: 'all',
     type: ['all', 'none', 'root'],
@@ -194,10 +224,26 @@ const definitions = {
       Limits the ability for npm to fetch dependencies from git references.
       That is, dependencies that point to a git repo instead of a version or semver range.
       Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
 
       \`all\` allows any git dependencies to be fetched and installed.
       \`none\` prevents any git dependencies from being fetched and installed.
-      \`root\` only allows git dependencies defined in your project's package.json to be fetched installed.  Also allows git dependencies to be fetched for other commands like \`npm view\`
+      \`root\` only allows git dependencies defined in your project's package.json to be fetched and installed.  Also allows git dependencies to be fetched for other commands like \`npm view\`
+  `,
+    flatten,
+  }),
+  'allow-remote': new Definition('allow-remote', {
+    default: 'all',
+    type: ['all', 'none', 'root'],
+    description: `
+      Limits the ability for npm to fetch dependencies from urls.
+      That is, dependencies that point to a tarball url instead of a version or semver range.
+      Please note that this could leave your tree incomplete and some packages may not function as intended or designed.
+      Changing this setting will not remove dependencies that are already installed.
+
+      \`all\` allows any url to be installed.
+      \`none\` prevents any url from being installed.
+      \`root\` only allows urls defined in your project's package.json to be installed.  Also allows url dependencies to be used for other commands like \`npm view\`
   `,
     flatten,
   }),
@@ -246,7 +292,6 @@ const definitions = {
     default: null,
     hint: '<date>',
     type: [null, Date],
-    exclusive: ['min-release-age'],
     description: `
       If passed to \`npm install\`, will rebuild the npm tree such that only
       versions that were available **on or before** the given date are
@@ -257,6 +302,12 @@ const definitions = {
       pass the \`--before\` filter, the most recent version less than or equal
       to that tag will be used. For example, \`foo@latest\` might install
       \`foo@1.2\` even though \`latest\` is \`2.0\`.
+
+      If \`before\` and \`min-release-age\` are both set in the same source,
+      \`before\` wins (an explicit absolute date overrides a relative window).
+      Across sources, the standard precedence applies (cli > env > project >
+      user > global), so a higher-priority source can always relax or
+      override a lower-priority one.
     `,
     flatten,
   }),
@@ -1363,7 +1414,6 @@ const definitions = {
     default: null,
     hint: '<days>',
     type: [null, Number],
-    exclusive: ['before'],
     envExport: false,
     description: `
        If set, npm will build the npm tree such that only versions that were
@@ -1372,13 +1422,18 @@ const definitions = {
        command will error.
 
        This flag is a complement to \`before\`, which accepts an exact date
-       instead of a relative number of days.
+       instead of a relative number of days. The two may coexist (e.g.
+       \`min-release-age\` in your \`.npmrc\` is preserved when npm internally
+       spawns a sub-process with \`--before\` while preparing a \`git:\` or
+       \`github:\` dependency); when both apply, \`before\` wins within a
+       single source and across sources the standard precedence rules apply.
     `,
     flatten: (key, obj, flatOptions) => {
-      if (obj['min-release-age'] !== null) {
-        flatOptions.before = new Date(Date.now() - (86400000 * obj['min-release-age']))
-        obj.before = flatOptions.before
-        delete obj['min-release-age']
+      const age = obj['min-release-age']
+      // `hasOwn` so a `before` inherited via ConfigData's prototype chain (lib/index.js) from a lower-priority source doesn't silently win.
+      // The `: null` clear depends on `Config#flat` iterating sources low → high.
+      if (age != null && !Object.hasOwn(obj, 'before')) {
+        flatOptions.before = age ? new Date(Date.now() - (86400000 * age)) : null
       }
     },
   }),
diff --git a/deps/npm/node_modules/@npmcli/config/package.json b/deps/npm/node_modules/@npmcli/config/package.json
index 5da16efc6cc4c3..09627833e07971 100644
--- a/deps/npm/node_modules/@npmcli/config/package.json
+++ b/deps/npm/node_modules/@npmcli/config/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/config",
-  "version": "10.8.1",
+  "version": "10.9.1",
   "files": [
     "bin/",
     "lib/"
diff --git a/deps/npm/node_modules/bin-links/lib/check-bin.js b/deps/npm/node_modules/bin-links/lib/check-bin.js
index c5b997bb96355c..a7fc8d51b415e2 100644
--- a/deps/npm/node_modules/bin-links/lib/check-bin.js
+++ b/deps/npm/node_modules/bin-links/lib/check-bin.js
@@ -2,7 +2,7 @@
 // either rejects or resolves to nothing.  return value not relevant.
 const isWindows = require('./is-windows.js')
 const binTarget = require('./bin-target.js')
-const { resolve, dirname } = require('path')
+const { resolve, dirname, sep } = require('path')
 const readCmdShim = require('read-cmd-shim')
 const { readlink } = require('fs/promises')
 
@@ -34,7 +34,9 @@ const checkLink = async ({ target, path }) => {
 
   const resolved = resolve(dirname(target), current)
 
-  if (resolved.toLowerCase().indexOf(path.toLowerCase()) !== 0) {
+  const resolvedLower = resolved.toLowerCase()
+  const pathLower = path.toLowerCase()
+  if (resolvedLower !== pathLower && !resolvedLower.startsWith(pathLower + sep)) {
     return failEEXIST({ target })
   }
 }
@@ -65,7 +67,9 @@ const checkShim = async ({ target, path }) => {
 
     const resolved = resolve(dirname(shim), current.replace(/\\/g, '/'))
 
-    if (resolved.toLowerCase().indexOf(path.toLowerCase()) !== 0) {
+    const resolvedLower = resolved.toLowerCase()
+    const pathLower = path.toLowerCase()
+    if (resolvedLower !== pathLower && !resolvedLower.startsWith(pathLower + sep)) {
       return failEEXIST({ target: shim })
     }
   }))
diff --git a/deps/npm/node_modules/bin-links/lib/link-gently.js b/deps/npm/node_modules/bin-links/lib/link-gently.js
index a39d3bced57b13..c4a38f7f54b951 100644
--- a/deps/npm/node_modules/bin-links/lib/link-gently.js
+++ b/deps/npm/node_modules/bin-links/lib/link-gently.js
@@ -4,7 +4,7 @@
 // if there's a symlink already, pointing into our pkg, remove it first
 // then create the symlink
 
-const { resolve, dirname } = require('path')
+const { resolve, dirname, sep } = require('path')
 const { lstat, mkdir, readlink, rm, symlink } = require('fs/promises')
 const { log } = require('proc-log')
 const throwSignificant = er => {
@@ -63,7 +63,7 @@ const linkGently = async ({ path, to, from, absFrom, force }) => {
         } // skip it, already set up like we want it.
 
         target = resolve(dirname(to), target)
-        if (target.indexOf(path) === 0 || force) {
+        if (target === path || target.startsWith(path + sep) || force) {
           return rm(to, rmOpts).then(() => CLOBBER)
         }
         // neither skip nor clobber
diff --git a/deps/npm/node_modules/bin-links/lib/shim-bin.js b/deps/npm/node_modules/bin-links/lib/shim-bin.js
index 67e2702702f0a8..91a6fcc94153bc 100644
--- a/deps/npm/node_modules/bin-links/lib/shim-bin.js
+++ b/deps/npm/node_modules/bin-links/lib/shim-bin.js
@@ -1,4 +1,4 @@
-const { resolve, dirname } = require('path')
+const { resolve, dirname, sep } = require('path')
 const { lstat } = require('fs/promises')
 const throwNonEnoent = er => {
   if (er.code !== 'ENOENT') {
@@ -64,7 +64,8 @@ const shimBin = ({ path, to, from, absFrom, force }) => {
       return readCmdShim(s)
         .then(target => {
           target = resolve(dirname(to), target)
-          if (target.indexOf(resolve(path)) !== 0) {
+          const base = resolve(path)
+          if (target !== base && !target.startsWith(base + sep)) {
             return failEEXIST({ from, to, path })
           }
           return false
diff --git a/deps/npm/node_modules/bin-links/package.json b/deps/npm/node_modules/bin-links/package.json
index 23f52cfc96ec46..80a63323e884b1 100644
--- a/deps/npm/node_modules/bin-links/package.json
+++ b/deps/npm/node_modules/bin-links/package.json
@@ -1,6 +1,6 @@
 {
   "name": "bin-links",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "JavaScript package binary linker",
   "main": "./lib/index.js",
   "scripts": {
@@ -32,7 +32,7 @@
   },
   "devDependencies": {
     "@npmcli/eslint-config": "^5.0.0",
-    "@npmcli/template-oss": "4.27.1",
+    "@npmcli/template-oss": "4.30.0",
     "require-inject": "^1.4.4",
     "tap": "^16.0.1"
   },
@@ -55,7 +55,9 @@
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
     "windowsCI": false,
-    "version": "4.27.1",
-    "publish": true
+    "version": "4.30.0",
+    "publish": true,
+    "updateNpm": false,
+    "latestCiVersion": 24
   }
 }
diff --git a/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js b/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js
index b9f3c6fdf6dfc7..33063dd3552cd6 100644
--- a/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js
+++ b/deps/npm/node_modules/brace-expansion/dist/commonjs/index.js
@@ -155,7 +155,7 @@ function expand_(str, max, isTop) {
             }
             const pad = n.some(isPadded);
             N = [];
-            for (let i = x; test(i, y); i += incr) {
+            for (let i = x; test(i, y) && N.length < max; i += incr) {
                 let c;
                 if (isAlphaSequence) {
                     c = String.fromCharCode(i);
diff --git a/deps/npm/node_modules/brace-expansion/dist/esm/index.js b/deps/npm/node_modules/brace-expansion/dist/esm/index.js
index 855e22cd71e824..32399e7b2f5cf1 100644
--- a/deps/npm/node_modules/brace-expansion/dist/esm/index.js
+++ b/deps/npm/node_modules/brace-expansion/dist/esm/index.js
@@ -151,7 +151,7 @@ function expand_(str, max, isTop) {
             }
             const pad = n.some(isPadded);
             N = [];
-            for (let i = x; test(i, y); i += incr) {
+            for (let i = x; test(i, y) && N.length < max; i += incr) {
                 let c;
                 if (isAlphaSequence) {
                     c = String.fromCharCode(i);
diff --git a/deps/npm/node_modules/brace-expansion/package.json b/deps/npm/node_modules/brace-expansion/package.json
index 83a8289641532c..81524809e58612 100644
--- a/deps/npm/node_modules/brace-expansion/package.json
+++ b/deps/npm/node_modules/brace-expansion/package.json
@@ -1,7 +1,7 @@
 {
   "name": "brace-expansion",
   "description": "Brace expansion as known from sh/bash",
-  "version": "5.0.5",
+  "version": "5.0.6",
   "files": [
     "dist"
   ],
diff --git a/deps/npm/node_modules/cidr-regex/package.json b/deps/npm/node_modules/cidr-regex/package.json
index 1c2db1a6e28b30..c15a446e7e2136 100644
--- a/deps/npm/node_modules/cidr-regex/package.json
+++ b/deps/npm/node_modules/cidr-regex/package.json
@@ -1,12 +1,25 @@
 {
   "name": "cidr-regex",
-  "version": "5.0.4",
+  "version": "5.0.5",
   "description": "Regular expression for matching IP addresses in CIDR notation",
   "author": "silverwind <me@silverwind.io>",
   "contributors": [
     "Felipe Apostol <flipjs.io@gmail.com> (http://flipjs.io/)"
   ],
   "repository": "silverwind/cidr-regex",
+  "keywords": [
+    "cidr",
+    "regex",
+    "regexp",
+    "ip",
+    "ipv4",
+    "ipv6",
+    "address",
+    "subnet",
+    "network",
+    "notation",
+    "match"
+  ],
   "license": "BSD-2-Clause",
   "type": "module",
   "sideEffects": false,
@@ -21,18 +34,18 @@
   },
   "devDependencies": {
     "@types/node": "25.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20260420.1",
+    "@typescript/native-preview": "7.0.0-dev.20260427.1",
     "eslint": "10.2.1",
-    "eslint-config-silverwind": "131.0.5",
+    "eslint-config-silverwind": "132.0.0",
     "jest-extended": "7.0.0",
-    "tsdown": "0.21.9",
-    "tsdown-config-silverwind": "2.1.0",
+    "tsdown": "0.21.10",
+    "tsdown-config-silverwind": "2.1.1",
     "typescript": "6.0.3",
     "typescript-config-silverwind": "18.0.0",
-    "updates": "17.15.5",
-    "updates-config-silverwind": "2.1.0",
-    "versions": "15.0.0",
-    "vitest": "4.1.4",
-    "vitest-config-silverwind": "11.3.0"
+    "updates": "17.16.4",
+    "updates-config-silverwind": "2.1.1",
+    "versions": "15.0.1",
+    "vitest": "4.1.5",
+    "vitest-config-silverwind": "11.3.1"
   }
 }
\ No newline at end of file
diff --git a/deps/npm/node_modules/hosted-git-info/lib/hosts.js b/deps/npm/node_modules/hosted-git-info/lib/hosts.js
index 6e7c123dbff8b4..a1635d3c898fed 100644
--- a/deps/npm/node_modules/hosted-git-info/lib/hosts.js
+++ b/deps/npm/node_modules/hosted-git-info/lib/hosts.js
@@ -110,7 +110,7 @@ hosts.gitlab = {
   blobpath: 'tree',
   editpath: '-/edit',
   tarballtemplate: ({ domain, user, project, committish }) =>
-    `https://${domain}/${user}/${project}/repository/archive.tar.gz?ref=${maybeEncode(committish || 'HEAD')}`,
+    `https://${domain}/api/v4/projects/${maybeEncode(user + '/' + project)}/repository/archive.tar.gz?sha=${maybeEncode(committish || 'HEAD')}`,
   extract: (url) => {
     const path = url.pathname.slice(1)
     if (path.includes('/-/') || path.includes('/archive.tar.gz')) {
@@ -198,7 +198,7 @@ hosts.sourcehut = {
   filetemplate: ({ domain, user, project, committish, path }) =>
     `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || 'HEAD'}/${path}`,
   httpstemplate: ({ domain, user, project, committish }) =>
-    `https://${domain}/${user}/${project}.git${maybeJoin('#', committish)}`,
+    `https://${domain}/${user}/${project}${maybeJoin('#', committish)}`,
   tarballtemplate: ({ domain, user, project, committish }) =>
     `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || 'HEAD'}.tar.gz`,
   bugstemplate: () => null,
diff --git a/deps/npm/node_modules/hosted-git-info/package.json b/deps/npm/node_modules/hosted-git-info/package.json
index 1e74eda1656d78..f21e546a64bfa5 100644
--- a/deps/npm/node_modules/hosted-git-info/package.json
+++ b/deps/npm/node_modules/hosted-git-info/package.json
@@ -1,6 +1,6 @@
 {
   "name": "hosted-git-info",
-  "version": "9.0.2",
+  "version": "9.0.3",
   "description": "Provides metadata and conversions from repository urls for GitHub, Bitbucket and GitLab",
   "main": "./lib/index.js",
   "repository": {
@@ -21,22 +21,23 @@
   "homepage": "https://github.com/npm/hosted-git-info",
   "scripts": {
     "posttest": "npm run lint",
-    "snap": "tap",
-    "test": "tap",
+    "snap": "node --test --test-update-snapshots './test/**/*.js'",
+    "test": "node --test './test/**/*.js'",
     "test:coverage": "tap --coverage-report=html",
     "lint": "npm run eslint",
     "postlint": "template-oss-check",
     "lintfix": "npm run eslint -- --fix",
     "template-oss-apply": "template-oss-apply --force",
-    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\""
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\"",
+    "test:node20": "node --test test",
+    "test:cover": "node --test --experimental-test-coverage --test-timeout=3000 --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=100 './test/**/*.js'"
   },
   "dependencies": {
     "lru-cache": "^11.1.0"
   },
   "devDependencies": {
-    "@npmcli/eslint-config": "^5.0.0",
-    "@npmcli/template-oss": "4.25.1",
-    "tap": "^16.0.1"
+    "@npmcli/eslint-config": "^6.0.0",
+    "@npmcli/template-oss": "4.30.0"
   },
   "files": [
     "bin/",
@@ -45,17 +46,12 @@
   "engines": {
     "node": "^20.17.0 || >=22.9.0"
   },
-  "tap": {
-    "color": 1,
-    "coverage": true,
-    "nyc-arg": [
-      "--exclude",
-      "tap-snapshots/**"
-    ]
-  },
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "4.25.1",
-    "publish": "true"
+    "version": "4.30.0",
+    "publish": "true",
+    "testRunner": "node:test",
+    "latestCiVersion": 24,
+    "updateNpm": false
   }
 }
diff --git a/deps/npm/node_modules/ip-address/dist/common.js b/deps/npm/node_modules/ip-address/dist/common.js
index 273a01e28e317d..6b76e051b44e41 100644
--- a/deps/npm/node_modules/ip-address/dist/common.js
+++ b/deps/npm/node_modules/ip-address/dist/common.js
@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInSubnet = isInSubnet;
 exports.isCorrect = isCorrect;
+exports.prefixLengthFromMask = prefixLengthFromMask;
 exports.numberToPaddedHex = numberToPaddedHex;
 exports.stringToPaddedHex = stringToPaddedHex;
 exports.testBit = testBit;
+const address_error_1 = require("./address-error");
 function isInSubnet(address) {
     if (this.subnetMask < address.subnetMask) {
         return false;
@@ -25,6 +27,25 @@ function isCorrect(defaultBits) {
         return this.parsedSubnet === String(this.subnetMask);
     };
 }
+/**
+ * Returns the prefix length (number of leading 1 bits) of a contiguous
+ * subnet mask. Throws `AddressError` if the mask is non-contiguous (e.g.
+ * `255.0.255.0`).
+ */
+function prefixLengthFromMask(value, totalBits) {
+    const binary = value.toString(2).padStart(totalBits, '0');
+    if (binary.length > totalBits) {
+        throw new address_error_1.AddressError('Invalid subnet mask.');
+    }
+    const firstZero = binary.indexOf('0');
+    if (firstZero === -1) {
+        return totalBits;
+    }
+    if (binary.slice(firstZero).includes('1')) {
+        throw new address_error_1.AddressError('Invalid subnet mask.');
+    }
+    return firstZero;
+}
 function numberToPaddedHex(number) {
     return number.toString(16).padStart(2, '0');
 }
diff --git a/deps/npm/node_modules/ip-address/dist/ipv4.js b/deps/npm/node_modules/ip-address/dist/ipv4.js
index 311c89c6965cb8..2c0fd182086d2d 100644
--- a/deps/npm/node_modules/ip-address/dist/ipv4.js
+++ b/deps/npm/node_modules/ip-address/dist/ipv4.js
@@ -28,9 +28,9 @@ exports.Address4 = void 0;
 const common = __importStar(require("./common"));
 const constants = __importStar(require("./v4/constants"));
 const address_error_1 = require("./address-error");
+const isCorrect4 = common.isCorrect(constants.BITS);
 /**
  * Represents an IPv4 address
- * @class Address4
  * @param {string} address - An IPv4 address string
  */
 class Address4 {
@@ -43,15 +43,11 @@ class Address4 {
         this.v4 = true;
         /**
          * Returns true if the address is correct, false otherwise
-         * @memberof Address4
-         * @instance
          * @returns {Boolean}
          */
-        this.isCorrect = common.isCorrect(constants.BITS);
+        this.isCorrect = isCorrect4;
         /**
          * Returns true if the given address is in the subnet of the current address
-         * @memberof Address4
-         * @instance
          * @returns {boolean}
          */
         this.isInSubnet = common.isInSubnet;
@@ -69,6 +65,13 @@ class Address4 {
         this.addressMinusSuffix = address;
         this.parsedAddress = this.parse(address);
     }
+    /**
+     * Returns true if the given string is a valid IPv4 address (with optional
+     * CIDR subnet), false otherwise. Host bits in the subnet portion are
+     * allowed (e.g. `192.168.1.5/24` is valid); for strict network-address
+     * validation compare `correctForm()` to `startAddress().correctForm()`,
+     * or use `networkForm()`.
+     */
     static isValid(address) {
         try {
             // eslint-disable-next-line no-new
@@ -79,8 +82,11 @@ class Address4 {
             return false;
         }
     }
-    /*
-     * Parses a v4 address
+    /**
+     * Parses an IPv4 address string into its four octet groups and stores the
+     * result on `this.parsedAddress`. Called automatically by the constructor;
+     * you typically don't need to call it directly. Throws `AddressError` if
+     * the input is not a valid IPv4 address.
      */
     parse(address) {
         const groups = address.split('.');
@@ -90,45 +96,110 @@ class Address4 {
         return groups;
     }
     /**
-     * Returns the correct form of an address
-     * @memberof Address4
-     * @instance
-     * @returns {String}
+     * Returns the address in correct form: octets joined with `.` and any
+     * leading zeros stripped (e.g. `192.168.1.1`). For IPv4 this matches the
+     * canonical dotted-decimal representation.
      */
     correctForm() {
         return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');
     }
     /**
-     * Converts a hex string to an IPv4 address object
-     * @memberof Address4
-     * @static
+     * Construct an `Address4` from an address and a dotted-decimal subnet
+     * mask given as separate strings (e.g. as returned by Node's
+     * `os.networkInterfaces()`). Throws `AddressError` if the mask is
+     * non-contiguous (e.g. `255.0.255.0`).
+     * @example
+     * var address = Address4.fromAddressAndMask('192.168.1.1', '255.255.255.0');
+     * address.subnetMask; // 24
+     */
+    static fromAddressAndMask(address, mask) {
+        const bits = common.prefixLengthFromMask(new Address4(mask).bigInt(), constants.BITS);
+        return new Address4(`${address}/${bits}`);
+    }
+    /**
+     * Construct an `Address4` from an address and a Cisco-style wildcard mask
+     * given as separate strings (e.g. `0.0.0.255` for a `/24`). The wildcard
+     * mask is the bitwise inverse of the subnet mask. Throws `AddressError`
+     * if the mask is non-contiguous (e.g. `0.255.0.255`).
+     * @example
+     * var address = Address4.fromAddressAndWildcardMask('10.0.0.1', '0.0.0.255');
+     * address.subnetMask; // 24
+     */
+    static fromAddressAndWildcardMask(address, wildcardMask) {
+        const wildcard = new Address4(wildcardMask).bigInt();
+        const allOnes = (BigInt(1) << BigInt(constants.BITS)) - BigInt(1);
+        // eslint-disable-next-line no-bitwise
+        const mask = wildcard ^ allOnes;
+        const bits = common.prefixLengthFromMask(mask, constants.BITS);
+        return new Address4(`${address}/${bits}`);
+    }
+    /**
+     * Construct an `Address4` from a wildcard pattern with trailing `*`
+     * octets. The number of trailing wildcards determines the prefix
+     * length: each `*` represents 8 bits.
+     *
+     * Only trailing whole-octet wildcards are supported. Partial-octet
+     * wildcards (e.g. `192.168.0.1*`) and interior wildcards (e.g.
+     * `192.*.0.1`) throw `AddressError`.
+     * @example
+     * Address4.fromWildcard('192.168.0.*').subnet;   // '/24'
+     * Address4.fromWildcard('192.168.*.*').subnet;   // '/16'
+     * Address4.fromWildcard('*.*.*.*').subnet;       // '/0'
+     */
+    static fromWildcard(input) {
+        const groups = input.split('.');
+        if (groups.length !== constants.GROUPS) {
+            throw new address_error_1.AddressError('Wildcard pattern must have 4 octets');
+        }
+        let firstWildcard = -1;
+        for (let i = 0; i < groups.length; i++) {
+            if (groups[i] === '*') {
+                if (firstWildcard === -1) {
+                    firstWildcard = i;
+                }
+            }
+            else if (firstWildcard !== -1) {
+                throw new address_error_1.AddressError('Wildcard `*` must only appear in trailing octets (e.g. `192.168.0.*`)');
+            }
+        }
+        const trailing = firstWildcard === -1 ? 0 : groups.length - firstWildcard;
+        const replaced = groups.map((g) => (g === '*' ? '0' : g));
+        const subnetBits = constants.BITS - trailing * 8;
+        return new Address4(`${replaced.join('.')}/${subnetBits}`);
+    }
+    /**
+     * Converts a hex string to an IPv4 address object. Accepts 8 hex digits
+     * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`).
+     * Throws `AddressError` for any other length or for non-hex characters.
      * @param {string} hex - a hex string to convert
      * @returns {Address4}
      */
     static fromHex(hex) {
-        const padded = hex.replace(/:/g, '').padStart(8, '0');
+        const stripped = hex.replace(/:/g, '');
+        if (!/^[0-9a-fA-F]{8}$/.test(stripped)) {
+            throw new address_error_1.AddressError('IPv4 hex must be exactly 8 hex digits');
+        }
         const groups = [];
-        let i;
-        for (i = 0; i < 8; i += 2) {
-            const h = padded.slice(i, i + 2);
-            groups.push(parseInt(h, 16));
+        for (let i = 0; i < 8; i += 2) {
+            groups.push(parseInt(stripped.slice(i, i + 2), 16));
         }
         return new Address4(groups.join('.'));
     }
     /**
-     * Converts an integer into a IPv4 address object
-     * @memberof Address4
-     * @static
+     * Converts an integer into a IPv4 address object. The integer must be a
+     * non-negative safe integer in the range `[0, 2**32 - 1]`; otherwise
+     * `AddressError` is thrown.
      * @param {integer} integer - a number to convert
      * @returns {Address4}
      */
     static fromInteger(integer) {
-        return Address4.fromHex(integer.toString(16));
+        if (!Number.isInteger(integer) || integer < 0 || integer > 0xffffffff) {
+            throw new address_error_1.AddressError('IPv4 integer must be in the range 0 to 2**32 - 1');
+        }
+        return Address4.fromHex(integer.toString(16).padStart(8, '0'));
     }
     /**
      * Return an address from in-addr.arpa form
-     * @memberof Address4
-     * @static
      * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address
      * @returns {Adress4}
      * @example
@@ -143,17 +214,15 @@ class Address4 {
     }
     /**
      * Converts an IPv4 address object to a hex string
-     * @memberof Address4
-     * @instance
      * @returns {String}
      */
     toHex() {
         return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(':');
     }
     /**
-     * Converts an IPv4 address object to an array of bytes
-     * @memberof Address4
-     * @instance
+     * Converts an IPv4 address object to an array of bytes.
+     *
+     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toArray())`.
      * @returns {Array}
      */
     toArray() {
@@ -161,8 +230,6 @@ class Address4 {
     }
     /**
      * Converts an IPv4 address object to an IPv6 address group
-     * @memberof Address4
-     * @instance
      * @returns {String}
      */
     toGroup6() {
@@ -175,8 +242,6 @@ class Address4 {
     }
     /**
      * Returns the address as a `bigint`
-     * @memberof Address4
-     * @instance
      * @returns {bigint}
      */
     bigInt() {
@@ -184,8 +249,6 @@ class Address4 {
     }
     /**
      * Helper function getting start address.
-     * @memberof Address4
-     * @instance
      * @returns {bigint}
      */
     _startAddress() {
@@ -194,8 +257,6 @@ class Address4 {
     /**
      * The first address in the range given by this address' subnet.
      * Often referred to as the Network Address.
-     * @memberof Address4
-     * @instance
      * @returns {Address4}
      */
     startAddress() {
@@ -204,8 +265,6 @@ class Address4 {
     /**
      * The first host address in the range given by this address's subnet ie
      * the first address after the Network Address
-     * @memberof Address4
-     * @instance
      * @returns {Address4}
      */
     startAddressExclusive() {
@@ -214,8 +273,6 @@ class Address4 {
     }
     /**
      * Helper function getting end address.
-     * @memberof Address4
-     * @instance
      * @returns {bigint}
      */
     _endAddress() {
@@ -224,8 +281,6 @@ class Address4 {
     /**
      * The last address in the range given by this address' subnet
      * Often referred to as the Broadcast
-     * @memberof Address4
-     * @instance
      * @returns {Address4}
      */
     endAddress() {
@@ -234,8 +289,6 @@ class Address4 {
     /**
      * The last host address in the range given by this address's subnet ie
      * the last address prior to the Broadcast Address
-     * @memberof Address4
-     * @instance
      * @returns {Address4}
      */
     endAddressExclusive() {
@@ -243,19 +296,47 @@ class Address4 {
         return Address4.fromBigInt(this._endAddress() - adjust);
     }
     /**
-     * Converts a BigInt to a v4 address object
-     * @memberof Address4
-     * @static
+     * The dotted-decimal form of the subnet mask, e.g. `255.255.240.0` for
+     * a `/20`. Returns an `Address4`; call `.correctForm()` for the string.
+     * @returns {Address4}
+     */
+    subnetMaskAddress() {
+        return Address4.fromBigInt(BigInt(`0b${'1'.repeat(this.subnetMask)}${'0'.repeat(constants.BITS - this.subnetMask)}`));
+    }
+    /**
+     * The Cisco-style wildcard mask, e.g. `0.0.0.255` for a `/24`. This is
+     * the bitwise inverse of `subnetMaskAddress()`. Returns an `Address4`;
+     * call `.correctForm()` for the string.
+     * @returns {Address4}
+     */
+    wildcardMask() {
+        return Address4.fromBigInt(BigInt(`0b${'0'.repeat(this.subnetMask)}${'1'.repeat(constants.BITS - this.subnetMask)}`));
+    }
+    /**
+     * The network address in CIDR string form, e.g. `192.168.1.0/24` for
+     * `192.168.1.5/24`. For an address with no explicit subnet the prefix is
+     * `/32`, e.g. `networkForm()` on `192.168.1.5` returns `192.168.1.5/32`.
+     * @returns {string}
+     */
+    networkForm() {
+        return `${this.startAddress().correctForm()}/${this.subnetMask}`;
+    }
+    /**
+     * Converts a BigInt to a v4 address object. The value must be in the
+     * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown.
      * @param {bigint} bigInt - a BigInt to convert
      * @returns {Address4}
      */
     static fromBigInt(bigInt) {
-        return Address4.fromHex(bigInt.toString(16));
+        if (bigInt < 0n || bigInt > 0xffffffffn) {
+            throw new address_error_1.AddressError('IPv4 BigInt must be in the range 0 to 2**32 - 1');
+        }
+        return Address4.fromHex(bigInt.toString(16).padStart(8, '0'));
     }
     /**
-     * Convert a byte array to an Address4 object
-     * @memberof Address4
-     * @static
+     * Convert a byte array to an Address4 object.
+     *
+     * To convert from a Node.js `Buffer`, spread it: `Address4.fromByteArray([...buf])`.
      * @param {Array<number>} bytes - an array of 4 bytes (0-255)
      * @returns {Address4}
      */
@@ -273,8 +354,6 @@ class Address4 {
     }
     /**
      * Convert an unsigned byte array to an Address4 object
-     * @memberof Address4
-     * @static
      * @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)
      * @returns {Address4}
      */
@@ -288,8 +367,6 @@ class Address4 {
     /**
      * Returns the first n bits of the address, defaulting to the
      * subnet mask
-     * @memberof Address4
-     * @instance
      * @returns {String}
      */
     mask(mask) {
@@ -300,8 +377,6 @@ class Address4 {
     }
     /**
      * Returns the bits in the given range as a base-2 string
-     * @memberof Address4
-     * @instance
      * @returns {string}
      */
     getBitsBase2(start, end) {
@@ -309,10 +384,8 @@ class Address4 {
     }
     /**
      * Return the reversed ip6.arpa form of the address
-     * @memberof Address4
      * @param {Object} options
      * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix
-     * @instance
      * @returns {String}
      */
     reverseForm(options) {
@@ -327,21 +400,62 @@ class Address4 {
     }
     /**
      * Returns true if the given address is a multicast address
-     * @memberof Address4
-     * @instance
      * @returns {boolean}
      */
     isMulticast() {
-        return this.isInSubnet(new Address4('224.0.0.0/4'));
+        return this.isInSubnet(MULTICAST_V4);
+    }
+    /**
+     * Returns true if the address is in one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private address ranges (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`).
+     * @returns {boolean}
+     */
+    isPrivate() {
+        return PRIVATE_V4.some((subnet) => this.isInSubnet(subnet));
+    }
+    /**
+     * Returns true if the address is in the loopback range `127.0.0.0/8` ([RFC 1122](https://datatracker.ietf.org/doc/html/rfc1122)).
+     * @returns {boolean}
+     */
+    isLoopback() {
+        return this.isInSubnet(LOOPBACK_V4);
+    }
+    /**
+     * Returns true if the address is in the link-local range `169.254.0.0/16` ([RFC 3927](https://datatracker.ietf.org/doc/html/rfc3927)).
+     * @returns {boolean}
+     */
+    isLinkLocal() {
+        return this.isInSubnet(LINK_LOCAL_V4);
+    }
+    /**
+     * Returns true if the address is the unspecified address `0.0.0.0`.
+     * @returns {boolean}
+     */
+    isUnspecified() {
+        return this.isInSubnet(UNSPECIFIED_V4);
+    }
+    /**
+     * Returns true if the address is the limited broadcast address `255.255.255.255` ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)).
+     * @returns {boolean}
+     */
+    isBroadcast() {
+        return this.isInSubnet(BROADCAST_V4);
+    }
+    /**
+     * Returns true if the address is in the carrier-grade NAT range `100.64.0.0/10` ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)).
+     * @returns {boolean}
+     */
+    isCGNAT() {
+        return this.isInSubnet(CGNAT_V4);
     }
     /**
      * Returns a zero-padded base-2 string representation of the address
-     * @memberof Address4
-     * @instance
      * @returns {string}
      */
     binaryZeroPad() {
-        return this.bigInt().toString(2).padStart(constants.BITS, '0');
+        if (this._binaryZeroPad === undefined) {
+            this._binaryZeroPad = this.bigInt().toString(2).padStart(constants.BITS, '0');
+        }
+        return this._binaryZeroPad;
     }
     /**
      * Groups an IPv4 address for inclusion at the end of an IPv6 address
@@ -357,4 +471,15 @@ class Address4 {
     }
 }
 exports.Address4 = Address4;
+const MULTICAST_V4 = new Address4('224.0.0.0/4');
+const PRIVATE_V4 = [
+    new Address4('10.0.0.0/8'),
+    new Address4('172.16.0.0/12'),
+    new Address4('192.168.0.0/16'),
+];
+const LOOPBACK_V4 = new Address4('127.0.0.0/8');
+const LINK_LOCAL_V4 = new Address4('169.254.0.0/16');
+const UNSPECIFIED_V4 = new Address4('0.0.0.0/32');
+const BROADCAST_V4 = new Address4('255.255.255.255/32');
+const CGNAT_V4 = new Address4('100.64.0.0/10');
 //# sourceMappingURL=ipv4.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/ip-address/dist/ipv6.js b/deps/npm/node_modules/ip-address/dist/ipv6.js
index 5f88ab63a56eb8..a78020ee7886ff 100644
--- a/deps/npm/node_modules/ip-address/dist/ipv6.js
+++ b/deps/npm/node_modules/ip-address/dist/ipv6.js
@@ -34,6 +34,7 @@ const ipv4_1 = require("./ipv4");
 const regular_expressions_1 = require("./v6/regular-expressions");
 const address_error_1 = require("./address-error");
 const common_1 = require("./common");
+const isCorrect6 = common.isCorrect(constants6.BITS);
 function assert(condition) {
     if (!condition) {
         throw new Error('Assertion failed.');
@@ -77,7 +78,6 @@ function unsignByte(b) {
 }
 /**
  * Represents an IPv6 address
- * @class Address6
  * @param {string} address - An IPv6 address string
  * @param {number} [groups=8] - How many octets to parse
  * @example
@@ -94,18 +94,14 @@ class Address6 {
         // #region Attributes
         /**
          * Returns true if the given address is in the subnet of the current address
-         * @memberof Address6
-         * @instance
          * @returns {boolean}
          */
         this.isInSubnet = common.isInSubnet;
         /**
          * Returns true if the address is correct, false otherwise
-         * @memberof Address6
-         * @instance
          * @returns {boolean}
          */
-        this.isCorrect = common.isCorrect(constants6.BITS);
+        this.isCorrect = isCorrect6;
         if (optionalGroups === undefined) {
             this.groups = constants6.GROUPS;
         }
@@ -136,6 +132,13 @@ class Address6 {
         this.addressMinusSuffix = address;
         this.parsedAddress = this.parse(this.addressMinusSuffix);
     }
+    /**
+     * Returns true if the given string is a valid IPv6 address (with optional
+     * CIDR subnet and zone identifier), false otherwise. Host bits in the
+     * subnet portion are allowed (e.g. `2001:db8::1/32` is valid); for strict
+     * network-address validation compare `correctForm()` to
+     * `startAddress().correctForm()`, or use `networkForm()`.
+     */
     static isValid(address) {
         try {
             // eslint-disable-next-line no-new
@@ -147,9 +150,8 @@ class Address6 {
         }
     }
     /**
-     * Convert a BigInt to a v6 address object
-     * @memberof Address6
-     * @static
+     * Convert a BigInt to a v6 address object. The value must be in the
+     * range `[0, 2**128 - 1]`; otherwise `AddressError` is thrown.
      * @param {bigint} bigInt - a BigInt to convert
      * @returns {Address6}
      * @example
@@ -158,19 +160,21 @@ class Address6 {
      * address.correctForm(); // '::e8:d4a5:1000'
      */
     static fromBigInt(bigInt) {
+        if (bigInt < 0n || bigInt > (1n << BigInt(constants6.BITS)) - 1n) {
+            throw new address_error_1.AddressError('IPv6 BigInt must be in the range 0 to 2**128 - 1');
+        }
         const hex = bigInt.toString(16).padStart(32, '0');
         const groups = [];
-        let i;
-        for (i = 0; i < constants6.GROUPS; i++) {
+        for (let i = 0; i < constants6.GROUPS; i++) {
             groups.push(hex.slice(i * 4, (i + 1) * 4));
         }
         return new Address6(groups.join(':'));
     }
     /**
-     * Convert a URL (with optional port number) to an address object
-     * @memberof Address6
-     * @static
-     * @param {string} url - a URL with optional port number
+     * Parse a URL (with optional bracketed host and port) into an address and
+     * port. Returns either `{ address, port }` on success or
+     * `{ error, address: null, port: null }` if the URL could not be parsed.
+     * Ports are returned as numbers (or `null` if absent or out of range).
      * @example
      * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
      * addressAndPort.address.correctForm(); // 'ffff::'
@@ -229,10 +233,92 @@ class Address6 {
             port,
         };
     }
+    /**
+     * Construct an `Address6` from an address and a hex subnet mask given as
+     * separate strings (e.g. as returned by Node's `os.networkInterfaces()`).
+     * Throws `AddressError` if the mask is non-contiguous (e.g.
+     * `ffff::ffff`).
+     * @example
+     * var address = Address6.fromAddressAndMask('fe80::1', 'ffff:ffff:ffff:ffff::');
+     * address.subnetMask; // 64
+     */
+    static fromAddressAndMask(address, mask) {
+        const bits = common.prefixLengthFromMask(new Address6(mask).bigInt(), constants6.BITS);
+        return new Address6(`${address}/${bits}`);
+    }
+    /**
+     * Construct an `Address6` from an address and a Cisco-style wildcard mask
+     * given as separate strings (e.g. `::ffff:ffff:ffff:ffff` for a `/64`).
+     * The wildcard mask is the bitwise inverse of the subnet mask. Throws
+     * `AddressError` if the mask is non-contiguous.
+     * @example
+     * var address = Address6.fromAddressAndWildcardMask('fe80::1', '::ffff:ffff:ffff:ffff');
+     * address.subnetMask; // 64
+     */
+    static fromAddressAndWildcardMask(address, wildcardMask) {
+        const wildcard = new Address6(wildcardMask).bigInt();
+        const allOnes = (BigInt(1) << BigInt(constants6.BITS)) - BigInt(1);
+        // eslint-disable-next-line no-bitwise
+        const mask = wildcard ^ allOnes;
+        const bits = common.prefixLengthFromMask(mask, constants6.BITS);
+        return new Address6(`${address}/${bits}`);
+    }
+    /**
+     * Construct an `Address6` from a wildcard pattern with trailing `*`
+     * groups. The number of trailing wildcards determines the prefix
+     * length: each `*` represents 16 bits. `::` is expanded to zero groups
+     * (not wildcards) before evaluating trailing wildcards.
+     *
+     * Only trailing whole-group wildcards are supported. Partial-group
+     * wildcards (e.g. `2001:db8::0*`) and interior wildcards (e.g.
+     * `*::1`) throw `AddressError`.
+     * @example
+     * Address6.fromWildcard('2001:db8:*:*:*:*:*:*').subnet;  // '/32'
+     * Address6.fromWildcard('2001:db8::*').subnet;           // '/112'
+     * Address6.fromWildcard('*:*:*:*:*:*:*:*').subnet;       // '/0'
+     */
+    static fromWildcard(input) {
+        if (input.includes('%') || input.includes('/')) {
+            throw new address_error_1.AddressError('Wildcard pattern must not include a zone or CIDR suffix');
+        }
+        const halves = input.split('::');
+        if (halves.length > 2) {
+            throw new address_error_1.AddressError("Wildcard pattern cannot contain more than one '::'");
+        }
+        let groups;
+        if (halves.length === 2) {
+            const left = halves[0] === '' ? [] : halves[0].split(':');
+            const right = halves[1] === '' ? [] : halves[1].split(':');
+            const remaining = constants6.GROUPS - left.length - right.length;
+            if (remaining < 1) {
+                throw new address_error_1.AddressError("Wildcard pattern with '::' has too many groups");
+            }
+            groups = [...left, ...new Array(remaining).fill('0'), ...right];
+        }
+        else {
+            groups = input.split(':');
+        }
+        if (groups.length !== constants6.GROUPS) {
+            throw new address_error_1.AddressError('Wildcard pattern must have 8 groups');
+        }
+        let firstWildcard = -1;
+        for (let i = 0; i < groups.length; i++) {
+            if (groups[i] === '*') {
+                if (firstWildcard === -1) {
+                    firstWildcard = i;
+                }
+            }
+            else if (firstWildcard !== -1) {
+                throw new address_error_1.AddressError('Wildcard `*` must only appear in trailing groups (e.g. `2001:db8:*:*:*:*:*:*`)');
+            }
+        }
+        const trailing = firstWildcard === -1 ? 0 : groups.length - firstWildcard;
+        const replaced = groups.map((g) => (g === '*' ? '0' : g));
+        const subnetBits = constants6.BITS - trailing * 16;
+        return new Address6(`${replaced.join(':')}/${subnetBits}`);
+    }
     /**
      * Create an IPv6-mapped address given an IPv4 address
-     * @memberof Address6
-     * @static
      * @param {string} address - An IPv4 address string
      * @returns {Address6}
      * @example
@@ -247,8 +333,6 @@ class Address6 {
     }
     /**
      * Return an address from ip6.arpa form
-     * @memberof Address6
-     * @static
      * @param {string} arpaFormAddress - an 'ip6.arpa' form address
      * @returns {Adress6}
      * @example
@@ -273,8 +357,6 @@ class Address6 {
     }
     /**
      * Return the Microsoft UNC transcription of the address
-     * @memberof Address6
-     * @instance
      * @returns {String} the Microsoft UNC transcription of the address
      */
     microsoftTranscription() {
@@ -282,8 +364,6 @@ class Address6 {
     }
     /**
      * Return the first n bits of the address, defaulting to the subnet mask
-     * @memberof Address6
-     * @instance
      * @param {number} [mask=subnet] - the number of bits to mask
      * @returns {String} the first n bits of the address as a string
      */
@@ -292,8 +372,6 @@ class Address6 {
     }
     /**
      * Return the number of possible subnets of a given size in the address
-     * @memberof Address6
-     * @instance
      * @param {number} [subnetSize=128] - the subnet size
      * @returns {String}
      */
@@ -309,8 +387,6 @@ class Address6 {
     }
     /**
      * Helper function getting start address.
-     * @memberof Address6
-     * @instance
      * @returns {bigint}
      */
     _startAddress() {
@@ -319,8 +395,6 @@ class Address6 {
     /**
      * The first address in the range given by this address' subnet
      * Often referred to as the Network Address.
-     * @memberof Address6
-     * @instance
      * @returns {Address6}
      */
     startAddress() {
@@ -329,8 +403,6 @@ class Address6 {
     /**
      * The first host address in the range given by this address's subnet ie
      * the first address after the Network Address
-     * @memberof Address6
-     * @instance
      * @returns {Address6}
      */
     startAddressExclusive() {
@@ -339,8 +411,6 @@ class Address6 {
     }
     /**
      * Helper function getting end address.
-     * @memberof Address6
-     * @instance
      * @returns {bigint}
      */
     _endAddress() {
@@ -349,8 +419,6 @@ class Address6 {
     /**
      * The last address in the range given by this address' subnet
      * Often referred to as the Broadcast
-     * @memberof Address6
-     * @instance
      * @returns {Address6}
      */
     endAddress() {
@@ -359,8 +427,6 @@ class Address6 {
     /**
      * The last host address in the range given by this address's subnet ie
      * the last address prior to the Broadcast Address
-     * @memberof Address6
-     * @instance
      * @returns {Address6}
      */
     endAddressExclusive() {
@@ -368,36 +434,73 @@ class Address6 {
         return Address6.fromBigInt(this._endAddress() - adjust);
     }
     /**
-     * Return the scope of the address
-     * @memberof Address6
-     * @instance
+     * The hex form of the subnet mask, e.g. `ffff:ffff:ffff:ffff::` for a
+     * `/64`. Returns an `Address6`; call `.correctForm()` for the string.
+     * @returns {Address6}
+     */
+    subnetMaskAddress() {
+        return Address6.fromBigInt(BigInt(`0b${'1'.repeat(this.subnetMask)}${'0'.repeat(constants6.BITS - this.subnetMask)}`));
+    }
+    /**
+     * The Cisco-style wildcard mask, e.g. `::ffff:ffff:ffff:ffff` for a
+     * `/64`. This is the bitwise inverse of `subnetMaskAddress()`. Returns
+     * an `Address6`; call `.correctForm()` for the string.
+     * @returns {Address6}
+     */
+    wildcardMask() {
+        return Address6.fromBigInt(BigInt(`0b${'0'.repeat(this.subnetMask)}${'1'.repeat(constants6.BITS - this.subnetMask)}`));
+    }
+    /**
+     * The network address in CIDR string form, e.g. `2001:db8::/32` for
+     * `2001:db8::1/32`. For an address with no explicit subnet the prefix
+     * is `/128`, e.g. `networkForm()` on `2001:db8::1` returns
+     * `2001:db8::1/128`.
+     * @returns {string}
+     */
+    networkForm() {
+        return `${this.startAddress().correctForm()}/${this.subnetMask}`;
+    }
+    /**
+     * Return the scope of the address. The 4-bit scope field
+     * ([RFC 4291 §2.7](https://datatracker.ietf.org/doc/html/rfc4291#section-2.7))
+     * is only defined for multicast addresses; for unicast addresses the scope
+     * is derived from the address type per
+     * [RFC 4007 §6](https://datatracker.ietf.org/doc/html/rfc4007#section-6).
      * @returns {String}
      */
     getScope() {
-        let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
-        if (this.getType() === 'Global unicast' && scope !== 'Link local') {
-            scope = 'Global';
+        const type = this.getType();
+        if (type === 'Multicast' || type.startsWith('Multicast ')) {
+            const scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+            return scope || 'Unknown';
+        }
+        // RFC 4291 §2.5.3: the loopback address is treated as having Link-Local
+        // scope. (Multicast scope 1, "Interface-Local", is a different concept
+        // used only for loopback transmission of multicast.)
+        if (type === 'Link-local unicast' || type === 'Loopback') {
+            return 'Link local';
+        }
+        // RFC 4007 §6: the unspecified address has no scope.
+        if (type === 'Unspecified') {
+            return 'Unknown';
         }
-        return scope || 'Unknown';
+        return 'Global';
     }
     /**
      * Return the type of the address
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     getType() {
-        for (const subnet of Object.keys(constants6.TYPES)) {
-            if (this.isInSubnet(new Address6(subnet))) {
-                return constants6.TYPES[subnet];
+        for (let i = 0; i < TYPE_SUBNETS.length; i++) {
+            const entry = TYPE_SUBNETS[i];
+            if (this.isInSubnet(entry[0])) {
+                return entry[1];
             }
         }
         return 'Global unicast';
     }
     /**
      * Return the bits in the given range as a BigInt
-     * @memberof Address6
-     * @instance
      * @returns {bigint}
      */
     getBits(start, end) {
@@ -405,8 +508,6 @@ class Address6 {
     }
     /**
      * Return the bits in the given range as a base-2 string
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     getBitsBase2(start, end) {
@@ -414,8 +515,6 @@ class Address6 {
     }
     /**
      * Return the bits in the given range as a base-16 string
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     getBitsBase16(start, end) {
@@ -429,8 +528,6 @@ class Address6 {
     }
     /**
      * Return the bits that are set past the subnet mask length
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     getBitsPastSubnet() {
@@ -438,10 +535,8 @@ class Address6 {
     }
     /**
      * Return the reversed ip6.arpa form of the address
-     * @memberof Address6
      * @param {Object} options
      * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix
-     * @instance
      * @returns {String}
      */
     reverseForm(options) {
@@ -467,10 +562,10 @@ class Address6 {
         return 'ip6.arpa.';
     }
     /**
-     * Return the correct form of the address
-     * @memberof Address6
-     * @instance
-     * @returns {String}
+     * Returns the address in correct form, per
+     * [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952): leading zeros
+     * stripped, the longest run of zero groups collapsed to `::`, and hex digits
+     * lowercased (e.g. `2001:db8::1`). This is the recommended form for display.
      */
     correctForm() {
         let i;
@@ -514,8 +609,6 @@ class Address6 {
     }
     /**
      * Return a zero-padded base-2 string representation of the address
-     * @memberof Address6
-     * @instance
      * @returns {String}
      * @example
      * var address = new Address6('2001:4860:4001:803::1011');
@@ -524,10 +617,22 @@ class Address6 {
      * //  0000000000000000000000000000000000000000000000000001000000010001'
      */
     binaryZeroPad() {
-        return this.bigInt().toString(2).padStart(constants6.BITS, '0');
+        if (this._binaryZeroPad === undefined) {
+            this._binaryZeroPad = this.bigInt().toString(2).padStart(constants6.BITS, '0');
+        }
+        return this._binaryZeroPad;
     }
+    /**
+     * Parses a v4-in-v6 string (e.g. `::ffff:192.168.0.1`) by extracting the
+     * trailing IPv4 address into `this.address4` / `this.parsedAddress4` and
+     * returning the address with the v4 portion converted to two v6 groups.
+     * Used internally by `parse()`.
+     */
     // TODO: Improve the semantics of this helper function
     parse4in6(address) {
+        if (address.indexOf('.') === -1) {
+            return address;
+        }
         const groups = address.split(':');
         const lastGroup = groups.slice(-1)[0];
         const address4 = lastGroup.match(constants4.RE_ADDRESS);
@@ -536,7 +641,12 @@ class Address6 {
             this.address4 = new ipv4_1.Address4(this.parsedAddress4);
             for (let i = 0; i < this.address4.groups; i++) {
                 if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {
-                    throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join('.')));
+                    // The prefix groups haven't been through the bad-character check
+                    // yet, so escape them before including in the error HTML.
+                    const highlighted = this.address4.parsedAddress.map(spanLeadingZeroes4).join('.');
+                    const prefix = groups.slice(0, -1).map(helpers.escapeHtml).join(':');
+                    const separator = groups.length > 1 ? ':' : '';
+                    throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", `${prefix}${separator}${highlighted}`);
                 }
             }
             this.v4 = true;
@@ -545,6 +655,13 @@ class Address6 {
         }
         return address;
     }
+    /**
+     * Parses an IPv6 address string into its 8 hexadecimal groups (expanding
+     * any `::` elision and any trailing v4-in-v6 portion) and stores the result
+     * on `this.parsedAddress`. Called automatically by the constructor; you
+     * typically don't need to call it directly. Throws `AddressError` if the
+     * input is malformed.
+     */
     // TODO: Make private?
     parse(address) {
         address = this.parse4in6(address);
@@ -594,18 +711,16 @@ class Address6 {
         return groups;
     }
     /**
-     * Return the canonical form of the address
-     * @memberof Address6
-     * @instance
-     * @returns {String}
+     * Returns the canonical (fully expanded) form of the address: all 8 groups,
+     * each padded to 4 hex digits, with no `::` collapsing
+     * (e.g. `2001:0db8:0000:0000:0000:0000:0000:0001`). Useful for sorting and
+     * byte-exact comparison.
      */
     canonicalForm() {
         return this.parsedAddress.map(paddedHex).join(':');
     }
     /**
      * Return the decimal form of the address
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     decimal() {
@@ -613,8 +728,6 @@ class Address6 {
     }
     /**
      * Return the address as a BigInt
-     * @memberof Address6
-     * @instance
      * @returns {bigint}
      */
     bigInt() {
@@ -622,8 +735,6 @@ class Address6 {
     }
     /**
      * Return the last two groups of this address as an IPv4 address string
-     * @memberof Address6
-     * @instance
      * @returns {Address4}
      * @example
      * var address = new Address6('2001:4860:4001::1825:bf11');
@@ -631,12 +742,10 @@ class Address6 {
      */
     to4() {
         const binary = this.binaryZeroPad().split('');
-        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16));
+        return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join('')}`).toString(16).padStart(8, '0'));
     }
     /**
      * Return the v4-in-v6 form of the address
-     * @memberof Address6
-     * @instance
      * @returns {String}
      */
     to4in6() {
@@ -650,10 +759,10 @@ class Address6 {
         return correct + infix + address4.address;
     }
     /**
-     * Return an object containing the Teredo properties of the address
-     * @memberof Address6
-     * @instance
-     * @returns {Object}
+     * Decodes the Teredo tunneling fields embedded in this address. Returns the
+     * Teredo prefix, server IPv4, client IPv4, raw flag bits, cone-NAT flag,
+     * UDP port, and Microsoft-format flag breakdown (reserved, universal/local,
+     * group/individual, nonce). Only meaningful for addresses in `2001::/32`.
      */
     inspectTeredo() {
         /*
@@ -684,7 +793,7 @@ class Address6 {
         const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));
         const bitsForClient4 = this.getBits(96, 128);
         // eslint-disable-next-line no-bitwise
-        const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt('0xffffffff')).toString(16));
+        const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt('0xffffffff')).toString(16).padStart(8, '0'));
         const flagsBase2 = this.getBitsBase2(64, 80);
         const coneNat = (0, common_1.testBit)(flagsBase2, 15);
         const reserved = (0, common_1.testBit)(flagsBase2, 14);
@@ -707,10 +816,9 @@ class Address6 {
         };
     }
     /**
-     * Return an object containing the 6to4 properties of the address
-     * @memberof Address6
-     * @instance
-     * @returns {Object}
+     * Decodes the 6to4 tunneling fields embedded in this address. Returns the
+     * 6to4 prefix and the embedded IPv4 gateway address. Only meaningful for
+     * addresses in `2002::/16`.
      */
     inspect6to4() {
         /*
@@ -726,8 +834,6 @@ class Address6 {
     }
     /**
      * Return a v6 6to4 address from a v6 v4inv6 address
-     * @memberof Address6
-     * @instance
      * @returns {Address6}
      */
     to6to4() {
@@ -744,9 +850,80 @@ class Address6 {
         return new Address6(addr6to4);
     }
     /**
-     * Return a byte array
-     * @memberof Address6
-     * @instance
+     * Embed an IPv4 address into a NAT64 IPv6 address using the encoding
+     * defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).
+     * The default prefix is the well-known prefix `64:ff9b::/96`. The prefix
+     * length must be one of 32, 40, 48, 56, 64, or 96; for prefixes shorter
+     * than /64 the IPv4 octets are split around the reserved bits 64–71.
+     * @example
+     * Address6.fromAddress4Nat64('192.0.2.33').correctForm(); // '64:ff9b::c000:221'
+     * Address6.fromAddress4Nat64('192.0.2.33', '2001:db8::/32').correctForm(); // '2001:db8:c000:221::'
+     */
+    static fromAddress4Nat64(address, prefix = '64:ff9b::/96') {
+        const v4 = new ipv4_1.Address4(address);
+        const prefix6 = new Address6(prefix);
+        const pl = prefix6.subnetMask;
+        if (pl !== 32 && pl !== 40 && pl !== 48 && pl !== 56 && pl !== 64 && pl !== 96) {
+            throw new address_error_1.AddressError('NAT64 prefix length must be 32, 40, 48, 56, 64, or 96');
+        }
+        const prefixBits = prefix6.binaryZeroPad();
+        const v4Bits = v4.binaryZeroPad();
+        let bits;
+        if (pl === 96) {
+            bits = prefixBits.slice(0, 96) + v4Bits;
+        }
+        else {
+            const beforeU = 64 - pl;
+            bits =
+                prefixBits.slice(0, pl) +
+                    v4Bits.slice(0, beforeU) +
+                    '00000000' +
+                    v4Bits.slice(beforeU) +
+                    '0'.repeat(128 - 72 - (32 - beforeU));
+        }
+        const hex = BigInt(`0b${bits}`).toString(16).padStart(32, '0');
+        const groups = [];
+        for (let i = 0; i < 8; i++) {
+            groups.push(hex.slice(i * 4, (i + 1) * 4));
+        }
+        return new Address6(groups.join(':'));
+    }
+    /**
+     * Extract the embedded IPv4 address from a NAT64 IPv6 address using the
+     * encoding defined by [RFC 6052](https://datatracker.ietf.org/doc/html/rfc6052).
+     * The default prefix is the well-known prefix `64:ff9b::/96`. Returns
+     * `null` if this address is not contained within the given prefix.
+     * @example
+     * new Address6('64:ff9b::c000:221').toAddress4Nat64()!.correctForm(); // '192.0.2.33'
+     */
+    toAddress4Nat64(prefix = '64:ff9b::/96') {
+        const prefix6 = new Address6(prefix);
+        const pl = prefix6.subnetMask;
+        if (pl !== 32 && pl !== 40 && pl !== 48 && pl !== 56 && pl !== 64 && pl !== 96) {
+            throw new address_error_1.AddressError('NAT64 prefix length must be 32, 40, 48, 56, 64, or 96');
+        }
+        if (!this.isInSubnet(prefix6)) {
+            return null;
+        }
+        const bits = this.binaryZeroPad();
+        let v4Bits;
+        if (pl === 96) {
+            v4Bits = bits.slice(96, 128);
+        }
+        else {
+            const beforeU = 64 - pl;
+            v4Bits = bits.slice(pl, pl + beforeU) + bits.slice(72, 72 + (32 - beforeU));
+        }
+        const octets = [];
+        for (let i = 0; i < 4; i++) {
+            octets.push(parseInt(v4Bits.slice(i * 8, (i + 1) * 8), 2).toString());
+        }
+        return new ipv4_1.Address4(octets.join('.'));
+    }
+    /**
+     * Return a byte array.
+     *
+     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toByteArray())`.
      * @returns {Array}
      */
     toByteArray() {
@@ -760,27 +937,27 @@ class Address6 {
         return bytes;
     }
     /**
-     * Return an unsigned byte array
-     * @memberof Address6
-     * @instance
+     * Return an unsigned byte array.
+     *
+     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toUnsignedByteArray())`.
      * @returns {Array}
      */
     toUnsignedByteArray() {
         return this.toByteArray().map(unsignByte);
     }
     /**
-     * Convert a byte array to an Address6 object
-     * @memberof Address6
-     * @static
+     * Convert a byte array to an Address6 object.
+     *
+     * To convert from a Node.js `Buffer`, spread it: `Address6.fromByteArray([...buf])`.
      * @returns {Address6}
      */
     static fromByteArray(bytes) {
         return this.fromUnsignedByteArray(bytes.map(unsignByte));
     }
     /**
-     * Convert an unsigned byte array to an Address6 object
-     * @memberof Address6
-     * @static
+     * Convert an unsigned byte array to an Address6 object.
+     *
+     * To convert from a Node.js `Buffer`, spread it: `Address6.fromUnsignedByteArray([...buf])`.
      * @returns {Address6}
      */
     static fromUnsignedByteArray(bytes) {
@@ -795,8 +972,6 @@ class Address6 {
     }
     /**
      * Returns true if the address is in the canonical form, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     isCanonical() {
@@ -804,8 +979,6 @@ class Address6 {
     }
     /**
      * Returns true if the address is a link local address, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     isLinkLocal() {
@@ -818,53 +991,81 @@ class Address6 {
     }
     /**
      * Returns true if the address is a multicast address, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     isMulticast() {
-        return this.getType() === 'Multicast';
+        const type = this.getType();
+        return type === 'Multicast' || type.startsWith('Multicast ');
     }
     /**
-     * Returns true if the address is a v4-in-v6 address, false otherwise
-     * @memberof Address6
-     * @instance
+     * Returns true if the address was written in v4-in-v6 dotted-quad notation
+     * (e.g. `::ffff:127.0.0.1`), false otherwise. This is a notation-level flag
+     * and does not reflect whether the address bits lie in the IPv4-mapped
+     * (`::ffff:0:0/96`) subnet — for that, see {@link isMapped4}.
      * @returns {boolean}
      */
     is4() {
         return this.v4;
     }
+    /**
+     * Returns true if the address is an IPv4-mapped IPv6 address in
+     * `::ffff:0:0/96` ([RFC 4291 §2.5.5.2](https://datatracker.ietf.org/doc/html/rfc4291#section-2.5.5.2)),
+     * false otherwise. Unlike {@link is4}, this checks the underlying address
+     * bits rather than the textual notation, so `::ffff:127.0.0.1` and
+     * `::ffff:7f00:1` both return true.
+     * @returns {boolean}
+     */
+    isMapped4() {
+        return this.isInSubnet(IPV4_MAPPED_SUBNET);
+    }
     /**
      * Returns true if the address is a Teredo address, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     isTeredo() {
-        return this.isInSubnet(new Address6('2001::/32'));
+        return this.isInSubnet(TEREDO_SUBNET);
     }
     /**
      * Returns true if the address is a 6to4 address, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     is6to4() {
-        return this.isInSubnet(new Address6('2002::/16'));
+        return this.isInSubnet(SIX_TO_FOUR_SUBNET);
     }
     /**
      * Returns true if the address is a loopback address, false otherwise
-     * @memberof Address6
-     * @instance
      * @returns {boolean}
      */
     isLoopback() {
         return this.getType() === 'Loopback';
     }
+    /**
+     * Returns true if the address is a Unique Local Address in `fc00::/7` ([RFC 4193](https://datatracker.ietf.org/doc/html/rfc4193)). ULAs are the IPv6 equivalent of IPv4 [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private addresses.
+     * @returns {boolean}
+     */
+    isULA() {
+        return this.isInSubnet(ULA_SUBNET);
+    }
+    /**
+     * Returns true if the address is the unspecified address `::`.
+     * @returns {boolean}
+     */
+    isUnspecified() {
+        return this.getType() === 'Unspecified';
+    }
+    /**
+     * Returns true if the address is in the documentation prefix `2001:db8::/32` ([RFC 3849](https://datatracker.ietf.org/doc/html/rfc3849)).
+     * @returns {boolean}
+     */
+    isDocumentation() {
+        return this.isInSubnet(DOCUMENTATION_SUBNET);
+    }
     // #endregion
     // #region HTML
     /**
-     * @returns {String} the address in link form with a default port of 80
+     * Returns the address as an HTTP URL with the host bracketed, e.g.
+     * `http://[2001:db8::1]/`. If `optionalPort` is provided it is appended,
+     * e.g. `http://[2001:db8::1]:8080/`.
      */
     href(optionalPort) {
         if (optionalPort === undefined) {
@@ -876,7 +1077,12 @@ class Address6 {
         return `http://[${this.correctForm()}]${optionalPort}/`;
     }
     /**
-     * @returns {String} a link suitable for conveying the address via a URL hash
+     * Returns an HTML `<a>` element whose `href` encodes the address in a URL
+     * hash fragment (default prefix `/#address=`). Useful for linking between
+     * pages of an address-inspector UI.
+     * @param options.className - CSS class for the rendered `<a>` element
+     * @param options.prefix - hash prefix prepended to the address (default `/#address=`)
+     * @param options.v4 - when true, render the address in v4-in-v6 form
      */
     link(options) {
         if (!options) {
@@ -896,10 +1102,13 @@ class Address6 {
             formFunction = this.to4in6;
         }
         const form = formFunction.call(this);
+        const safeHref = helpers.escapeHtml(`${options.prefix}${form}`);
+        const safeForm = helpers.escapeHtml(form);
         if (options.className) {
-            return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`;
+            const safeClass = helpers.escapeHtml(options.className);
+            return `<a href="${safeHref}" class="${safeClass}">${safeForm}</a>`;
         }
-        return `<a href="${options.prefix}${form}">${form}</a>`;
+        return `<a href="${safeHref}">${safeForm}</a>`;
     }
     /**
      * Groups an address
@@ -908,13 +1117,13 @@ class Address6 {
     group() {
         if (this.elidedGroups === 0) {
             // The simple case
-            return helpers.simpleGroup(this.address).join(':');
+            return helpers.simpleGroup(this.addressMinusSuffix).join(':');
         }
         assert(typeof this.elidedGroups === 'number');
         assert(typeof this.elisionBegin === 'number');
         // The elided case
         const output = [];
-        const [left, right] = this.address.split('::');
+        const [left, right] = this.addressMinusSuffix.split('::');
         if (left.length) {
             output.push(...helpers.simpleGroup(left));
         }
@@ -944,8 +1153,6 @@ class Address6 {
     /**
      * Generate a regular expression string that can be used to find or validate
      * all variations of this address
-     * @memberof Address6
-     * @instance
      * @param {boolean} substringSearch
      * @returns {string}
      */
@@ -990,8 +1197,6 @@ class Address6 {
     /**
      * Generate a regular expression that can be used to find or validate all
      * variations of this address.
-     * @memberof Address6
-     * @instance
      * @param {boolean} substringSearch
      * @returns {RegExp}
      */
@@ -1000,4 +1205,13 @@ class Address6 {
     }
 }
 exports.Address6 = Address6;
+const TYPE_SUBNETS = Object.keys(constants6.TYPES).map((subnet) => [
+    new Address6(subnet),
+    constants6.TYPES[subnet],
+]);
+const TEREDO_SUBNET = new Address6('2001::/32');
+const SIX_TO_FOUR_SUBNET = new Address6('2002::/16');
+const ULA_SUBNET = new Address6('fc00::/7');
+const DOCUMENTATION_SUBNET = new Address6('2001:db8::/32');
+const IPV4_MAPPED_SUBNET = new Address6('::ffff:0:0/96');
 //# sourceMappingURL=ipv6.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/ip-address/dist/v6/constants.js b/deps/npm/node_modules/ip-address/dist/v6/constants.js
index 0abc423e0a91ab..1a8cd1dd616e86 100644
--- a/deps/npm/node_modules/ip-address/dist/v6/constants.js
+++ b/deps/npm/node_modules/ip-address/dist/v6/constants.js
@@ -46,6 +46,11 @@ exports.TYPES = {
     '::1/128': 'Loopback',
     'ff00::/8': 'Multicast',
     'fe80::/10': 'Link-local unicast',
+    'fc00::/7': 'Unique local',
+    '2002::/16': '6to4',
+    '2001:db8::/32': 'Documentation',
+    '64:ff9b::/96': 'NAT64 (well-known)',
+    '64:ff9b:1::/48': 'NAT64 (local-use)',
 };
 /**
  * A regular expression that matches bad characters in an IPv6 address
diff --git a/deps/npm/node_modules/ip-address/dist/v6/helpers.js b/deps/npm/node_modules/ip-address/dist/v6/helpers.js
index fafca0c2712ddc..e6bae04698a66a 100644
--- a/deps/npm/node_modules/ip-address/dist/v6/helpers.js
+++ b/deps/npm/node_modules/ip-address/dist/v6/helpers.js
@@ -1,14 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
 exports.spanAllZeroes = spanAllZeroes;
 exports.spanAll = spanAll;
 exports.spanLeadingZeroes = spanLeadingZeroes;
 exports.simpleGroup = simpleGroup;
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
 /**
  * @returns {String} the string with all zeroes contained in a <span>
  */
 function spanAllZeroes(s) {
-    return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+    return escapeHtml(s).replace(/(0+)/g, '<span class="zero">$1</span>');
 }
 /**
  * @returns {String} the string with each character contained in a <span>
@@ -16,11 +25,11 @@ function spanAllZeroes(s) {
 function spanAll(s, offset = 0) {
     const letters = s.split('');
     return letters
-        .map((n, i) => `<span class="digit value-${n} position-${i + offset}">${spanAllZeroes(n)}</span>`)
+        .map((n, i) => `<span class="digit value-${escapeHtml(n)} position-${i + offset}">${spanAllZeroes(n)}</span>`)
         .join('');
 }
 function spanLeadingZeroesSimple(group) {
-    return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+    return escapeHtml(group).replace(/^(0+)/, '<span class="zero">$1</span>');
 }
 /**
  * @returns {String} the string with leading zeroes contained in a <span>
diff --git a/deps/npm/node_modules/ip-address/package.json b/deps/npm/node_modules/ip-address/package.json
index 5cf811e8c563af..47d109ec6f34da 100644
--- a/deps/npm/node_modules/ip-address/package.json
+++ b/deps/npm/node_modules/ip-address/package.json
@@ -2,77 +2,87 @@
   "name": "ip-address",
   "description": "A library for parsing IPv4 and IPv6 IP addresses in node and the browser.",
   "keywords": [
-    "ipv6",
+    "ip",
     "ipv4",
-    "browser",
-    "validation"
+    "ipv6",
+    "address",
+    "cidr",
+    "subnet",
+    "netmask",
+    "validate",
+    "validation",
+    "parse",
+    "arpa",
+    "bigint",
+    "browser"
   ],
-  "version": "10.1.0",
+  "version": "10.2.0",
   "author": "Beau Gunderson <beau@beaugunderson.com> (https://beaugunderson.com/)",
   "license": "MIT",
   "main": "dist/ip-address.js",
   "types": "dist/ip-address.d.ts",
   "scripts": {
-    "docs": "documentation build --github --output docs --format html ./ip-address.js",
+    "docs": "tsx scripts/build-readme.ts",
     "build": "rm -rf dist; mkdir dist; tsc",
-    "prepack": "npm run build",
-    "release": "release-it",
-    "test-ci": "nyc mocha",
+    "prepack": "npm run docs && npm run build",
+    "test-ci": "c8 --experimental-monocart mocha",
     "test": "mocha",
     "watch": "mocha --watch"
   },
-  "nyc": {
-    "extension": [
-      ".ts"
+  "c8": {
+    "include": [
+      "src/**/*.ts"
     ],
     "exclude": [
       "**/*.d.ts",
-      ".eslintrc.js",
-      "coverage/",
-      "dist/",
-      "test/",
-      "tmp/"
+      "src/ip-address.ts",
+      "src/v4/constants.ts",
+      "src/v6/constants.ts"
     ],
     "reporter": [
       "html",
       "lcov",
       "text"
-    ],
-    "all": true
+    ]
   },
   "engines": {
     "node": ">= 12"
   },
+  "sideEffects": false,
   "files": [
-    "src",
     "dist"
   ],
   "repository": {
     "type": "git",
     "url": "git://github.com/beaugunderson/ip-address.git"
   },
+  "overrides": {
+    "diff": "^8.0.3",
+    "serialize-javascript": "^7.0.5",
+    "@eslint/plugin-kit": "^0.7.1"
+  },
   "devDependencies": {
-    "@types/chai": "^5.0.0",
-    "@types/mocha": "^10.0.8",
-    "@typescript-eslint/eslint-plugin": "^8.8.0",
-    "@typescript-eslint/parser": "^8.8.0",
-    "chai": "^5.1.1",
-    "documentation": "^14.0.3",
-    "eslint": "^8.50.0",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.59.1",
+    "@typescript-eslint/parser": "^8.59.1",
+    "c8": "^11.0.0",
+    "chai": "^6.2.2",
+    "eslint": "^8.57.1",
     "eslint_d": "^14.0.4",
     "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-filenames": "^1.3.2",
-    "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-jsx-a11y": "^6.10.0",
-    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-sort-imports-es6-autofix": "^0.6.0",
-    "mocha": "^10.7.3",
-    "nyc": "^17.1.0",
-    "prettier": "^3.3.3",
-    "release-it": "^17.6.0",
+    "mocha": "^11.7.5",
+    "monocart-coverage-reports": "^2.12.11",
+    "prettier": "^3.8.3",
     "source-map-support": "^0.5.21",
-    "tsx": "^4.19.1",
+    "tsx": "^4.21.0",
+    "typedoc": "^0.28.19",
     "typescript": "<5.6.0"
   }
 }
diff --git a/deps/npm/node_modules/libnpmdiff/package.json b/deps/npm/node_modules/libnpmdiff/package.json
index a59017ff3d9731..974b7346e01068 100644
--- a/deps/npm/node_modules/libnpmdiff/package.json
+++ b/deps/npm/node_modules/libnpmdiff/package.json
@@ -1,6 +1,6 @@
 {
   "name": "libnpmdiff",
-  "version": "8.1.6",
+  "version": "8.1.8",
   "description": "The registry diff",
   "repository": {
     "type": "git",
@@ -47,7 +47,7 @@
     "tap": "^16.3.8"
   },
   "dependencies": {
-    "@npmcli/arborist": "^9.4.3",
+    "@npmcli/arborist": "^9.6.0",
     "@npmcli/installed-package-contents": "^4.0.0",
     "binary-extensions": "^3.0.0",
     "diff": "^8.0.2",
diff --git a/deps/npm/node_modules/libnpmexec/package.json b/deps/npm/node_modules/libnpmexec/package.json
index 078c5618a4cd33..52a1e1539d2697 100644
--- a/deps/npm/node_modules/libnpmexec/package.json
+++ b/deps/npm/node_modules/libnpmexec/package.json
@@ -1,6 +1,6 @@
 {
   "name": "libnpmexec",
-  "version": "10.2.6",
+  "version": "10.2.8",
   "files": [
     "bin/",
     "lib/"
@@ -61,7 +61,7 @@
   },
   "dependencies": {
     "@gar/promise-retry": "^1.0.0",
-    "@npmcli/arborist": "^9.4.3",
+    "@npmcli/arborist": "^9.6.0",
     "@npmcli/package-json": "^7.0.0",
     "@npmcli/run-script": "^10.0.0",
     "ci-info": "^4.0.0",
diff --git a/deps/npm/node_modules/libnpmfund/package.json b/deps/npm/node_modules/libnpmfund/package.json
index 62e73f5ef6436b..9c35a66a27e31f 100644
--- a/deps/npm/node_modules/libnpmfund/package.json
+++ b/deps/npm/node_modules/libnpmfund/package.json
@@ -1,6 +1,6 @@
 {
   "name": "libnpmfund",
-  "version": "7.0.20",
+  "version": "7.0.22",
   "main": "lib/index.js",
   "files": [
     "bin/",
@@ -46,7 +46,7 @@
     "tap": "^16.3.8"
   },
   "dependencies": {
-    "@npmcli/arborist": "^9.4.3"
+    "@npmcli/arborist": "^9.6.0"
   },
   "engines": {
     "node": "^20.17.0 || >=22.9.0"
diff --git a/deps/npm/node_modules/libnpmpack/package.json b/deps/npm/node_modules/libnpmpack/package.json
index befca6090e66b8..11029cf91ee08a 100644
--- a/deps/npm/node_modules/libnpmpack/package.json
+++ b/deps/npm/node_modules/libnpmpack/package.json
@@ -1,6 +1,6 @@
 {
   "name": "libnpmpack",
-  "version": "9.1.6",
+  "version": "9.1.8",
   "description": "Programmatic API for the bits behind npm pack",
   "author": "GitHub Inc.",
   "main": "lib/index.js",
@@ -37,7 +37,7 @@
   "bugs": "https://github.com/npm/libnpmpack/issues",
   "homepage": "https://npmjs.com/package/libnpmpack",
   "dependencies": {
-    "@npmcli/arborist": "^9.4.3",
+    "@npmcli/arborist": "^9.6.0",
     "@npmcli/run-script": "^10.0.0",
     "npm-package-arg": "^13.0.0",
     "pacote": "^21.0.2"
diff --git a/deps/npm/node_modules/libnpmpublish/README.md b/deps/npm/node_modules/libnpmpublish/README.md
index 90b1f7c68ab4f2..4daac34feaad10 100644
--- a/deps/npm/node_modules/libnpmpublish/README.md
+++ b/deps/npm/node_modules/libnpmpublish/README.md
@@ -62,6 +62,13 @@ A couple of options of note:
   containing a [DSSE](https://github.com/secure-systems-lab/dsse)-packaged
   provenance statement.
 
+* `opts.stage` - when `true`, publishes the package to a staging area instead
+  of making it immediately available. The registry response will include a
+  `stageId` (UUID) that can be used to approve or reject the staged version
+  later. Changes the request method to `POST` and the endpoint to
+  `/-/stage/package/<name>`. The returned Response object will have a
+  `stageId` property.
+
 #### <a name="publish"></a> `> libpub.publish(manifest, tarData, [opts]) -> Promise`
 
 Sends the package represented by the `manifest` and `tarData` to the
diff --git a/deps/npm/node_modules/libnpmpublish/lib/publish.js b/deps/npm/node_modules/libnpmpublish/lib/publish.js
index 933e142422b6c4..cfe85d2d29f57b 100644
--- a/deps/npm/node_modules/libnpmpublish/lib/publish.js
+++ b/deps/npm/node_modules/libnpmpublish/lib/publish.js
@@ -50,15 +50,20 @@ Remove the 'private' field from the package.json to publish it.`),
     opts
   )
 
-  const res = await npmFetch(spec.escapedName, {
+  const stageRoute = `/-/stage/package/${spec.escapedName}`
+  const res = await npmFetch(opts.stage ? stageRoute : spec.escapedName, {
     ...opts,
-    method: 'PUT',
+    method: opts.stage ? 'POST' : 'PUT',
     body: metadata,
-    ignoreBody: true,
+    ignoreBody: !opts.stage,
   })
   if (transparencyLogUrl) {
     res.transparencyLogUrl = transparencyLogUrl
   }
+  if (opts.stage) {
+    const json = await res.json()
+    res.stageId = json.stageId
+  }
   return res
 }
 
@@ -86,7 +91,7 @@ const patchManifest = async (_manifest, opts) => {
 }
 
 const buildMetadata = async (registry, manifest, tarballData, spec, opts) => {
-  const { access, defaultTag, algorithms, provenance, provenanceFile } = opts
+  const { access, defaultTag, algorithms, provenance, provenanceFile, command = 'publish' } = opts
   const root = {
     _id: manifest.name,
     name: manifest.name,
@@ -141,14 +146,14 @@ const buildMetadata = async (registry, manifest, tarballData, spec, opts) => {
       provenanceBundle = await generateProvenance([subject], opts)
 
       /* eslint-disable-next-line max-len */
-      log.notice('publish', `Signed provenance statement with source and build information from ${ciInfo.name}`)
+      log.notice(command, `Signed provenance statement with source and build information from ${ciInfo.name}`)
 
       const tlogEntry = provenanceBundle?.verificationMaterial?.tlogEntries[0]
       /* istanbul ignore else */
       if (tlogEntry) {
         transparencyLogUrl = `${TLOG_BASE_URL}?logIndex=${tlogEntry.logIndex}`
         log.notice(
-          'publish',
+          command,
           `Provenance statement published to transparency log: ${transparencyLogUrl}`
         )
       }
diff --git a/deps/npm/node_modules/libnpmpublish/package.json b/deps/npm/node_modules/libnpmpublish/package.json
index f90a6bf4506ecd..5b4ae66e57284c 100644
--- a/deps/npm/node_modules/libnpmpublish/package.json
+++ b/deps/npm/node_modules/libnpmpublish/package.json
@@ -1,6 +1,6 @@
 {
   "name": "libnpmpublish",
-  "version": "11.1.3",
+  "version": "11.2.0",
   "description": "Programmatic API for the bits behind npm publish and unpublish",
   "author": "GitHub Inc.",
   "main": "lib/index.js",
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.js b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.js
new file mode 100644
index 00000000000000..8f6a8f12edb399
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/diagnostics-channel.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-browser.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.js b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.js
new file mode 100644
index 00000000000000..6b8268b0ea9123
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.js
@@ -0,0 +1,1726 @@
+"use strict";
+/**
+ * @module LRUCache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+const diagnostics_channel_js_1 = require("./diagnostics-channel.js");
+const perf_js_1 = require("./perf.js");
+const hasSubscribers = () => diagnostics_channel_js_1.metrics.hasSubscribers || diagnostics_channel_js_1.tracing.hasSubscribers;
+const warned = new Set();
+/* c8 ignore start */
+const PROCESS = (typeof process === 'object' && !!process ?
+    process
+    : {});
+/* c8 ignore stop */
+const emitWarning = (msg, type, code, fn) => {
+    if (typeof PROCESS.emitWarning === 'function') {
+        PROCESS.emitWarning(msg, type, code, fn);
+    }
+    else {
+        //oxlint-disable-next-line no-console
+        console.error(`[${code}] ${type}: ${msg}`);
+    }
+};
+const shouldWarn = (code) => !warned.has(code);
+const TYPE = Symbol('type');
+const isPosInt = (n) => !!n && n === Math.floor(n) && n > 0 && isFinite(n);
+// This is a little bit ridiculous, tbh.
+// The maximum array length is 2^32-1 or thereabouts on most JS impls.
+// And well before that point, you're caching the entire world, I mean,
+// that's ~32GB of just integers for the next/prev links, plus whatever
+// else to hold that many keys and values.  Just filling the memory with
+// zeroes at init time is brutal when you get that big.
+// But why not be complete?
+// Maybe in the future, these limits will have expanded.
+/* c8 ignore start */
+const getUintArray = (max) => !isPosInt(max) ? null
+    : max <= Math.pow(2, 8) ? Uint8Array
+        : max <= Math.pow(2, 16) ? Uint16Array
+            : max <= Math.pow(2, 32) ? Uint32Array
+                : max <= Number.MAX_SAFE_INTEGER ? ZeroArray
+                    : null;
+/* c8 ignore stop */
+class ZeroArray extends Array {
+    constructor(size) {
+        super(size);
+        this.fill(0);
+    }
+}
+class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
+    heap;
+    /* c8 ignore stop */
+    length;
+    // private constructor
+    static #constructing = false;
+    static create(max) {
+        const HeapCls = getUintArray(max);
+        if (!HeapCls)
+            return [];
+        Stack.#constructing = true;
+        const s = new Stack(max, HeapCls);
+        Stack.#constructing = false;
+        return s;
+    }
+    constructor(max, HeapCls) {
+        /* c8 ignore start */
+        if (!Stack.#constructing) {
+            throw new TypeError('instantiate Stack using Stack.create(n)');
+        }
+        /* c8 ignore stop */
+        this.heap = new HeapCls(max);
+        this.length = 0;
+    }
+    push(n) {
+        this.heap[this.length++] = n;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+/**
+ * Default export, the thing you're using this module to get.
+ *
+ * The `K` and `V` types define the key and value types, respectively. The
+ * optional `FC` type defines the type of the `context` object passed to
+ * `cache.fetch()` and `cache.memo()`.
+ *
+ * Keys and values **must not** be `null` or `undefined`.
+ *
+ * All properties from the options object (with the exception of `max`,
+ * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+ * added as normal public members. (The listed options are read-only getters.)
+ *
+ * Changing any of these will alter the defaults for subsequent method calls.
+ */
+class LRUCache {
+    // options that cannot be changed without disaster
+    #max;
+    #maxSize;
+    #dispose;
+    #onInsert;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    #perf;
+    /**
+     * {@link LRUCache.OptionsBase.perf}
+     */
+    get perf() {
+        return this.#perf;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    ttl;
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    ttlResolution;
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    ttlAutopurge;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    updateAgeOnGet;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    updateAgeOnHas;
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    allowStale;
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    noDisposeOnSet;
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    noUpdateTTL;
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    maxEntrySize;
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    sizeCalculation;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    noDeleteOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    noDeleteOnStaleGet;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    allowStaleOnFetchAbort;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    allowStaleOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
+    // computed properties
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #autopurgeTimers;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    #hasOnInsert;
+    /**
+     * Do not call this method unless you need to inspect the
+     * inner workings of the cache.  If anything returned by this
+     * object is modified in any way, strange breakage may occur.
+     *
+     * These fields are private for a reason!
+     *
+     * @internal
+     */
+    static unsafeExposeInternals(c) {
+        return {
+            // properties
+            starts: c.#starts,
+            ttls: c.#ttls,
+            autopurgeTimers: c.#autopurgeTimers,
+            sizes: c.#sizes,
+            keyMap: c.#keyMap,
+            keyList: c.#keyList,
+            valList: c.#valList,
+            next: c.#next,
+            prev: c.#prev,
+            get head() {
+                return c.#head;
+            },
+            get tail() {
+                return c.#tail;
+            },
+            free: c.#free,
+            // methods
+            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+            moveToTail: (index) => c.#moveToTail(index),
+            indexes: (options) => c.#indexes(options),
+            rindexes: (options) => c.#rindexes(options),
+            isStale: (index) => c.#isStale(index),
+        };
+    }
+    // Protected read-only members
+    /**
+     * {@link LRUCache.OptionsBase.max} (read-only)
+     */
+    get max() {
+        return this.#max;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.maxSize} (read-only)
+     */
+    get maxSize() {
+        return this.#maxSize;
+    }
+    /**
+     * The total computed size of items in the cache (read-only)
+     */
+    get calculatedSize() {
+        return this.#calculatedSize;
+    }
+    /**
+     * The number of items stored in the cache (read-only)
+     */
+    get size() {
+        return this.#size;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+     */
+    get fetchMethod() {
+        return this.#fetchMethod;
+    }
+    get memoMethod() {
+        return this.#memoMethod;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.dispose} (read-only)
+     */
+    get dispose() {
+        return this.#dispose;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.onInsert} (read-only)
+     */
+    get onInsert() {
+        return this.#onInsert;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+     */
+    get disposeAfter() {
+        return this.#disposeAfter;
+    }
+    constructor(options) {
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
+        if (perf !== undefined) {
+            if (typeof perf?.now !== 'function') {
+                throw new TypeError('perf option must have a now() method if specified');
+            }
+        }
+        this.#perf = perf ?? perf_js_1.defaultPerf;
+        if (max !== 0 && !isPosInt(max)) {
+            throw new TypeError('max option must be a nonnegative integer');
+        }
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) {
+            throw new Error('invalid max value: ' + max);
+        }
+        this.#max = max;
+        this.#maxSize = maxSize;
+        this.maxEntrySize = maxEntrySize || this.#maxSize;
+        this.sizeCalculation = sizeCalculation;
+        if (this.sizeCalculation) {
+            if (!this.#maxSize && !this.maxEntrySize) {
+                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+            }
+            if (typeof this.sizeCalculation !== 'function') {
+                throw new TypeError('sizeCalculation set to non-function');
+            }
+        }
+        if (memoMethod !== undefined && typeof memoMethod !== 'function') {
+            throw new TypeError('memoMethod must be a function if defined');
+        }
+        this.#memoMethod = memoMethod;
+        if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
+            throw new TypeError('fetchMethod must be a function if specified');
+        }
+        this.#fetchMethod = fetchMethod;
+        this.#hasFetchMethod = !!fetchMethod;
+        this.#keyMap = new Map();
+        this.#keyList = Array.from({ length: max }).fill(undefined);
+        this.#valList = Array.from({ length: max }).fill(undefined);
+        this.#next = new UintArray(max);
+        this.#prev = new UintArray(max);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free = Stack.create(max);
+        this.#size = 0;
+        this.#calculatedSize = 0;
+        if (typeof dispose === 'function') {
+            this.#dispose = dispose;
+        }
+        if (typeof onInsert === 'function') {
+            this.#onInsert = onInsert;
+        }
+        if (typeof disposeAfter === 'function') {
+            this.#disposeAfter = disposeAfter;
+            this.#disposed = [];
+        }
+        else {
+            this.#disposeAfter = undefined;
+            this.#disposed = undefined;
+        }
+        this.#hasDispose = !!this.#dispose;
+        this.#hasOnInsert = !!this.#onInsert;
+        this.#hasDisposeAfter = !!this.#disposeAfter;
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+        this.ignoreFetchAbort = !!ignoreFetchAbort;
+        // NB: maxEntrySize is set to maxSize if it's set
+        if (this.maxEntrySize !== 0) {
+            if (this.#maxSize !== 0) {
+                if (!isPosInt(this.#maxSize)) {
+                    throw new TypeError('maxSize must be a positive integer if specified');
+                }
+            }
+            if (!isPosInt(this.maxEntrySize)) {
+                throw new TypeError('maxEntrySize must be a positive integer if specified');
+            }
+            this.#initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale;
+        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution =
+            isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || 0;
+        if (this.ttl) {
+            if (!isPosInt(this.ttl)) {
+                throw new TypeError('ttl must be a positive integer if specified');
+            }
+            this.#initializeTTLTracking();
+        }
+        // do not allow completely unbounded caches
+        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+            throw new TypeError('At least one of max, maxSize, or ttl is required');
+        }
+        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+            const code = 'LRU_CACHE_UNBOUNDED';
+            if (shouldWarn(code)) {
+                warned.add(code);
+                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
+                    'result in unbounded memory consumption.';
+                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+            }
+        }
+    }
+    /**
+     * Return the number of ms left in the item's TTL. If item is not in cache,
+     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+     */
+    getRemainingTTL(key) {
+        return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+        const ttls = new ZeroArray(this.#max);
+        const starts = new ZeroArray(this.#max);
+        this.#ttls = ttls;
+        this.#starts = starts;
+        const purgeTimers = this.ttlAutopurge ?
+            Array.from({
+                length: this.#max,
+            })
+            : undefined;
+        this.#autopurgeTimers = purgeTimers;
+        this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
+            starts[index] = ttl !== 0 ? start : 0;
+            ttls[index] = ttl;
+            setPurgetTimer(index, ttl);
+        };
+        this.#updateItemAge = index => {
+            starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+            setPurgetTimer(index, ttls[index]);
+        };
+        // clear out the purge timer if we're setting TTL to 0, and
+        // previously had a ttl purge timer running, so it doesn't
+        // fire unnecessarily. Don't need to do this if we're not doing
+        // autopurge.
+        const setPurgetTimer = !this.ttlAutopurge ?
+            () => { }
+            : (index, ttl) => {
+                if (purgeTimers?.[index]) {
+                    clearTimeout(purgeTimers[index]);
+                    purgeTimers[index] = undefined;
+                }
+                if (ttl && ttl !== 0 && purgeTimers) {
+                    const t = setTimeout(() => {
+                        if (this.#isStale(index)) {
+                            this.#delete(this.#keyList[index], 'expire');
+                        }
+                    }, ttl + 1);
+                    // unref() not supported on all platforms
+                    /* c8 ignore start */
+                    if (t.unref) {
+                        t.unref();
+                    }
+                    /* c8 ignore stop */
+                    purgeTimers[index] = t;
+                }
+            };
+        this.#statusTTL = (status, index) => {
+            if (ttls[index]) {
+                const ttl = ttls[index];
+                const start = starts[index];
+                /* c8 ignore start */
+                if (!ttl || !start) {
+                    return;
+                }
+                /* c8 ignore stop */
+                status.ttl = ttl;
+                status.start = start;
+                status.now = cachedNow || getNow();
+                const age = status.now - start;
+                status.remainingTTL = ttl - age;
+            }
+        };
+        // debounce calls to perf.now() to 1s so we're not hitting
+        // that costly call repeatedly.
+        let cachedNow = 0;
+        const getNow = () => {
+            const n = this.#perf.now();
+            if (this.ttlResolution > 0) {
+                cachedNow = n;
+                const t = setTimeout(() => (cachedNow = 0), this.ttlResolution);
+                // not available on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+            return n;
+        };
+        this.getRemainingTTL = key => {
+            const index = this.#keyMap.get(key);
+            if (index === undefined) {
+                return 0;
+            }
+            const ttl = ttls[index];
+            const start = starts[index];
+            if (!ttl || !start) {
+                return Infinity;
+            }
+            const age = (cachedNow || getNow()) - start;
+            return ttl - age;
+        };
+        this.#isStale = index => {
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        };
+    }
+    // conditionally set private methods related to TTL
+    #updateItemAge = () => { };
+    #statusTTL = () => { };
+    #setItemTTL = () => { };
+    /* c8 ignore stop */
+    #isStale = () => false;
+    #initializeSizeTracking() {
+        const sizes = new ZeroArray(this.#max);
+        this.#calculatedSize = 0;
+        this.#sizes = sizes;
+        this.#removeItemSize = index => {
+            this.#calculatedSize -= sizes[index];
+            sizes[index] = 0;
+        };
+        this.#requireSize = (k, v, size, sizeCalculation) => {
+            if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
+                if (sizeCalculation) {
+                    if (typeof sizeCalculation !== 'function') {
+                        throw new TypeError('sizeCalculation must be a function');
+                    }
+                    size = sizeCalculation(v, k);
+                    if (!isPosInt(size)) {
+                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+                    }
+                }
+                else {
+                    throw new TypeError('invalid size value (must be positive integer). ' +
+                        'When maxSize or maxEntrySize is used, sizeCalculation ' +
+                        'or size must be set.');
+                }
+            }
+            return size;
+        };
+        this.#addItemSize = (index, size, status) => {
+            sizes[index] = size;
+            if (this.#maxSize) {
+                const maxSize = this.#maxSize - sizes[index];
+                while (this.#calculatedSize > maxSize) {
+                    this.#evict(true);
+                }
+            }
+            this.#calculatedSize += sizes[index];
+            if (status) {
+                status.entrySize = size;
+                status.totalCalculatedSize = this.#calculatedSize;
+            }
+        };
+    }
+    #removeItemSize = _i => { };
+    #addItemSize = (_i, _s, _st) => { };
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+        if (size || sizeCalculation) {
+            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+        }
+        return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#tail; this.#isValidIndex(i);) {
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#head) {
+                    break;
+                }
+                else {
+                    i = this.#prev[i];
+                }
+            }
+        }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#head; this.#isValidIndex(i);) {
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#tail) {
+                    break;
+                }
+                else {
+                    i = this.#next[i];
+                }
+            }
+        }
+    }
+    #isValidIndex(index) {
+        return (index !== undefined &&
+            this.#keyMap.get(this.#keyList[index]) === index);
+    }
+    /**
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from most recently used to least recently used.
+     */
+    *entries() {
+        for (const i of this.#indexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.entries}
+     *
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from least recently used to most recently used.
+     */
+    *rentries() {
+        for (const i of this.#rindexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the keys in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *keys() {
+        for (const i of this.#indexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.keys}
+     *
+     * Return a generator yielding the keys in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rkeys() {
+        for (const i of this.#rindexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the values in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *values() {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.values}
+     *
+     * Return a generator yielding the values in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rvalues() {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Iterating over the cache itself yields the same results as
+     * {@link LRUCache.entries}
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
+     */
+    [Symbol.toStringTag] = 'LRUCache';
+    /**
+     * Find a value for which the supplied fn method returns a truthy value,
+     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+     */
+    find(fn, getOptions = {}) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            if (fn(value, this.#keyList[i], this)) {
+                return this.#get(this.#keyList[i], getOptions);
+            }
+        }
+    }
+    /**
+     * Call the supplied function on each item in the cache, in order from most
+     * recently used to least recently used.
+     *
+     * `fn` is called as `fn(value, key, cache)`.
+     *
+     * If `thisp` is provided, function will be called in the `this`-context of
+     * the provided object, or the cache if no `thisp` object is provided.
+     *
+     * Does not update age or recenty of use, or iterate over stale values.
+     */
+    forEach(fn, thisp = this) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * The same as {@link LRUCache.forEach} but items are iterated over in
+     * reverse order.  (ie, less recently used items are iterated over first.)
+     */
+    rforEach(fn, thisp = this) {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * Delete any stale entries. Returns true if anything was removed,
+     * false otherwise.
+     */
+    purgeStale() {
+        let deleted = false;
+        for (const i of this.#rindexes({ allowStale: true })) {
+            if (this.#isStale(i)) {
+                this.#delete(this.#keyList[i], 'expire');
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Returns `undefined` if the key is not present.
+     *
+     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+     * serialization, the `start` value is always the current timestamp, and the
+     * `ttl` is a calculated remaining time to live (negative if expired).
+     *
+     * Always returns stale values, if their info is found in the cache, so be
+     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+     * if relevant.
+     */
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (i === undefined)
+            return undefined;
+        const v = this.#valList[i];
+        /* c8 ignore start - this isn't tested for the info function,
+         * but it's the same logic as found in other places. */
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined)
+            return undefined;
+        /* c8 ignore stop */
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (this.#perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) {
+            entry.size = this.#sizes[i];
+        }
+        return entry;
+    }
+    /**
+     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+     * passed to {@link LRUCache#load}.
+     *
+     * The `start` fields are calculated relative to a portable `Date.now()`
+     * timestamp, even if `performance.now()` is available.
+     *
+     * Stale entries are always included in the `dump`, even if
+     * {@link LRUCache.OptionsBase.allowStale} is false.
+     *
+     * Note: this returns an actual array, not a generator, so it can be more
+     * easily passed around.
+     */
+    dump() {
+        const arr = [];
+        for (const i of this.#indexes({ allowStale: true })) {
+            const key = this.#keyList[i];
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined || key === undefined)
+                continue;
+            const entry = { value };
+            if (this.#ttls && this.#starts) {
+                entry.ttl = this.#ttls[i];
+                // always dump the start relative to a portable timestamp
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = this.#perf.now() - this.#starts[i];
+                entry.start = Math.floor(Date.now() - age);
+            }
+            if (this.#sizes) {
+                entry.size = this.#sizes[i];
+            }
+            arr.unshift([key, entry]);
+        }
+        return arr;
+    }
+    /**
+     * Reset the cache and load in the items in entries in the order listed.
+     *
+     * The shape of the resulting cache may be different if the same options are
+     * not used in both caches.
+     *
+     * The `start` fields are assumed to be calculated relative to a portable
+     * `Date.now()` timestamp, even if `performance.now()` is available.
+     */
+    load(arr) {
+        this.clear();
+        for (const [key, entry] of arr) {
+            if (entry.start) {
+                // entry.start is a portable timestamp, but we may be using
+                // node's performance.now(), so calculate the offset, so that
+                // we get the intended remaining TTL, no matter how long it's
+                // been on ice.
+                //
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = Date.now() - entry.start;
+                entry.start = this.#perf.now() - age;
+            }
+            this.#set(key, entry.value, entry);
+        }
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * Note: if `undefined` is specified as a value, this is an alias for
+     * {@link LRUCache#delete}
+     *
+     * Fields on the {@link LRUCache.SetOptions} options param will override
+     * their corresponding values in the constructor options for the scope
+     * of this single `set()` operation.
+     *
+     * If `start` is provided, then that will set the effective start
+     * time for the TTL calculation. Note that this must be a previous
+     * value of `performance.now()` if supported, or a previous value of
+     * `Date.now()` if not.
+     *
+     * Options object may also include `size`, which will prevent
+     * calling the `sizeCalculation` function and just use the specified
+     * number if it is a positive integer, and `noDisposeOnSet` which
+     * will prevent calling a `dispose` function in the case of
+     * overwrites.
+     *
+     * If the `size` (or return value of `sizeCalculation`) for a given
+     * entry is greater than `maxEntrySize`, then the item will not be
+     * added to the cache.
+     *
+     * Will update the recency of the entry.
+     *
+     * If the value is `undefined`, then this is an alias for
+     * `cache.delete(key)`. `undefined` is never stored in the cache.
+     */
+    set(k, v, setOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = setOptions;
+        setOptions.status = status;
+        if (status) {
+            status.op = 'set';
+            status.key = k;
+            if (v !== undefined)
+                status.value = v;
+            status.cache = this;
+        }
+        const result = this.#set(k, v, setOptions);
+        if (status && diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #set(k, v, setOptions, bf) {
+        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
+        if (v === undefined) {
+            if (status)
+                status.set = 'deleted';
+            this.delete(k);
+            return this;
+        }
+        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+        if (status && !isBF)
+            status.value = v;
+        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
+        // if the item doesn't fit, don't do anything
+        // NB: maxEntrySize set to maxSize by default
+        if (this.maxEntrySize && size > this.maxEntrySize) {
+            // have to delete, in case something is there already.
+            this.#delete(k, 'set');
+            if (status) {
+                status.set = 'miss';
+                status.maxEntrySizeExceeded = true;
+            }
+            return this;
+        }
+        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+        if (index === undefined) {
+            // addition
+            index = (this.#size === 0 ? this.#tail
+                : this.#free.length !== 0 ? this.#free.pop()
+                    : this.#size === this.#max ? this.#evict(false)
+                        : this.#size);
+            this.#keyList[index] = k;
+            this.#valList[index] = v;
+            this.#keyMap.set(k, index);
+            this.#next[this.#tail] = index;
+            this.#prev[index] = this.#tail;
+            this.#tail = index;
+            this.#size++;
+            this.#addItemSize(index, size, status);
+            if (status)
+                status.set = 'add';
+            noUpdateTTL = false;
+            if (this.#hasOnInsert && !isBF) {
+                this.#onInsert?.(v, k, 'add');
+            }
+        }
+        else {
+            // update
+            // might be updating a background fetch!
+            this.#moveToTail(index);
+            const oldVal = this.#valList[index];
+            if (v !== oldVal) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(oldVal, k, 'set');
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([oldVal, k, 'set']);
+                        }
+                    }
+                }
+                this.#removeItemSize(index);
+                this.#addItemSize(index, size, status);
+                this.#valList[index] = v;
+                if (!isBF) {
+                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
+                        oldVal.__staleWhileFetching
+                        : oldVal;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
+                }
+            }
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
+            }
+        }
+        if (ttl !== 0 && !this.#ttls) {
+            this.#initializeTTLTracking();
+        }
+        if (this.#ttls) {
+            if (!noUpdateTTL) {
+                this.#setItemTTL(index, ttl, start);
+            }
+            if (status)
+                this.#statusTTL(status, index);
+        }
+        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return this;
+    }
+    /**
+     * Evict the least recently used item, returning its value or
+     * `undefined` if cache is empty.
+     */
+    pop() {
+        try {
+            while (this.#size) {
+                const val = this.#valList[this.#head];
+                this.#evict(true);
+                if (this.#isBackgroundFetch(val)) {
+                    if (val.__staleWhileFetching) {
+                        return val.__staleWhileFetching;
+                    }
+                }
+                else if (val !== undefined) {
+                    return val;
+                }
+            }
+        }
+        finally {
+            if (this.#hasDisposeAfter && this.#disposed) {
+                const dt = this.#disposed;
+                let task;
+                while ((task = dt?.shift())) {
+                    this.#disposeAfter?.(...task);
+                }
+            }
+        }
+    }
+    #evict(free) {
+        const head = this.#head;
+        const k = this.#keyList[head];
+        const v = this.#valList[head];
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
+            v.__abortController.abort(new Error('evicted'));
+        }
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
+            if (this.#hasDispose) {
+                this.#dispose?.(oldValue, k, 'evict');
+            }
+            if (this.#hasDisposeAfter) {
+                this.#disposed?.push([oldValue, k, 'evict']);
+            }
+        }
+        this.#removeItemSize(head);
+        if (this.#autopurgeTimers?.[head]) {
+            clearTimeout(this.#autopurgeTimers[head]);
+            this.#autopurgeTimers[head] = undefined;
+        }
+        // if we aren't about to use the index, then null these out
+        if (free) {
+            this.#keyList[head] = undefined;
+            this.#valList[head] = undefined;
+            this.#free.push(head);
+        }
+        if (this.#size === 1) {
+            this.#head = this.#tail = 0;
+            this.#free.length = 0;
+        }
+        else {
+            this.#head = this.#next[head];
+        }
+        this.#keyMap.delete(k);
+        this.#size--;
+        return head;
+    }
+    /**
+     * Check if a key is in the cache, without updating the recency of use.
+     * Will return false if the item is stale, even though it is technically
+     * in the cache.
+     *
+     * Check if a key is in the cache, without updating the recency of
+     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+     * to `true` in either the options or the constructor.
+     *
+     * Will return `false` if the item is stale, even though it is technically in
+     * the cache. The difference can be determined (if it matters) by using a
+     * `status` argument, and inspecting the `has` field.
+     *
+     * Will not update item age unless
+     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+     */
+    has(k, hasOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = hasOptions;
+        hasOptions.status = status;
+        if (status) {
+            status.op = 'has';
+            status.key = k;
+            status.cache = this;
+        }
+        const result = this.#has(k, hasOptions);
+        if (diagnostics_channel_js_1.metrics.hasSubscribers)
+            diagnostics_channel_js_1.metrics.publish(status);
+        return result;
+    }
+    #has(k, hasOptions = {}) {
+        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v) &&
+                v.__staleWhileFetching === undefined) {
+                return false;
+            }
+            if (!this.#isStale(index)) {
+                if (updateAgeOnHas) {
+                    this.#updateItemAge(index);
+                }
+                if (status) {
+                    status.has = 'hit';
+                    this.#statusTTL(status, index);
+                }
+                return true;
+            }
+            else if (status) {
+                status.has = 'stale';
+                this.#statusTTL(status, index);
+            }
+        }
+        else if (status) {
+            status.has = 'miss';
+        }
+        return false;
+    }
+    /**
+     * Like {@link LRUCache#get} but doesn't update recency or delete stale
+     * items.
+     *
+     * Returns `undefined` if the item is stale, unless
+     * {@link LRUCache.OptionsBase.allowStale} is set.
+     */
+    peek(k, peekOptions = {}) {
+        const { status = hasSubscribers() ? {} : undefined } = peekOptions;
+        if (status) {
+            status.op = 'peek';
+            status.key = k;
+            status.cache = this;
+        }
+        peekOptions.status = status;
+        const result = this.#peek(k, peekOptions);
+        if (diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #peek(k, peekOptions) {
+        const { status, allowStale = this.allowStale } = peekOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined || (!allowStale && this.#isStale(index))) {
+            if (status)
+                status.peek = index === undefined ? 'miss' : 'stale';
+            return undefined;
+        }
+        const v = this.#valList[index];
+        const val = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (status) {
+            if (val !== undefined) {
+                status.peek = 'hit';
+                status.value = val;
+            }
+            else {
+                status.peek = 'miss';
+            }
+        }
+        return val;
+    }
+    #backgroundFetch(k, index, options, context) {
+        const v = index === undefined ? undefined : this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+            return v;
+        }
+        const ac = new AbortController();
+        const { signal } = options;
+        // when/if our AC signals, then stop listening to theirs.
+        signal?.addEventListener('abort', () => ac.abort(signal.reason), {
+            signal: ac.signal,
+        });
+        const fetchOpts = {
+            signal: ac.signal,
+            options,
+            context,
+        };
+        const cb = (v, updateCache = false) => {
+            const { aborted } = ac.signal;
+            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
+            const proceed = options.ignoreFetchAbort ||
+                !!(options.allowStaleOnFetchAbort && v !== undefined);
+            if (options.status) {
+                if (aborted && !updateCache) {
+                    options.status.fetchAborted = true;
+                    options.status.fetchError = ac.signal.reason;
+                    if (ignoreAbort)
+                        options.status.fetchAbortIgnored = true;
+                }
+                else {
+                    options.status.fetchResolved = true;
+                }
+            }
+            if (aborted && !ignoreAbort && !updateCache) {
+                return fetchFail(ac.signal.reason, proceed);
+            }
+            // either we didn't abort, and are still here, or we did, and ignored
+            const bf = p;
+            // if nothing else has been written there but we're set to update the
+            // cache and ignore the abort, or if it's still pending on this specific
+            // background request, then write it to the cache.
+            const vl = this.#valList[index];
+            if (vl === p || (vl === undefined && ignoreAbort && updateCache)) {
+                if (v === undefined) {
+                    if (bf.__staleWhileFetching !== undefined) {
+                        this.#valList[index] = bf.__staleWhileFetching;
+                    }
+                    else {
+                        this.#delete(k, 'fetch');
+                    }
+                }
+                else {
+                    if (options.status)
+                        options.status.fetchUpdated = true;
+                    this.#set(k, v, fetchOpts.options, bf);
+                }
+            }
+            return v;
+        };
+        const eb = (er) => {
+            if (options.status) {
+                options.status.fetchRejected = true;
+                options.status.fetchError = er;
+            }
+            // do not pass go, do not collect $200
+            return fetchFail(er, false);
+        };
+        const fetchFail = (er, proceed) => {
+            const { aborted } = ac.signal;
+            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+            const noDelete = allowStale || options.noDeleteOnFetchRejection;
+            const bf = p;
+            if (this.#valList[index] === p) {
+                // if we allow stale on fetch rejections, then we need to ensure that
+                // the stale value is not removed from the cache when the fetch fails.
+                const del = !noDelete || (!proceed && bf.__staleWhileFetching === undefined);
+                if (del) {
+                    this.#delete(k, 'fetch');
+                }
+                else if (!allowStaleAborted) {
+                    // still replace the *promise* with the stale value,
+                    // since we are done with the promise at this point.
+                    // leave it untouched if we're still waiting for an
+                    // aborted background fetch that hasn't yet returned.
+                    this.#valList[index] = bf.__staleWhileFetching;
+                }
+            }
+            if (allowStale) {
+                if (options.status && bf.__staleWhileFetching !== undefined) {
+                    options.status.returnedStale = true;
+                }
+                return bf.__staleWhileFetching;
+            }
+            else if (bf.__returned === bf) {
+                throw er;
+            }
+        };
+        const pcall = (res, rej) => {
+            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+            // ignored, we go until we finish, regardless.
+            // defer check until we are actually aborting,
+            // so fetchMethod can override.
+            ac.signal.addEventListener('abort', () => {
+                if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+                    res(undefined);
+                    // when it eventually resolves, update the cache.
+                    if (options.allowStaleOnFetchAbort) {
+                        res = v => cb(v, true);
+                    }
+                }
+            });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
+        };
+        if (options.status)
+            options.status.fetchDispatched = true;
+        const p = new Promise(pcall).then(cb, eb);
+        const bf = Object.assign(p, {
+            __abortController: ac,
+            __staleWhileFetching: v,
+            __returned: undefined,
+        });
+        if (index === undefined) {
+            // internal, don't expose status.
+            this.#set(k, bf, { ...fetchOpts.options, status: undefined });
+            index = this.#keyMap.get(k);
+        }
+        else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
+            this.#valList[index] = bf;
+        }
+        return bf;
+    }
+    #isBackgroundFetch(p) {
+        if (!this.#hasFetchMethod)
+            return false;
+        const b = p;
+        return (!!b &&
+            b instanceof Promise &&
+            b.hasOwnProperty('__staleWhileFetching') &&
+            b.__abortController instanceof AbortController);
+    }
+    fetch(k, fetchOptions = {}) {
+        const ths = diagnostics_channel_js_1.tracing.hasSubscribers;
+        const { status = hasSubscribers() ? {} : undefined } = fetchOptions;
+        fetchOptions.status = status;
+        if (status && fetchOptions.context) {
+            status.context = fetchOptions.context;
+        }
+        const p = this.#fetch(k, fetchOptions);
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
+        }
+        return p;
+    }
+    async #fetch(k, fetchOptions = {}) {
+        const {
+        // get options
+        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        // set options
+        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL,
+        // fetch exclusive options
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal, } = fetchOptions;
+        if (status) {
+            status.op = 'fetch';
+            status.key = k;
+            if (forceRefresh)
+                status.forceRefresh = true;
+            status.cache = this;
+        }
+        if (!this.#hasFetchMethod) {
+            if (status)
+                status.fetch = 'get';
+            return this.#get(k, {
+                allowStale,
+                updateAgeOnGet,
+                noDeleteOnStaleGet,
+                status,
+            });
+        }
+        const options = {
+            allowStale,
+            updateAgeOnGet,
+            noDeleteOnStaleGet,
+            ttl,
+            noDisposeOnSet,
+            size,
+            sizeCalculation,
+            noUpdateTTL,
+            noDeleteOnFetchRejection,
+            allowStaleOnFetchRejection,
+            allowStaleOnFetchAbort,
+            ignoreFetchAbort,
+            status,
+            signal,
+        };
+        let index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.fetch = 'miss';
+            const p = this.#backgroundFetch(k, index, options, context);
+            return (p.__returned = p);
+        }
+        else {
+            // in cache, maybe already fetching
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                const stale = allowStale && v.__staleWhileFetching !== undefined;
+                if (status) {
+                    status.fetch = 'inflight';
+                    if (stale)
+                        status.returnedStale = true;
+                }
+                return stale ? v.__staleWhileFetching : (v.__returned = v);
+            }
+            // if we force a refresh, that means do NOT serve the cached value,
+            // unless we are already in the process of refreshing the cache.
+            const isStale = this.#isStale(index);
+            if (!forceRefresh && !isStale) {
+                if (status)
+                    status.fetch = 'hit';
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                if (status)
+                    this.#statusTTL(status, index);
+                return v;
+            }
+            // ok, it is stale or a forced refresh, and not already fetching.
+            // refresh the cache.
+            const p = this.#backgroundFetch(k, index, options, context);
+            const hasStale = p.__staleWhileFetching !== undefined;
+            const staleVal = hasStale && allowStale;
+            if (status) {
+                status.fetch = isStale ? 'stale' : 'refresh';
+                if (staleVal && isStale)
+                    status.returnedStale = true;
+            }
+            return staleVal ? p.__staleWhileFetching : (p.__returned = p);
+        }
+    }
+    forceFetch(k, fetchOptions = {}) {
+        const ths = diagnostics_channel_js_1.tracing.hasSubscribers;
+        const { status = hasSubscribers() ? {} : undefined } = fetchOptions;
+        fetchOptions.status = status;
+        if (status && fetchOptions.context) {
+            status.context = fetchOptions.context;
+        }
+        const p = this.#forceFetch(k, fetchOptions);
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
+        }
+        return p;
+    }
+    async #forceFetch(k, fetchOptions = {}) {
+        const v = await this.#fetch(k, fetchOptions);
+        if (v === undefined)
+            throw new Error('fetch() returned undefined');
+        return v;
+    }
+    memo(k, memoOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = memoOptions;
+        memoOptions.status = status;
+        if (status) {
+            status.op = 'memo';
+            status.key = k;
+            if (memoOptions.context) {
+                status.context = memoOptions.context;
+            }
+            status.cache = this;
+        }
+        const result = this.#memo(k, memoOptions);
+        if (status)
+            status.value = result;
+        if (diagnostics_channel_js_1.metrics.hasSubscribers)
+            diagnostics_channel_js_1.metrics.publish(status);
+        return result;
+    }
+    #memo(k, memoOptions = {}) {
+        const memoMethod = this.#memoMethod;
+        if (!memoMethod) {
+            throw new Error('no memoMethod provided to constructor');
+        }
+        const { context, status, forceRefresh, ...options } = memoOptions;
+        if (status && forceRefresh)
+            status.forceRefresh = true;
+        const v = this.#get(k, options);
+        const refresh = forceRefresh || v === undefined;
+        if (status) {
+            status.memo = refresh ? 'miss' : 'hit';
+            if (!refresh)
+                status.value = v;
+        }
+        if (!refresh)
+            return v;
+        const vv = memoMethod(k, v, {
+            options,
+            context,
+        });
+        if (status)
+            status.value = vv;
+        this.#set(k, vv, options);
+        return vv;
+    }
+    /**
+     * Return a value from the cache. Will update the recency of the cache
+     * entry found.
+     *
+     * If the key is not found, get() will return `undefined`.
+     */
+    get(k, getOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = getOptions;
+        getOptions.status = status;
+        if (status) {
+            status.op = 'get';
+            status.key = k;
+            status.cache = this;
+        }
+        const result = this.#get(k, getOptions);
+        if (status) {
+            if (result !== undefined)
+                status.value = result;
+            if (diagnostics_channel_js_1.metrics.hasSubscribers)
+                diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #get(k, getOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status, } = getOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.get = 'miss';
+            return undefined;
+        }
+        const value = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value);
+        if (status)
+            this.#statusTTL(status, index);
+        if (this.#isStale(index)) {
+            // delete only if not an in-flight background fetch
+            if (!fetching) {
+                if (!noDeleteOnStaleGet) {
+                    this.#delete(k, 'expire');
+                }
+                if (status)
+                    status.get = 'stale';
+                if (allowStale) {
+                    if (status)
+                        status.returnedStale = true;
+                    return value;
+                }
+                return undefined;
+            }
+            if (status)
+                status.get = 'stale-fetching';
+            if (allowStale && value.__staleWhileFetching !== undefined) {
+                if (status)
+                    status.returnedStale = true;
+                return value.__staleWhileFetching;
+            }
+            return undefined;
+        }
+        // not stale
+        if (status)
+            status.get = fetching ? 'fetching' : 'hit';
+        // if we're currently fetching it, we don't actually have it yet
+        // it's not stale, which means this isn't a staleWhileRefetching.
+        // If it's not stale, and fetching, AND has a __staleWhileFetching
+        // value, then that means the user fetched with {forceRefresh:true},
+        // so it's safe to return that value.
+        this.#moveToTail(index);
+        if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+        }
+        return fetching ? value.__staleWhileFetching : value;
+    }
+    #connect(p, n) {
+        this.#prev[n] = p;
+        this.#next[p] = n;
+    }
+    #moveToTail(index) {
+        // if tail already, nothing to do
+        // if head, move head to next[index]
+        // else
+        //   move next[prev[index]] to next[index] (head has no prev)
+        //   move prev[next[index]] to prev[index]
+        // prev[index] = tail
+        // next[tail] = index
+        // tail = index
+        if (index !== this.#tail) {
+            if (index === this.#head) {
+                this.#head = this.#next[index];
+            }
+            else {
+                this.#connect(this.#prev[index], this.#next[index]);
+            }
+            this.#connect(this.#tail, index);
+            this.#tail = index;
+        }
+    }
+    /**
+     * Deletes a key out of the cache.
+     *
+     * Returns true if the key was deleted, false otherwise.
+     */
+    delete(k) {
+        return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
+        if (diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish({
+                op: 'delete',
+                delete: reason,
+                key: k,
+                cache: this,
+            });
+        }
+        let deleted = false;
+        if (this.#size !== 0) {
+            const index = this.#keyMap.get(k);
+            if (index !== undefined) {
+                if (this.#autopurgeTimers?.[index]) {
+                    clearTimeout(this.#autopurgeTimers?.[index]);
+                    this.#autopurgeTimers[index] = undefined;
+                }
+                deleted = true;
+                if (this.#size === 1) {
+                    this.#clear(reason);
+                }
+                else {
+                    this.#removeItemSize(index);
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) {
+                        v.__abortController.abort(new Error('deleted'));
+                    }
+                    else if (this.#hasDispose || this.#hasDisposeAfter) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(v, k, reason);
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([v, k, reason]);
+                        }
+                    }
+                    this.#keyMap.delete(k);
+                    this.#keyList[index] = undefined;
+                    this.#valList[index] = undefined;
+                    if (index === this.#tail) {
+                        this.#tail = this.#prev[index];
+                    }
+                    else if (index === this.#head) {
+                        this.#head = this.#next[index];
+                    }
+                    else {
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
+                    }
+                    this.#size--;
+                    this.#free.push(index);
+                }
+            }
+        }
+        if (this.#hasDisposeAfter && this.#disposed?.length) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Clear the cache entirely, throwing away all values.
+     */
+    clear() {
+        return this.#clear('delete');
+    }
+    #clear(reason) {
+        for (const index of this.#rindexes({ allowStale: true })) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                v.__abortController.abort(new Error('deleted'));
+            }
+            else {
+                const k = this.#keyList[index];
+                if (this.#hasDispose) {
+                    this.#dispose?.(v, k, reason);
+                }
+                if (this.#hasDisposeAfter) {
+                    this.#disposed?.push([v, k, reason]);
+                }
+            }
+        }
+        this.#keyMap.clear();
+        void this.#valList.fill(undefined);
+        this.#keyList.fill(undefined);
+        if (this.#ttls && this.#starts) {
+            this.#ttls.fill(0);
+            this.#starts.fill(0);
+            for (const t of this.#autopurgeTimers ?? []) {
+                if (t !== undefined)
+                    clearTimeout(t);
+            }
+            this.#autopurgeTimers?.fill(undefined);
+        }
+        if (this.#sizes) {
+            this.#sizes.fill(0);
+        }
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free.length = 0;
+        this.#calculatedSize = 0;
+        this.#size = 0;
+        if (this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+    }
+}
+exports.LRUCache = LRUCache;
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.min.js b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.min.js
new file mode 100644
index 00000000000000..8e42461074475a
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/index.min.js
@@ -0,0 +1,2 @@
+"use strict";var j=(c,t)=>()=>(t||c((t={exports:{}}).exports,t),t.exports);var I=j(O=>{"use strict";Object.defineProperty(O,"__esModule",{value:!0});O.tracing=O.metrics=void 0;var U={hasSubscribers:!1};O.metrics=U;O.tracing=U});var P=j(D=>{"use strict";Object.defineProperty(D,"__esModule",{value:!0});D.defaultPerf=void 0;D.defaultPerf=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date});Object.defineProperty(exports,"__esModule",{value:!0});exports.LRUCache=void 0;var g=I(),N=P(),x=()=>g.metrics.hasSubscribers||g.tracing.hasSubscribers,k=new Set,G=typeof process=="object"&&process?process:{},V=(c,t,e,i)=>{typeof G.emitWarning=="function"?G.emitWarning(c,t,e,i):console.error(`[${e}] ${t}: ${c}`)},B=c=>!k.has(c);var T=c=>!!c&&c===Math.floor(c)&&c>0&&isFinite(c),H=c=>T(c)?c<=Math.pow(2,8)?Uint8Array:c<=Math.pow(2,16)?Uint16Array:c<=Math.pow(2,32)?Uint32Array:c<=Number.MAX_SAFE_INTEGER?W:null:null,W=class extends Array{constructor(t){super(t),this.fill(0)}},C=class c{heap;length;static#o=!1;static create(t){let e=H(t);if(!e)return[];c.#o=!0;let i=new c(t,e);return c.#o=!1,i}constructor(t,e){if(!c.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new e(t),this.length=0}push(t){this.heap[this.length++]=t}pop(){return this.heap[--this.length]}},L=class c{#o;#c;#m;#W;#S;#M;#j;#w;get perf(){return this.#w}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#U;#f;#D;static unsafeExposeInternals(t){return{starts:t.#F,ttls:t.#d,autopurgeTimers:t.#g,sizes:t.#_,keyMap:t.#s,keyList:t.#i,valList:t.#t,next:t.#l,prev:t.#u,get head(){return t.#a},get tail(){return t.#h},free:t.#y,isBackgroundFetch:e=>t.#e(e),backgroundFetch:(e,i,s,n)=>t.#G(e,i,s,n),moveToTail:e=>t.#L(e),indexes:e=>t.#A(e),rindexes:e=>t.#z(e),isStale:e=>t.#p(e)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#j}get dispose(){return this.#m}get onInsert(){return this.#W}get disposeAfter(){return this.#S}constructor(t){let{max:e=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:y,noDisposeOnSet:_,noUpdateTTL:u,maxSize:p=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:S,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:w,allowStaleOnFetchRejection:m,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,backgroundFetchSize:M=1,perf:v}=t;if(this.backgroundFetchSize=M,v!==void 0&&typeof v?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#w=v??N.defaultPerf,e!==0&&!T(e))throw new TypeError("max option must be a nonnegative integer");let E=e?H(e):Array;if(!E)throw new Error("invalid max value: "+e);if(this.#o=e,this.#c=p,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(S!==void 0&&typeof S!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#j=S,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:e}).fill(void 0),this.#t=Array.from({length:e}).fill(void 0),this.#l=new E(e),this.#u=new E(e),this.#a=0,this.#h=0,this.#y=C.create(e),this.#n=0,this.#b=0,typeof o=="function"&&(this.#m=o),typeof d=="function"&&(this.#W=d),typeof y=="function"?(this.#S=y,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#m,this.#D=!!this.#W,this.#f=!!this.#S,this.noDisposeOnSet=!!_,this.noUpdateTTL=!!u,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!m,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!w,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let R="LRU_CACHE_UNBOUNDED";B(R)&&(k.add(R),V("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",R,c))}}getRemainingTTL(t){return this.#s.has(t)?1/0:0}#k(){let t=new W(this.#o),e=new W(this.#o);this.#d=t,this.#F=e;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#w.now())=>{e[h]=a!==0?o:0,t[h]=a,s(h,a)},this.#R=h=>{e[h]=t[h]!==0?this.#w.now():0,s(h,t[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#v(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#E=(h,a)=>{if(t[a]){let o=t[a],d=e[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let y=h.now-d;h.remainingTTL=o-y}};let n=0,r=()=>{let h=this.#w.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=t[a],d=e[a];if(!o||!d)return 1/0;let y=(n||r())-d;return o-y},this.#p=h=>{let a=e[h],o=t[h];return!!o&&!!a&&(n||r())-a>o}}#R=()=>{};#E=()=>{};#H=()=>{};#p=()=>!1;#X(){let t=new W(this.#o);this.#b=0,this.#_=t,this.#x=e=>{this.#b-=t[e],t[e]=0},this.#N=(e,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,e),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#I=(e,i,s)=>{if(t[e]=i,this.#c){let n=this.#c-t[e];for(;this.#b>n;)this.#P(!0)}this.#b+=t[e],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#x=t=>{};#I=(t,e,i)=>{};#N=(t,e,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#h;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#a);)e=this.#u[e]}*#z({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#a;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#h);)e=this.#l[e]}#V(t){return t!==void 0&&this.#s.get(this.#i[t])===t}*entries(){for(let t of this.#A())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*rentries(){for(let t of this.#z())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*keys(){for(let t of this.#A()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*rkeys(){for(let t of this.#z()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*values(){for(let t of this.#A())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}*rvalues(){for(let t of this.#z())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(t,e={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&t(n,this.#i[i],this))return this.#C(this.#i[i],e)}}forEach(t,e=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}rforEach(t,e=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}purgeStale(){let t=!1;for(let e of this.#z({allowStale:!0}))this.#p(e)&&(this.#v(this.#i[e],"expire"),t=!0);return t}info(t){let e=this.#s.get(t);if(e===void 0)return;let i=this.#t[e],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[e],h=this.#F[e];if(r&&h){let a=r-(this.#w.now()-h);n.ttl=a,n.start=Date.now()}}return this.#_&&(n.size=this.#_[e]),n}dump(){let t=[];for(let e of this.#A({allowStale:!0})){let i=this.#i[e],s=this.#t[e],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[e];let h=this.#w.now()-this.#F[e];r.start=Math.floor(Date.now()-h)}this.#_&&(r.size=this.#_[e]),t.unshift([i,r])}return t}load(t){this.clear();for(let[e,i]of t){if(i.start){let s=Date.now()-i.start;i.start=this.#w.now()-s}this.#O(e,i.value,i)}}set(t,e,i={}){let{status:s=g.metrics.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=t,e!==void 0&&(s.value=e),s.cache=this);let n=this.#O(t,e,i);return s&&g.metrics.hasSubscribers&&g.metrics.publish(s),n}#O(t,e,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(e);if(e===void 0)return o&&(o.set="deleted"),this.delete(t),this;let{noUpdateTTL:y=this.noUpdateTTL}=i;o&&!d&&(o.value=e);let _=this.#N(t,e,i.size||0,a,o);if(this.maxEntrySize&&_>this.maxEntrySize)return this.#v(t,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let u=this.#n===0?void 0:this.#s.get(t);if(u===void 0)u=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#P(!1):this.#n,this.#i[u]=t,this.#t[u]=e,this.#s.set(t,u),this.#l[this.#h]=u,this.#u[u]=this.#h,this.#h=u,this.#n++,this.#I(u,_,o),o&&(o.set="add"),y=!1,this.#D&&!d&&this.#W?.(e,t,"add");else{this.#L(u);let p=this.#t[u];if(e!==p){if(!h)if(this.#e(p)){p!==s&&p.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=p;f!==void 0&&f!==e&&(this.#T&&this.#m?.(f,t,"set"),this.#f&&this.#r?.push([f,t,"set"]))}else this.#T&&this.#m?.(p,t,"set"),this.#f&&this.#r?.push([p,t,"set"]);if(this.#x(u),this.#I(u,_,o),this.#t[u]=e,!d){let f=p&&this.#e(p)?p.__staleWhileFetching:p,b=f===void 0?"add":e!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#D&&this.onInsert?.(e,t,b)}}else d||(o&&(o.set="update"),this.#D&&this.onInsert?.(e,t,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(y||this.#H(u,n,r),o&&this.#E(o,u)),!h&&this.#f&&this.#r){let p=this.#r,f;for(;f=p?.shift();)this.#S?.(...f)}return this}pop(){try{for(;this.#n;){let t=this.#t[this.#a];if(this.#P(!0),this.#e(t)){if(t.__staleWhileFetching)return t.__staleWhileFetching}else if(t!==void 0)return t}}finally{if(this.#f&&this.#r){let t=this.#r,e;for(;e=t?.shift();)this.#S?.(...e)}}}#P(t){let e=this.#a,i=this.#i[e],s=this.#t[e],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#m?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#x(e),this.#g?.[e]&&(clearTimeout(this.#g[e]),this.#g[e]=void 0),t&&(this.#i[e]=void 0,this.#t[e]=void 0,this.#y.push(e)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[e],this.#s.delete(i),this.#n--,e}has(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="has",i.key=t,i.cache=this);let s=this.#Y(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Y(t,e={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=e,n=this.#s.get(t);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#R(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(t,e={}){let{status:i=x()?{}:void 0}=e;i&&(i.op="peek",i.key=t,i.cache=this),e.status=i;let s=this.#J(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#J(t,e){let{status:i,allowStale:s=this.allowStale}=e,n=this.#s.get(t);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#G(t,e,i,s){let n=e===void 0?void 0:this.#t[e];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,S=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,S&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!S&&!b)return y(r.signal.reason,F);let w=u,m=this.#t[e];return(m===u||m===void 0&&S&&b)&&(f===void 0?w.__staleWhileFetching!==void 0?this.#t[e]=w.__staleWhileFetching:this.#v(t,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(t,f,a.options,w))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),y(f,!1)),y=(f,b)=>{let{aborted:l}=r.signal,S=l&&i.allowStaleOnFetchAbort,F=S||i.allowStaleOnFetchRejection,w=F||i.noDeleteOnFetchRejection,m=u;if(this.#t[e]===u&&(!w||!b&&m.__staleWhileFetching===void 0?this.#v(t,"fetch"):S||(this.#t[e]=m.__staleWhileFetching)),F)return i.status&&m.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),m.__staleWhileFetching;if(m.__returned===m)throw f},_=(f,b)=>{let l=this.#M?.(t,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=S=>o(S,!0)))}),l&&l instanceof Promise?l.then(S=>f(S===void 0?void 0:S),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let u=new Promise(_).then(o,d),p=Object.assign(u,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return e===void 0?(this.#O(t,p,{...a.options,status:void 0}),e=this.#s.get(t)):this.#t[e]=p,p}#e(t){if(!this.#U)return!1;let e=t;return!!e&&e instanceof Promise&&e.hasOwnProperty("__staleWhileFetching")&&e.__abortController instanceof AbortController}fetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=x()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#B(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#B(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:y=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:_=this.allowStaleOnFetchRejection,ignoreFetchAbort:u=this.ignoreFetchAbort,allowStaleOnFetchAbort:p=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:S}=e;if(l&&(l.op="fetch",l.key=t,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#C(t,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:y,allowStaleOnFetchRejection:_,allowStaleOnFetchAbort:p,ignoreFetchAbort:u,status:l,signal:S},w=this.#s.get(t);if(w===void 0){l&&(l.fetch="miss");let m=this.#G(t,w,F,f);return m.__returned=m}else{let m=this.#t[w];if(this.#e(m)){let E=i&&m.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",E&&(l.returnedStale=!0)),E?m.__staleWhileFetching:m.__returned=m}let A=this.#p(w);if(!b&&!A)return l&&(l.fetch="hit"),this.#L(w),s&&this.#R(w),l&&this.#E(l,w),m;let z=this.#G(t,w,F,f),v=z.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",v&&A&&(l.returnedStale=!0)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=x()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#K(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#K(t,e={}){let i=await this.#B(t,e);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="memo",i.key=t,e.context&&(i.context=e.context),i.cache=this);let s=this.#Q(t,e);return i&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Q(t,e={}){let i=this.#j;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=e;n&&r&&(n.forceRefresh=!0);let a=this.#C(t,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(t,a,{options:h,context:s});return n&&(n.value=d),this.#O(t,d,h),d}get(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="get",i.key=t,i.cache=this);let s=this.#C(t,e);return i&&(s!==void 0&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i)),s}#C(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=e,h=this.#s.get(t);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#E(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#v(t,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#R(h),o?a.__staleWhileFetching:a)}#q(t,e){this.#u[e]=t,this.#l[t]=e}#L(t){t!==this.#h&&(t===this.#a?this.#a=this.#l[t]:this.#q(this.#u[t],this.#l[t]),this.#q(this.#h,t),this.#h=t)}delete(t){return this.#v(t,"delete")}#v(t,e){g.metrics.hasSubscribers&&g.metrics.publish({op:"delete",delete:e,key:t,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(t);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#$(e);else{this.#x(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#m?.(n,t,e),this.#f&&this.#r?.push([n,t,e])),this.#s.delete(t),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#$("delete")}#$(t){for(let e of this.#z({allowStale:!0})){let i=this.#t[e];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[e];this.#T&&this.#m?.(i,s,t),this.#f&&this.#r?.push([i,s,t])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let e of this.#g??[])e!==void 0&&clearTimeout(e);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let e=this.#r,i;for(;i=e?.shift();)this.#S?.(...i)}}};exports.LRUCache=L;
+//# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/browser/perf.js b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/perf.js
new file mode 100644
index 00000000000000..bd4c80f461d6c1
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/browser/perf.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPerf = void 0;
+exports.defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/diagnostics-channel.js b/deps/npm/node_modules/lru-cache/dist/commonjs/diagnostics-channel.js
index 3a3c4e1be38b28..bdd4f41f903666 100644
--- a/deps/npm/node_modules/lru-cache/dist/commonjs/diagnostics-channel.js
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/diagnostics-channel.js
@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tracing = exports.metrics = void 0;
-// simple node version that imports from node builtin
-// this gets compiled to a require() commonjs-style override,
-// not using top level await on a conditional dynamic import
-const node_diagnostics_channel_1 = require("node:diagnostics_channel");
-exports.metrics = (0, node_diagnostics_channel_1.channel)('lru-cache:metrics');
-exports.tracing = (0, node_diagnostics_channel_1.tracingChannel)('lru-cache');
-//# sourceMappingURL=diagnostics-channel.js.map
\ No newline at end of file
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-cjs.cjs.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/index.js b/deps/npm/node_modules/lru-cache/dist/commonjs/index.js
index bb8256253be5f8..6b8268b0ea9123 100644
--- a/deps/npm/node_modules/lru-cache/dist/commonjs/index.js
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/index.js
@@ -5,12 +5,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LRUCache = void 0;
 const diagnostics_channel_js_1 = require("./diagnostics-channel.js");
+const perf_js_1 = require("./perf.js");
 const hasSubscribers = () => diagnostics_channel_js_1.metrics.hasSubscribers || diagnostics_channel_js_1.tracing.hasSubscribers;
-const defaultPerf = (typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function') ?
-    performance
-    : Date;
 const warned = new Set();
 /* c8 ignore start */
 const PROCESS = (typeof process === 'object' && !!process ?
@@ -52,7 +48,9 @@ class ZeroArray extends Array {
     }
 }
 class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
     heap;
+    /* c8 ignore stop */
     length;
     // private constructor
     static #constructing = false;
@@ -172,6 +170,8 @@ class LRUCache {
      * {@link LRUCache.OptionsBase.ignoreFetchAbort}
      */
     ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
     // computed properties
     #size;
     #calculatedSize;
@@ -282,13 +282,14 @@ class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
         if (perf !== undefined) {
             if (typeof perf?.now !== 'function') {
                 throw new TypeError('perf option must have a now() method if specified');
             }
         }
-        this.#perf = perf ?? defaultPerf;
+        this.#perf = perf ?? perf_js_1.defaultPerf;
         if (max !== 0 && !isPosInt(max)) {
             throw new TypeError('max option must be a nonnegative integer');
         }
@@ -510,12 +511,15 @@ class LRUCache {
             sizes[index] = 0;
         };
         this.#requireSize = (k, v, size, sizeCalculation) => {
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
             if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
                 if (sizeCalculation) {
                     if (typeof sizeCalculation !== 'function') {
                         throw new TypeError('sizeCalculation must be a function');
@@ -882,6 +886,7 @@ class LRUCache {
             status.key = k;
             if (v !== undefined)
                 status.value = v;
+            status.cache = this;
         }
         const result = this.#set(k, v, setOptions);
         if (status && diagnostics_channel_js_1.metrics.hasSubscribers) {
@@ -889,8 +894,9 @@ class LRUCache {
         }
         return result;
     }
-    #set(k, v, setOptions = {}) {
+    #set(k, v, setOptions, bf) {
         const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
         if (v === undefined) {
             if (status)
                 status.set = 'deleted';
@@ -898,7 +904,7 @@ class LRUCache {
             return this;
         }
         let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        if (status && !this.#isBackgroundFetch(v))
+        if (status && !isBF)
             status.value = v;
         const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
         // if the item doesn't fit, don't do anything
@@ -930,52 +936,68 @@ class LRUCache {
             if (status)
                 status.set = 'add';
             noUpdateTTL = false;
-            if (this.#hasOnInsert) {
+            if (this.#hasOnInsert && !isBF) {
                 this.#onInsert?.(v, k, 'add');
             }
         }
         else {
             // update
+            // might be updating a background fetch!
             this.#moveToTail(index);
             const oldVal = this.#valList[index];
             if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                    const { __staleWhileFetching: s } = oldVal;
-                    if (s !== undefined && !noDisposeOnSet) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
                         if (this.#hasDispose) {
-                            this.#dispose?.(s, k, 'set');
+                            this.#dispose?.(oldVal, k, 'set');
                         }
                         if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([s, k, 'set']);
+                            this.#disposed?.push([oldVal, k, 'set']);
                         }
                     }
                 }
-                else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([oldVal, k, 'set']);
-                    }
-                }
                 this.#removeItemSize(index);
                 this.#addItemSize(index, size, status);
                 this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
+                if (!isBF) {
                     const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
                         oldVal.__staleWhileFetching
                         : oldVal;
-                    if (oldValue !== undefined)
-                        status.oldValue = oldValue;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
                 }
             }
-            else if (status) {
-                status.set = 'update';
-            }
-            if (this.#hasOnInsert) {
-                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
             }
         }
         if (ttl !== 0 && !this.#ttls) {
@@ -1030,15 +1052,18 @@ class LRUCache {
         const head = this.#head;
         const k = this.#keyList[head];
         const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
             v.__abortController.abort(new Error('evicted'));
         }
-        else if (this.#hasDispose || this.#hasDisposeAfter) {
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
             if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
+                this.#dispose?.(oldValue, k, 'evict');
             }
             if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, 'evict']);
+                this.#disposed?.push([oldValue, k, 'evict']);
             }
         }
         this.#removeItemSize(head);
@@ -1085,6 +1110,7 @@ class LRUCache {
         if (status) {
             status.op = 'has';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#has(k, hasOptions);
         if (diagnostics_channel_js_1.metrics.hasSubscribers)
@@ -1132,6 +1158,7 @@ class LRUCache {
         if (status) {
             status.op = 'peek';
             status.key = k;
+            status.cache = this;
         }
         peekOptions.status = status;
         const result = this.#peek(k, peekOptions);
@@ -1214,7 +1241,7 @@ class LRUCache {
                 else {
                     if (options.status)
                         options.status.fetchUpdated = true;
-                    this.#set(k, v, fetchOpts.options);
+                    this.#set(k, v, fetchOpts.options, bf);
                 }
             }
             return v;
@@ -1260,9 +1287,6 @@ class LRUCache {
         };
         const pcall = (res, rej) => {
             const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then(v => res(v === undefined ? undefined : v), rej);
-            }
             // ignored, we go until we finish, regardless.
             // defer check until we are actually aborting,
             // so fetchMethod can override.
@@ -1275,6 +1299,12 @@ class LRUCache {
                     }
                 }
             });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
         };
         if (options.status)
             options.status.fetchDispatched = true;
@@ -1290,6 +1320,10 @@ class LRUCache {
             index = this.#keyMap.get(k);
         }
         else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
             this.#valList[index] = bf;
         }
         return bf;
@@ -1311,11 +1345,9 @@ class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#fetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1332,6 +1364,7 @@ class LRUCache {
             status.key = k;
             if (forceRefresh)
                 status.forceRefresh = true;
+            status.cache = this;
         }
         if (!this.#hasFetchMethod) {
             if (status)
@@ -1413,11 +1446,9 @@ class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#forceFetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1436,6 +1467,7 @@ class LRUCache {
             if (memoOptions.context) {
                 status.context = memoOptions.context;
             }
+            status.cache = this;
         }
         const result = this.#memo(k, memoOptions);
         if (status)
@@ -1482,6 +1514,7 @@ class LRUCache {
         if (status) {
             status.op = 'get';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#get(k, getOptions);
         if (status) {
@@ -1580,6 +1613,7 @@ class LRUCache {
                 op: 'delete',
                 delete: reason,
                 key: k,
+                cache: this,
             });
         }
         let deleted = false;
@@ -1660,7 +1694,7 @@ class LRUCache {
             }
         }
         this.#keyMap.clear();
-        this.#valList.fill(undefined);
+        void this.#valList.fill(undefined);
         this.#keyList.fill(undefined);
         if (this.#ttls && this.#starts) {
             this.#ttls.fill(0);
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/index.min.js b/deps/npm/node_modules/lru-cache/dist/commonjs/index.min.js
index 383a09d043d362..8e42461074475a 100644
--- a/deps/npm/node_modules/lru-cache/dist/commonjs/index.min.js
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/index.min.js
@@ -1,2 +1,2 @@
-"use strict";var G=(c,t)=>()=>(t||c((t={exports:{}}).exports,t),t.exports);var M=G(O=>{"use strict";Object.defineProperty(O,"__esModule",{value:!0});O.tracing=O.metrics=void 0;var L=require("node:diagnostics_channel");O.metrics=(0,L.channel)("lru-cache:metrics");O.tracing=(0,L.tracingChannel)("lru-cache")});Object.defineProperty(exports,"__esModule",{value:!0});exports.LRUCache=void 0;var u=M(),D=()=>u.metrics.hasSubscribers||u.tracing.hasSubscribers,P=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date,U=new Set,j=typeof process=="object"&&process?process:{},H=(c,t,e,i)=>{typeof j.emitWarning=="function"?j.emitWarning(c,t,e,i):console.error(`[${e}] ${t}: ${c}`)},N=c=>!U.has(c),B=Symbol("type"),F=c=>!!c&&c===Math.floor(c)&&c>0&&isFinite(c),I=c=>F(c)?c<=Math.pow(2,8)?Uint8Array:c<=Math.pow(2,16)?Uint16Array:c<=Math.pow(2,32)?Uint32Array:c<=Number.MAX_SAFE_INTEGER?W:null:null,W=class extends Array{constructor(t){super(t),this.fill(0)}},C=class c{heap;length;static#o=!1;static create(t){let e=I(t);if(!e)return[];c.#o=!0;let i=new c(t,e);return c.#o=!1,i}constructor(t,e){if(!c.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new e(t),this.length=0}push(t){this.heap[this.length++]=t}pop(){return this.heap[--this.length]}},x=class c{#o;#c;#m;#D;#w;#M;#j;#S;get perf(){return this.#S}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#O;#f;#U;static unsafeExposeInternals(t){return{starts:t.#F,ttls:t.#d,autopurgeTimers:t.#g,sizes:t.#_,keyMap:t.#s,keyList:t.#i,valList:t.#t,next:t.#l,prev:t.#u,get head(){return t.#a},get tail(){return t.#h},free:t.#y,isBackgroundFetch:e=>t.#e(e),backgroundFetch:(e,i,s,n)=>t.#P(e,i,s,n),moveToTail:e=>t.#L(e),indexes:e=>t.#A(e),rindexes:e=>t.#v(e),isStale:e=>t.#p(e)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#j}get dispose(){return this.#m}get onInsert(){return this.#D}get disposeAfter(){return this.#w}constructor(t){let{max:e=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:o,updateAgeOnHas:r,allowStale:h,dispose:a,onInsert:d,disposeAfter:f,noDisposeOnSet:p,noUpdateTTL:m,maxSize:T=0,maxEntrySize:w=0,sizeCalculation:y,fetchMethod:l,memoMethod:S,noDeleteOnFetchRejection:_,noDeleteOnStaleGet:b,allowStaleOnFetchRejection:g,allowStaleOnFetchAbort:A,ignoreFetchAbort:v,perf:R}=t;if(R!==void 0&&typeof R?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#S=R??P,e!==0&&!F(e))throw new TypeError("max option must be a nonnegative integer");let z=e?I(e):Array;if(!z)throw new Error("invalid max value: "+e);if(this.#o=e,this.#c=T,this.maxEntrySize=w||this.#c,this.sizeCalculation=y,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(S!==void 0&&typeof S!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#j=S,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#O=!!l,this.#s=new Map,this.#i=Array.from({length:e}).fill(void 0),this.#t=Array.from({length:e}).fill(void 0),this.#l=new z(e),this.#u=new z(e),this.#a=0,this.#h=0,this.#y=C.create(e),this.#n=0,this.#b=0,typeof a=="function"&&(this.#m=a),typeof d=="function"&&(this.#D=d),typeof f=="function"?(this.#w=f,this.#r=[]):(this.#w=void 0,this.#r=void 0),this.#T=!!this.#m,this.#U=!!this.#D,this.#f=!!this.#w,this.noDisposeOnSet=!!p,this.noUpdateTTL=!!m,this.noDeleteOnFetchRejection=!!_,this.allowStaleOnFetchRejection=!!g,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!v,this.maxEntrySize!==0){if(this.#c!==0&&!F(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!F(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!h,this.noDeleteOnStaleGet=!!b,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!r,this.ttlResolution=F(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!F(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#H()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let E="LRU_CACHE_UNBOUNDED";N(E)&&(U.add(E),H("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",E,c))}}getRemainingTTL(t){return this.#s.has(t)?1/0:0}#H(){let t=new W(this.#o),e=new W(this.#o);this.#d=t,this.#F=e;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#N=(r,h,a=this.#S.now())=>{e[r]=h!==0?a:0,t[r]=h,s(r,h)},this.#R=r=>{e[r]=t[r]!==0?this.#S.now():0,s(r,t[r])};let s=this.ttlAutopurge?(r,h)=>{if(i?.[r]&&(clearTimeout(i[r]),i[r]=void 0),h&&h!==0&&i){let a=setTimeout(()=>{this.#p(r)&&this.#z(this.#i[r],"expire")},h+1);a.unref&&a.unref(),i[r]=a}}:()=>{};this.#E=(r,h)=>{if(t[h]){let a=t[h],d=e[h];if(!a||!d)return;r.ttl=a,r.start=d,r.now=n||o();let f=r.now-d;r.remainingTTL=a-f}};let n=0,o=()=>{let r=this.#S.now();if(this.ttlResolution>0){n=r;let h=setTimeout(()=>n=0,this.ttlResolution);h.unref&&h.unref()}return r};this.getRemainingTTL=r=>{let h=this.#s.get(r);if(h===void 0)return 0;let a=t[h],d=e[h];if(!a||!d)return 1/0;let f=(n||o())-d;return a-f},this.#p=r=>{let h=e[r],a=t[r];return!!a&&!!h&&(n||o())-h>a}}#R=()=>{};#E=()=>{};#N=()=>{};#p=()=>!1;#X(){let t=new W(this.#o);this.#b=0,this.#_=t,this.#C=e=>{this.#b-=t[e],t[e]=0},this.#k=(e,i,s,n)=>{if(this.#e(i))return 0;if(!F(s))if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,e),!F(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");return s},this.#I=(e,i,s)=>{if(t[e]=i,this.#c){let n=this.#c-t[e];for(;this.#b>n;)this.#G(!0)}this.#b+=t[e],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#C=t=>{};#I=(t,e,i)=>{};#k=(t,e,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#h;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#a);)e=this.#u[e]}*#v({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#a;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#h);)e=this.#l[e]}#V(t){return t!==void 0&&this.#s.get(this.#i[t])===t}*entries(){for(let t of this.#A())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*rentries(){for(let t of this.#v())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*keys(){for(let t of this.#A()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*rkeys(){for(let t of this.#v()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*values(){for(let t of this.#A())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}*rvalues(){for(let t of this.#v())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(t,e={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&t(n,this.#i[i],this))return this.#x(this.#i[i],e)}}forEach(t,e=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}rforEach(t,e=this){for(let i of this.#v()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}purgeStale(){let t=!1;for(let e of this.#v({allowStale:!0}))this.#p(e)&&(this.#z(this.#i[e],"expire"),t=!0);return t}info(t){let e=this.#s.get(t);if(e===void 0)return;let i=this.#t[e],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let o=this.#d[e],r=this.#F[e];if(o&&r){let h=o-(this.#S.now()-r);n.ttl=h,n.start=Date.now()}}return this.#_&&(n.size=this.#_[e]),n}dump(){let t=[];for(let e of this.#A({allowStale:!0})){let i=this.#i[e],s=this.#t[e],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let o={value:n};if(this.#d&&this.#F){o.ttl=this.#d[e];let r=this.#S.now()-this.#F[e];o.start=Math.floor(Date.now()-r)}this.#_&&(o.size=this.#_[e]),t.unshift([i,o])}return t}load(t){this.clear();for(let[e,i]of t){if(i.start){let s=Date.now()-i.start;i.start=this.#S.now()-s}this.#W(e,i.value,i)}}set(t,e,i={}){let{status:s=u.metrics.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=t,e!==void 0&&(s.value=e));let n=this.#W(t,e,i);return s&&u.metrics.hasSubscribers&&u.metrics.publish(s),n}#W(t,e,i={}){let{ttl:s=this.ttl,start:n,noDisposeOnSet:o=this.noDisposeOnSet,sizeCalculation:r=this.sizeCalculation,status:h}=i;if(e===void 0)return h&&(h.set="deleted"),this.delete(t),this;let{noUpdateTTL:a=this.noUpdateTTL}=i;h&&!this.#e(e)&&(h.value=e);let d=this.#k(t,e,i.size||0,r,h);if(this.maxEntrySize&&d>this.maxEntrySize)return this.#z(t,"set"),h&&(h.set="miss",h.maxEntrySizeExceeded=!0),this;let f=this.#n===0?void 0:this.#s.get(t);if(f===void 0)f=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[f]=t,this.#t[f]=e,this.#s.set(t,f),this.#l[this.#h]=f,this.#u[f]=this.#h,this.#h=f,this.#n++,this.#I(f,d,h),h&&(h.set="add"),a=!1,this.#U&&this.#D?.(e,t,"add");else{this.#L(f);let p=this.#t[f];if(e!==p){if(this.#O&&this.#e(p)){p.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:m}=p;m!==void 0&&!o&&(this.#T&&this.#m?.(m,t,"set"),this.#f&&this.#r?.push([m,t,"set"]))}else o||(this.#T&&this.#m?.(p,t,"set"),this.#f&&this.#r?.push([p,t,"set"]));if(this.#C(f),this.#I(f,d,h),this.#t[f]=e,h){h.set="replace";let m=p&&this.#e(p)?p.__staleWhileFetching:p;m!==void 0&&(h.oldValue=m)}}else h&&(h.set="update");this.#U&&this.onInsert?.(e,t,e===p?"update":"replace")}if(s!==0&&!this.#d&&this.#H(),this.#d&&(a||this.#N(f,s,n),h&&this.#E(h,f)),!o&&this.#f&&this.#r){let p=this.#r,m;for(;m=p?.shift();)this.#w?.(...m)}return this}pop(){try{for(;this.#n;){let t=this.#t[this.#a];if(this.#G(!0),this.#e(t)){if(t.__staleWhileFetching)return t.__staleWhileFetching}else if(t!==void 0)return t}}finally{if(this.#f&&this.#r){let t=this.#r,e;for(;e=t?.shift();)this.#w?.(...e)}}}#G(t){let e=this.#a,i=this.#i[e],s=this.#t[e];return this.#O&&this.#e(s)?s.__abortController.abort(new Error("evicted")):(this.#T||this.#f)&&(this.#T&&this.#m?.(s,i,"evict"),this.#f&&this.#r?.push([s,i,"evict"])),this.#C(e),this.#g?.[e]&&(clearTimeout(this.#g[e]),this.#g[e]=void 0),t&&(this.#i[e]=void 0,this.#t[e]=void 0,this.#y.push(e)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[e],this.#s.delete(i),this.#n--,e}has(t,e={}){let{status:i=u.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="has",i.key=t);let s=this.#Y(t,e);return u.metrics.hasSubscribers&&u.metrics.publish(i),s}#Y(t,e={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=e,n=this.#s.get(t);if(n!==void 0){let o=this.#t[n];if(this.#e(o)&&o.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#R(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(t,e={}){let{status:i=D()?{}:void 0}=e;i&&(i.op="peek",i.key=t),e.status=i;let s=this.#J(t,e);return u.metrics.hasSubscribers&&u.metrics.publish(i),s}#J(t,e){let{status:i,allowStale:s=this.allowStale}=e,n=this.#s.get(t);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let o=this.#t[n],r=this.#e(o)?o.__staleWhileFetching:o;return i&&(r!==void 0?(i.peek="hit",i.value=r):i.peek="miss"),r}#P(t,e,i,s){let n=e===void 0?void 0:this.#t[e];if(this.#e(n))return n;let o=new AbortController,{signal:r}=i;r?.addEventListener("abort",()=>o.abort(r.reason),{signal:o.signal});let h={signal:o.signal,options:i,context:s},a=(w,y=!1)=>{let{aborted:l}=o.signal,S=i.ignoreFetchAbort&&w!==void 0,_=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&w!==void 0);if(i.status&&(l&&!y?(i.status.fetchAborted=!0,i.status.fetchError=o.signal.reason,S&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!S&&!y)return f(o.signal.reason,_);let b=m,g=this.#t[e];return(g===m||g===void 0&&S&&y)&&(w===void 0?b.__staleWhileFetching!==void 0?this.#t[e]=b.__staleWhileFetching:this.#z(t,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#W(t,w,h.options))),w},d=w=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=w),f(w,!1)),f=(w,y)=>{let{aborted:l}=o.signal,S=l&&i.allowStaleOnFetchAbort,_=S||i.allowStaleOnFetchRejection,b=_||i.noDeleteOnFetchRejection,g=m;if(this.#t[e]===m&&(!b||!y&&g.__staleWhileFetching===void 0?this.#z(t,"fetch"):S||(this.#t[e]=g.__staleWhileFetching)),_)return i.status&&g.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),g.__staleWhileFetching;if(g.__returned===g)throw w},p=(w,y)=>{let l=this.#M?.(t,n,h);l&&l instanceof Promise&&l.then(S=>w(S===void 0?void 0:S),y),o.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(w(void 0),i.allowStaleOnFetchAbort&&(w=S=>a(S,!0)))})};i.status&&(i.status.fetchDispatched=!0);let m=new Promise(p).then(a,d),T=Object.assign(m,{__abortController:o,__staleWhileFetching:n,__returned:void 0});return e===void 0?(this.#W(t,T,{...h.options,status:void 0}),e=this.#s.get(t)):this.#t[e]=T,T}#e(t){if(!this.#O)return!1;let e=t;return!!e&&e instanceof Promise&&e.hasOwnProperty("__staleWhileFetching")&&e.__abortController instanceof AbortController}fetch(t,e={}){let i=u.tracing.hasSubscribers,{status:s=D()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#q(t,e);return s&&D()&&i&&(s.trace=!0,u.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#q(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:o=this.ttl,noDisposeOnSet:r=this.noDisposeOnSet,size:h=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:p=this.allowStaleOnFetchRejection,ignoreFetchAbort:m=this.ignoreFetchAbort,allowStaleOnFetchAbort:T=this.allowStaleOnFetchAbort,context:w,forceRefresh:y=!1,status:l,signal:S}=e;if(l&&(l.op="fetch",l.key=t,y&&(l.forceRefresh=!0)),!this.#O)return l&&(l.fetch="get"),this.#x(t,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let _={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:o,noDisposeOnSet:r,size:h,sizeCalculation:a,noUpdateTTL:d,noDeleteOnFetchRejection:f,allowStaleOnFetchRejection:p,allowStaleOnFetchAbort:T,ignoreFetchAbort:m,status:l,signal:S},b=this.#s.get(t);if(b===void 0){l&&(l.fetch="miss");let g=this.#P(t,b,_,w);return g.__returned=g}else{let g=this.#t[b];if(this.#e(g)){let E=i&&g.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",E&&(l.returnedStale=!0)),E?g.__staleWhileFetching:g.__returned=g}let A=this.#p(b);if(!y&&!A)return l&&(l.fetch="hit"),this.#L(b),s&&this.#R(b),l&&this.#E(l,b),g;let v=this.#P(t,b,_,w),z=v.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",z&&A&&(l.returnedStale=!0)),z?v.__staleWhileFetching:v.__returned=v}}forceFetch(t,e={}){let i=u.tracing.hasSubscribers,{status:s=D()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#K(t,e);return s&&D()&&i&&(s.trace=!0,u.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#K(t,e={}){let i=await this.#q(t,e);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(t,e={}){let{status:i=u.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="memo",i.key=t,e.context&&(i.context=e.context));let s=this.#Q(t,e);return i&&(i.value=s),u.metrics.hasSubscribers&&u.metrics.publish(i),s}#Q(t,e={}){let i=this.#j;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:o,...r}=e;n&&o&&(n.forceRefresh=!0);let h=this.#x(t,r),a=o||h===void 0;if(n&&(n.memo=a?"miss":"hit",a||(n.value=h)),!a)return h;let d=i(t,h,{options:r,context:s});return n&&(n.value=d),this.#W(t,d,r),d}get(t,e={}){let{status:i=u.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="get",i.key=t);let s=this.#x(t,e);return i&&(s!==void 0&&(i.value=s),u.metrics.hasSubscribers&&u.metrics.publish(i)),s}#x(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:o}=e,r=this.#s.get(t);if(r===void 0){o&&(o.get="miss");return}let h=this.#t[r],a=this.#e(h);return o&&this.#E(o,r),this.#p(r)?a?(o&&(o.get="stale-fetching"),i&&h.__staleWhileFetching!==void 0?(o&&(o.returnedStale=!0),h.__staleWhileFetching):void 0):(n||this.#z(t,"expire"),o&&(o.get="stale"),i?(o&&(o.returnedStale=!0),h):void 0):(o&&(o.get=a?"fetching":"hit"),this.#L(r),s&&this.#R(r),a?h.__staleWhileFetching:h)}#B(t,e){this.#u[e]=t,this.#l[t]=e}#L(t){t!==this.#h&&(t===this.#a?this.#a=this.#l[t]:this.#B(this.#u[t],this.#l[t]),this.#B(this.#h,t),this.#h=t)}delete(t){return this.#z(t,"delete")}#z(t,e){u.metrics.hasSubscribers&&u.metrics.publish({op:"delete",delete:e,key:t});let i=!1;if(this.#n!==0){let s=this.#s.get(t);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#$(e);else{this.#C(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#m?.(n,t,e),this.#f&&this.#r?.push([n,t,e])),this.#s.delete(t),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let o=this.#u[s];this.#l[o]=this.#l[s];let r=this.#l[s];this.#u[r]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#w?.(...n)}return i}clear(){return this.#$("delete")}#$(t){for(let e of this.#v({allowStale:!0})){let i=this.#t[e];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[e];this.#T&&this.#m?.(i,s,t),this.#f&&this.#r?.push([i,s,t])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let e of this.#g??[])e!==void 0&&clearTimeout(e);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let e=this.#r,i;for(;i=e?.shift();)this.#w?.(...i)}}};exports.LRUCache=x;
+"use strict";var j=(c,t)=>()=>(t||c((t={exports:{}}).exports,t),t.exports);var I=j(O=>{"use strict";Object.defineProperty(O,"__esModule",{value:!0});O.tracing=O.metrics=void 0;var U={hasSubscribers:!1};O.metrics=U;O.tracing=U});var P=j(D=>{"use strict";Object.defineProperty(D,"__esModule",{value:!0});D.defaultPerf=void 0;D.defaultPerf=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date});Object.defineProperty(exports,"__esModule",{value:!0});exports.LRUCache=void 0;var g=I(),N=P(),x=()=>g.metrics.hasSubscribers||g.tracing.hasSubscribers,k=new Set,G=typeof process=="object"&&process?process:{},V=(c,t,e,i)=>{typeof G.emitWarning=="function"?G.emitWarning(c,t,e,i):console.error(`[${e}] ${t}: ${c}`)},B=c=>!k.has(c);var T=c=>!!c&&c===Math.floor(c)&&c>0&&isFinite(c),H=c=>T(c)?c<=Math.pow(2,8)?Uint8Array:c<=Math.pow(2,16)?Uint16Array:c<=Math.pow(2,32)?Uint32Array:c<=Number.MAX_SAFE_INTEGER?W:null:null,W=class extends Array{constructor(t){super(t),this.fill(0)}},C=class c{heap;length;static#o=!1;static create(t){let e=H(t);if(!e)return[];c.#o=!0;let i=new c(t,e);return c.#o=!1,i}constructor(t,e){if(!c.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new e(t),this.length=0}push(t){this.heap[this.length++]=t}pop(){return this.heap[--this.length]}},L=class c{#o;#c;#m;#W;#S;#M;#j;#w;get perf(){return this.#w}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#U;#f;#D;static unsafeExposeInternals(t){return{starts:t.#F,ttls:t.#d,autopurgeTimers:t.#g,sizes:t.#_,keyMap:t.#s,keyList:t.#i,valList:t.#t,next:t.#l,prev:t.#u,get head(){return t.#a},get tail(){return t.#h},free:t.#y,isBackgroundFetch:e=>t.#e(e),backgroundFetch:(e,i,s,n)=>t.#G(e,i,s,n),moveToTail:e=>t.#L(e),indexes:e=>t.#A(e),rindexes:e=>t.#z(e),isStale:e=>t.#p(e)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#j}get dispose(){return this.#m}get onInsert(){return this.#W}get disposeAfter(){return this.#S}constructor(t){let{max:e=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:y,noDisposeOnSet:_,noUpdateTTL:u,maxSize:p=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:S,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:w,allowStaleOnFetchRejection:m,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,backgroundFetchSize:M=1,perf:v}=t;if(this.backgroundFetchSize=M,v!==void 0&&typeof v?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#w=v??N.defaultPerf,e!==0&&!T(e))throw new TypeError("max option must be a nonnegative integer");let E=e?H(e):Array;if(!E)throw new Error("invalid max value: "+e);if(this.#o=e,this.#c=p,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(S!==void 0&&typeof S!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#j=S,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:e}).fill(void 0),this.#t=Array.from({length:e}).fill(void 0),this.#l=new E(e),this.#u=new E(e),this.#a=0,this.#h=0,this.#y=C.create(e),this.#n=0,this.#b=0,typeof o=="function"&&(this.#m=o),typeof d=="function"&&(this.#W=d),typeof y=="function"?(this.#S=y,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#m,this.#D=!!this.#W,this.#f=!!this.#S,this.noDisposeOnSet=!!_,this.noUpdateTTL=!!u,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!m,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!w,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let R="LRU_CACHE_UNBOUNDED";B(R)&&(k.add(R),V("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",R,c))}}getRemainingTTL(t){return this.#s.has(t)?1/0:0}#k(){let t=new W(this.#o),e=new W(this.#o);this.#d=t,this.#F=e;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#w.now())=>{e[h]=a!==0?o:0,t[h]=a,s(h,a)},this.#R=h=>{e[h]=t[h]!==0?this.#w.now():0,s(h,t[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#v(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#E=(h,a)=>{if(t[a]){let o=t[a],d=e[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let y=h.now-d;h.remainingTTL=o-y}};let n=0,r=()=>{let h=this.#w.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=t[a],d=e[a];if(!o||!d)return 1/0;let y=(n||r())-d;return o-y},this.#p=h=>{let a=e[h],o=t[h];return!!o&&!!a&&(n||r())-a>o}}#R=()=>{};#E=()=>{};#H=()=>{};#p=()=>!1;#X(){let t=new W(this.#o);this.#b=0,this.#_=t,this.#x=e=>{this.#b-=t[e],t[e]=0},this.#N=(e,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,e),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#I=(e,i,s)=>{if(t[e]=i,this.#c){let n=this.#c-t[e];for(;this.#b>n;)this.#P(!0)}this.#b+=t[e],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#x=t=>{};#I=(t,e,i)=>{};#N=(t,e,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#h;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#a);)e=this.#u[e]}*#z({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#a;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#h);)e=this.#l[e]}#V(t){return t!==void 0&&this.#s.get(this.#i[t])===t}*entries(){for(let t of this.#A())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*rentries(){for(let t of this.#z())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*keys(){for(let t of this.#A()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*rkeys(){for(let t of this.#z()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*values(){for(let t of this.#A())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}*rvalues(){for(let t of this.#z())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(t,e={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&t(n,this.#i[i],this))return this.#C(this.#i[i],e)}}forEach(t,e=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}rforEach(t,e=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}purgeStale(){let t=!1;for(let e of this.#z({allowStale:!0}))this.#p(e)&&(this.#v(this.#i[e],"expire"),t=!0);return t}info(t){let e=this.#s.get(t);if(e===void 0)return;let i=this.#t[e],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[e],h=this.#F[e];if(r&&h){let a=r-(this.#w.now()-h);n.ttl=a,n.start=Date.now()}}return this.#_&&(n.size=this.#_[e]),n}dump(){let t=[];for(let e of this.#A({allowStale:!0})){let i=this.#i[e],s=this.#t[e],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[e];let h=this.#w.now()-this.#F[e];r.start=Math.floor(Date.now()-h)}this.#_&&(r.size=this.#_[e]),t.unshift([i,r])}return t}load(t){this.clear();for(let[e,i]of t){if(i.start){let s=Date.now()-i.start;i.start=this.#w.now()-s}this.#O(e,i.value,i)}}set(t,e,i={}){let{status:s=g.metrics.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=t,e!==void 0&&(s.value=e),s.cache=this);let n=this.#O(t,e,i);return s&&g.metrics.hasSubscribers&&g.metrics.publish(s),n}#O(t,e,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(e);if(e===void 0)return o&&(o.set="deleted"),this.delete(t),this;let{noUpdateTTL:y=this.noUpdateTTL}=i;o&&!d&&(o.value=e);let _=this.#N(t,e,i.size||0,a,o);if(this.maxEntrySize&&_>this.maxEntrySize)return this.#v(t,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let u=this.#n===0?void 0:this.#s.get(t);if(u===void 0)u=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#P(!1):this.#n,this.#i[u]=t,this.#t[u]=e,this.#s.set(t,u),this.#l[this.#h]=u,this.#u[u]=this.#h,this.#h=u,this.#n++,this.#I(u,_,o),o&&(o.set="add"),y=!1,this.#D&&!d&&this.#W?.(e,t,"add");else{this.#L(u);let p=this.#t[u];if(e!==p){if(!h)if(this.#e(p)){p!==s&&p.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=p;f!==void 0&&f!==e&&(this.#T&&this.#m?.(f,t,"set"),this.#f&&this.#r?.push([f,t,"set"]))}else this.#T&&this.#m?.(p,t,"set"),this.#f&&this.#r?.push([p,t,"set"]);if(this.#x(u),this.#I(u,_,o),this.#t[u]=e,!d){let f=p&&this.#e(p)?p.__staleWhileFetching:p,b=f===void 0?"add":e!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#D&&this.onInsert?.(e,t,b)}}else d||(o&&(o.set="update"),this.#D&&this.onInsert?.(e,t,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(y||this.#H(u,n,r),o&&this.#E(o,u)),!h&&this.#f&&this.#r){let p=this.#r,f;for(;f=p?.shift();)this.#S?.(...f)}return this}pop(){try{for(;this.#n;){let t=this.#t[this.#a];if(this.#P(!0),this.#e(t)){if(t.__staleWhileFetching)return t.__staleWhileFetching}else if(t!==void 0)return t}}finally{if(this.#f&&this.#r){let t=this.#r,e;for(;e=t?.shift();)this.#S?.(...e)}}}#P(t){let e=this.#a,i=this.#i[e],s=this.#t[e],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#m?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#x(e),this.#g?.[e]&&(clearTimeout(this.#g[e]),this.#g[e]=void 0),t&&(this.#i[e]=void 0,this.#t[e]=void 0,this.#y.push(e)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[e],this.#s.delete(i),this.#n--,e}has(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="has",i.key=t,i.cache=this);let s=this.#Y(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Y(t,e={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=e,n=this.#s.get(t);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#R(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(t,e={}){let{status:i=x()?{}:void 0}=e;i&&(i.op="peek",i.key=t,i.cache=this),e.status=i;let s=this.#J(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#J(t,e){let{status:i,allowStale:s=this.allowStale}=e,n=this.#s.get(t);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#G(t,e,i,s){let n=e===void 0?void 0:this.#t[e];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,S=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,S&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!S&&!b)return y(r.signal.reason,F);let w=u,m=this.#t[e];return(m===u||m===void 0&&S&&b)&&(f===void 0?w.__staleWhileFetching!==void 0?this.#t[e]=w.__staleWhileFetching:this.#v(t,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(t,f,a.options,w))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),y(f,!1)),y=(f,b)=>{let{aborted:l}=r.signal,S=l&&i.allowStaleOnFetchAbort,F=S||i.allowStaleOnFetchRejection,w=F||i.noDeleteOnFetchRejection,m=u;if(this.#t[e]===u&&(!w||!b&&m.__staleWhileFetching===void 0?this.#v(t,"fetch"):S||(this.#t[e]=m.__staleWhileFetching)),F)return i.status&&m.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),m.__staleWhileFetching;if(m.__returned===m)throw f},_=(f,b)=>{let l=this.#M?.(t,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=S=>o(S,!0)))}),l&&l instanceof Promise?l.then(S=>f(S===void 0?void 0:S),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let u=new Promise(_).then(o,d),p=Object.assign(u,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return e===void 0?(this.#O(t,p,{...a.options,status:void 0}),e=this.#s.get(t)):this.#t[e]=p,p}#e(t){if(!this.#U)return!1;let e=t;return!!e&&e instanceof Promise&&e.hasOwnProperty("__staleWhileFetching")&&e.__abortController instanceof AbortController}fetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=x()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#B(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#B(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:y=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:_=this.allowStaleOnFetchRejection,ignoreFetchAbort:u=this.ignoreFetchAbort,allowStaleOnFetchAbort:p=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:S}=e;if(l&&(l.op="fetch",l.key=t,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#C(t,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:y,allowStaleOnFetchRejection:_,allowStaleOnFetchAbort:p,ignoreFetchAbort:u,status:l,signal:S},w=this.#s.get(t);if(w===void 0){l&&(l.fetch="miss");let m=this.#G(t,w,F,f);return m.__returned=m}else{let m=this.#t[w];if(this.#e(m)){let E=i&&m.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",E&&(l.returnedStale=!0)),E?m.__staleWhileFetching:m.__returned=m}let A=this.#p(w);if(!b&&!A)return l&&(l.fetch="hit"),this.#L(w),s&&this.#R(w),l&&this.#E(l,w),m;let z=this.#G(t,w,F,f),v=z.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",v&&A&&(l.returnedStale=!0)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=x()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#K(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#K(t,e={}){let i=await this.#B(t,e);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="memo",i.key=t,e.context&&(i.context=e.context),i.cache=this);let s=this.#Q(t,e);return i&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Q(t,e={}){let i=this.#j;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=e;n&&r&&(n.forceRefresh=!0);let a=this.#C(t,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(t,a,{options:h,context:s});return n&&(n.value=d),this.#O(t,d,h),d}get(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="get",i.key=t,i.cache=this);let s=this.#C(t,e);return i&&(s!==void 0&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i)),s}#C(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=e,h=this.#s.get(t);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#E(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#v(t,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#R(h),o?a.__staleWhileFetching:a)}#q(t,e){this.#u[e]=t,this.#l[t]=e}#L(t){t!==this.#h&&(t===this.#a?this.#a=this.#l[t]:this.#q(this.#u[t],this.#l[t]),this.#q(this.#h,t),this.#h=t)}delete(t){return this.#v(t,"delete")}#v(t,e){g.metrics.hasSubscribers&&g.metrics.publish({op:"delete",delete:e,key:t,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(t);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#$(e);else{this.#x(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#m?.(n,t,e),this.#f&&this.#r?.push([n,t,e])),this.#s.delete(t),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#$("delete")}#$(t){for(let e of this.#z({allowStale:!0})){let i=this.#t[e];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[e];this.#T&&this.#m?.(i,s,t),this.#f&&this.#r?.push([i,s,t])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let e of this.#g??[])e!==void 0&&clearTimeout(e);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let e=this.#r,i;for(;i=e?.shift();)this.#S?.(...i)}}};exports.LRUCache=L;
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/node/diagnostics-channel.js b/deps/npm/node_modules/lru-cache/dist/commonjs/node/diagnostics-channel.js
new file mode 100644
index 00000000000000..30f39a05a5630c
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/node/diagnostics-channel.js
@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+// simple node version that imports from node builtin
+// this is built to both ESM and CommonJS on the 'node' import path
+const node_diagnostics_channel_1 = require("node:diagnostics_channel");
+exports.metrics = (0, node_diagnostics_channel_1.channel)('lru-cache:metrics');
+exports.tracing = (0, node_diagnostics_channel_1.tracingChannel)('lru-cache');
+//# sourceMappingURL=diagnostics-channel-node.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.js b/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.js
new file mode 100644
index 00000000000000..6b8268b0ea9123
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.js
@@ -0,0 +1,1726 @@
+"use strict";
+/**
+ * @module LRUCache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+const diagnostics_channel_js_1 = require("./diagnostics-channel.js");
+const perf_js_1 = require("./perf.js");
+const hasSubscribers = () => diagnostics_channel_js_1.metrics.hasSubscribers || diagnostics_channel_js_1.tracing.hasSubscribers;
+const warned = new Set();
+/* c8 ignore start */
+const PROCESS = (typeof process === 'object' && !!process ?
+    process
+    : {});
+/* c8 ignore stop */
+const emitWarning = (msg, type, code, fn) => {
+    if (typeof PROCESS.emitWarning === 'function') {
+        PROCESS.emitWarning(msg, type, code, fn);
+    }
+    else {
+        //oxlint-disable-next-line no-console
+        console.error(`[${code}] ${type}: ${msg}`);
+    }
+};
+const shouldWarn = (code) => !warned.has(code);
+const TYPE = Symbol('type');
+const isPosInt = (n) => !!n && n === Math.floor(n) && n > 0 && isFinite(n);
+// This is a little bit ridiculous, tbh.
+// The maximum array length is 2^32-1 or thereabouts on most JS impls.
+// And well before that point, you're caching the entire world, I mean,
+// that's ~32GB of just integers for the next/prev links, plus whatever
+// else to hold that many keys and values.  Just filling the memory with
+// zeroes at init time is brutal when you get that big.
+// But why not be complete?
+// Maybe in the future, these limits will have expanded.
+/* c8 ignore start */
+const getUintArray = (max) => !isPosInt(max) ? null
+    : max <= Math.pow(2, 8) ? Uint8Array
+        : max <= Math.pow(2, 16) ? Uint16Array
+            : max <= Math.pow(2, 32) ? Uint32Array
+                : max <= Number.MAX_SAFE_INTEGER ? ZeroArray
+                    : null;
+/* c8 ignore stop */
+class ZeroArray extends Array {
+    constructor(size) {
+        super(size);
+        this.fill(0);
+    }
+}
+class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
+    heap;
+    /* c8 ignore stop */
+    length;
+    // private constructor
+    static #constructing = false;
+    static create(max) {
+        const HeapCls = getUintArray(max);
+        if (!HeapCls)
+            return [];
+        Stack.#constructing = true;
+        const s = new Stack(max, HeapCls);
+        Stack.#constructing = false;
+        return s;
+    }
+    constructor(max, HeapCls) {
+        /* c8 ignore start */
+        if (!Stack.#constructing) {
+            throw new TypeError('instantiate Stack using Stack.create(n)');
+        }
+        /* c8 ignore stop */
+        this.heap = new HeapCls(max);
+        this.length = 0;
+    }
+    push(n) {
+        this.heap[this.length++] = n;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+/**
+ * Default export, the thing you're using this module to get.
+ *
+ * The `K` and `V` types define the key and value types, respectively. The
+ * optional `FC` type defines the type of the `context` object passed to
+ * `cache.fetch()` and `cache.memo()`.
+ *
+ * Keys and values **must not** be `null` or `undefined`.
+ *
+ * All properties from the options object (with the exception of `max`,
+ * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+ * added as normal public members. (The listed options are read-only getters.)
+ *
+ * Changing any of these will alter the defaults for subsequent method calls.
+ */
+class LRUCache {
+    // options that cannot be changed without disaster
+    #max;
+    #maxSize;
+    #dispose;
+    #onInsert;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    #perf;
+    /**
+     * {@link LRUCache.OptionsBase.perf}
+     */
+    get perf() {
+        return this.#perf;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    ttl;
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    ttlResolution;
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    ttlAutopurge;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    updateAgeOnGet;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    updateAgeOnHas;
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    allowStale;
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    noDisposeOnSet;
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    noUpdateTTL;
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    maxEntrySize;
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    sizeCalculation;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    noDeleteOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    noDeleteOnStaleGet;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    allowStaleOnFetchAbort;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    allowStaleOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
+    // computed properties
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #autopurgeTimers;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    #hasOnInsert;
+    /**
+     * Do not call this method unless you need to inspect the
+     * inner workings of the cache.  If anything returned by this
+     * object is modified in any way, strange breakage may occur.
+     *
+     * These fields are private for a reason!
+     *
+     * @internal
+     */
+    static unsafeExposeInternals(c) {
+        return {
+            // properties
+            starts: c.#starts,
+            ttls: c.#ttls,
+            autopurgeTimers: c.#autopurgeTimers,
+            sizes: c.#sizes,
+            keyMap: c.#keyMap,
+            keyList: c.#keyList,
+            valList: c.#valList,
+            next: c.#next,
+            prev: c.#prev,
+            get head() {
+                return c.#head;
+            },
+            get tail() {
+                return c.#tail;
+            },
+            free: c.#free,
+            // methods
+            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+            moveToTail: (index) => c.#moveToTail(index),
+            indexes: (options) => c.#indexes(options),
+            rindexes: (options) => c.#rindexes(options),
+            isStale: (index) => c.#isStale(index),
+        };
+    }
+    // Protected read-only members
+    /**
+     * {@link LRUCache.OptionsBase.max} (read-only)
+     */
+    get max() {
+        return this.#max;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.maxSize} (read-only)
+     */
+    get maxSize() {
+        return this.#maxSize;
+    }
+    /**
+     * The total computed size of items in the cache (read-only)
+     */
+    get calculatedSize() {
+        return this.#calculatedSize;
+    }
+    /**
+     * The number of items stored in the cache (read-only)
+     */
+    get size() {
+        return this.#size;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+     */
+    get fetchMethod() {
+        return this.#fetchMethod;
+    }
+    get memoMethod() {
+        return this.#memoMethod;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.dispose} (read-only)
+     */
+    get dispose() {
+        return this.#dispose;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.onInsert} (read-only)
+     */
+    get onInsert() {
+        return this.#onInsert;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+     */
+    get disposeAfter() {
+        return this.#disposeAfter;
+    }
+    constructor(options) {
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
+        if (perf !== undefined) {
+            if (typeof perf?.now !== 'function') {
+                throw new TypeError('perf option must have a now() method if specified');
+            }
+        }
+        this.#perf = perf ?? perf_js_1.defaultPerf;
+        if (max !== 0 && !isPosInt(max)) {
+            throw new TypeError('max option must be a nonnegative integer');
+        }
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) {
+            throw new Error('invalid max value: ' + max);
+        }
+        this.#max = max;
+        this.#maxSize = maxSize;
+        this.maxEntrySize = maxEntrySize || this.#maxSize;
+        this.sizeCalculation = sizeCalculation;
+        if (this.sizeCalculation) {
+            if (!this.#maxSize && !this.maxEntrySize) {
+                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+            }
+            if (typeof this.sizeCalculation !== 'function') {
+                throw new TypeError('sizeCalculation set to non-function');
+            }
+        }
+        if (memoMethod !== undefined && typeof memoMethod !== 'function') {
+            throw new TypeError('memoMethod must be a function if defined');
+        }
+        this.#memoMethod = memoMethod;
+        if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {
+            throw new TypeError('fetchMethod must be a function if specified');
+        }
+        this.#fetchMethod = fetchMethod;
+        this.#hasFetchMethod = !!fetchMethod;
+        this.#keyMap = new Map();
+        this.#keyList = Array.from({ length: max }).fill(undefined);
+        this.#valList = Array.from({ length: max }).fill(undefined);
+        this.#next = new UintArray(max);
+        this.#prev = new UintArray(max);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free = Stack.create(max);
+        this.#size = 0;
+        this.#calculatedSize = 0;
+        if (typeof dispose === 'function') {
+            this.#dispose = dispose;
+        }
+        if (typeof onInsert === 'function') {
+            this.#onInsert = onInsert;
+        }
+        if (typeof disposeAfter === 'function') {
+            this.#disposeAfter = disposeAfter;
+            this.#disposed = [];
+        }
+        else {
+            this.#disposeAfter = undefined;
+            this.#disposed = undefined;
+        }
+        this.#hasDispose = !!this.#dispose;
+        this.#hasOnInsert = !!this.#onInsert;
+        this.#hasDisposeAfter = !!this.#disposeAfter;
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+        this.ignoreFetchAbort = !!ignoreFetchAbort;
+        // NB: maxEntrySize is set to maxSize if it's set
+        if (this.maxEntrySize !== 0) {
+            if (this.#maxSize !== 0) {
+                if (!isPosInt(this.#maxSize)) {
+                    throw new TypeError('maxSize must be a positive integer if specified');
+                }
+            }
+            if (!isPosInt(this.maxEntrySize)) {
+                throw new TypeError('maxEntrySize must be a positive integer if specified');
+            }
+            this.#initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale;
+        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution =
+            isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || 0;
+        if (this.ttl) {
+            if (!isPosInt(this.ttl)) {
+                throw new TypeError('ttl must be a positive integer if specified');
+            }
+            this.#initializeTTLTracking();
+        }
+        // do not allow completely unbounded caches
+        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+            throw new TypeError('At least one of max, maxSize, or ttl is required');
+        }
+        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+            const code = 'LRU_CACHE_UNBOUNDED';
+            if (shouldWarn(code)) {
+                warned.add(code);
+                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
+                    'result in unbounded memory consumption.';
+                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+            }
+        }
+    }
+    /**
+     * Return the number of ms left in the item's TTL. If item is not in cache,
+     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+     */
+    getRemainingTTL(key) {
+        return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+        const ttls = new ZeroArray(this.#max);
+        const starts = new ZeroArray(this.#max);
+        this.#ttls = ttls;
+        this.#starts = starts;
+        const purgeTimers = this.ttlAutopurge ?
+            Array.from({
+                length: this.#max,
+            })
+            : undefined;
+        this.#autopurgeTimers = purgeTimers;
+        this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {
+            starts[index] = ttl !== 0 ? start : 0;
+            ttls[index] = ttl;
+            setPurgetTimer(index, ttl);
+        };
+        this.#updateItemAge = index => {
+            starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0;
+            setPurgetTimer(index, ttls[index]);
+        };
+        // clear out the purge timer if we're setting TTL to 0, and
+        // previously had a ttl purge timer running, so it doesn't
+        // fire unnecessarily. Don't need to do this if we're not doing
+        // autopurge.
+        const setPurgetTimer = !this.ttlAutopurge ?
+            () => { }
+            : (index, ttl) => {
+                if (purgeTimers?.[index]) {
+                    clearTimeout(purgeTimers[index]);
+                    purgeTimers[index] = undefined;
+                }
+                if (ttl && ttl !== 0 && purgeTimers) {
+                    const t = setTimeout(() => {
+                        if (this.#isStale(index)) {
+                            this.#delete(this.#keyList[index], 'expire');
+                        }
+                    }, ttl + 1);
+                    // unref() not supported on all platforms
+                    /* c8 ignore start */
+                    if (t.unref) {
+                        t.unref();
+                    }
+                    /* c8 ignore stop */
+                    purgeTimers[index] = t;
+                }
+            };
+        this.#statusTTL = (status, index) => {
+            if (ttls[index]) {
+                const ttl = ttls[index];
+                const start = starts[index];
+                /* c8 ignore start */
+                if (!ttl || !start) {
+                    return;
+                }
+                /* c8 ignore stop */
+                status.ttl = ttl;
+                status.start = start;
+                status.now = cachedNow || getNow();
+                const age = status.now - start;
+                status.remainingTTL = ttl - age;
+            }
+        };
+        // debounce calls to perf.now() to 1s so we're not hitting
+        // that costly call repeatedly.
+        let cachedNow = 0;
+        const getNow = () => {
+            const n = this.#perf.now();
+            if (this.ttlResolution > 0) {
+                cachedNow = n;
+                const t = setTimeout(() => (cachedNow = 0), this.ttlResolution);
+                // not available on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+            return n;
+        };
+        this.getRemainingTTL = key => {
+            const index = this.#keyMap.get(key);
+            if (index === undefined) {
+                return 0;
+            }
+            const ttl = ttls[index];
+            const start = starts[index];
+            if (!ttl || !start) {
+                return Infinity;
+            }
+            const age = (cachedNow || getNow()) - start;
+            return ttl - age;
+        };
+        this.#isStale = index => {
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        };
+    }
+    // conditionally set private methods related to TTL
+    #updateItemAge = () => { };
+    #statusTTL = () => { };
+    #setItemTTL = () => { };
+    /* c8 ignore stop */
+    #isStale = () => false;
+    #initializeSizeTracking() {
+        const sizes = new ZeroArray(this.#max);
+        this.#calculatedSize = 0;
+        this.#sizes = sizes;
+        this.#removeItemSize = index => {
+            this.#calculatedSize -= sizes[index];
+            sizes[index] = 0;
+        };
+        this.#requireSize = (k, v, size, sizeCalculation) => {
+            if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
+                if (sizeCalculation) {
+                    if (typeof sizeCalculation !== 'function') {
+                        throw new TypeError('sizeCalculation must be a function');
+                    }
+                    size = sizeCalculation(v, k);
+                    if (!isPosInt(size)) {
+                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+                    }
+                }
+                else {
+                    throw new TypeError('invalid size value (must be positive integer). ' +
+                        'When maxSize or maxEntrySize is used, sizeCalculation ' +
+                        'or size must be set.');
+                }
+            }
+            return size;
+        };
+        this.#addItemSize = (index, size, status) => {
+            sizes[index] = size;
+            if (this.#maxSize) {
+                const maxSize = this.#maxSize - sizes[index];
+                while (this.#calculatedSize > maxSize) {
+                    this.#evict(true);
+                }
+            }
+            this.#calculatedSize += sizes[index];
+            if (status) {
+                status.entrySize = size;
+                status.totalCalculatedSize = this.#calculatedSize;
+            }
+        };
+    }
+    #removeItemSize = _i => { };
+    #addItemSize = (_i, _s, _st) => { };
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+        if (size || sizeCalculation) {
+            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+        }
+        return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#tail; this.#isValidIndex(i);) {
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#head) {
+                    break;
+                }
+                else {
+                    i = this.#prev[i];
+                }
+            }
+        }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#head; this.#isValidIndex(i);) {
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#tail) {
+                    break;
+                }
+                else {
+                    i = this.#next[i];
+                }
+            }
+        }
+    }
+    #isValidIndex(index) {
+        return (index !== undefined &&
+            this.#keyMap.get(this.#keyList[index]) === index);
+    }
+    /**
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from most recently used to least recently used.
+     */
+    *entries() {
+        for (const i of this.#indexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.entries}
+     *
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from least recently used to most recently used.
+     */
+    *rentries() {
+        for (const i of this.#rindexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the keys in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *keys() {
+        for (const i of this.#indexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.keys}
+     *
+     * Return a generator yielding the keys in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rkeys() {
+        for (const i of this.#rindexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the values in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *values() {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.values}
+     *
+     * Return a generator yielding the values in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rvalues() {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Iterating over the cache itself yields the same results as
+     * {@link LRUCache.entries}
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
+     */
+    [Symbol.toStringTag] = 'LRUCache';
+    /**
+     * Find a value for which the supplied fn method returns a truthy value,
+     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+     */
+    find(fn, getOptions = {}) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            if (fn(value, this.#keyList[i], this)) {
+                return this.#get(this.#keyList[i], getOptions);
+            }
+        }
+    }
+    /**
+     * Call the supplied function on each item in the cache, in order from most
+     * recently used to least recently used.
+     *
+     * `fn` is called as `fn(value, key, cache)`.
+     *
+     * If `thisp` is provided, function will be called in the `this`-context of
+     * the provided object, or the cache if no `thisp` object is provided.
+     *
+     * Does not update age or recenty of use, or iterate over stale values.
+     */
+    forEach(fn, thisp = this) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * The same as {@link LRUCache.forEach} but items are iterated over in
+     * reverse order.  (ie, less recently used items are iterated over first.)
+     */
+    rforEach(fn, thisp = this) {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * Delete any stale entries. Returns true if anything was removed,
+     * false otherwise.
+     */
+    purgeStale() {
+        let deleted = false;
+        for (const i of this.#rindexes({ allowStale: true })) {
+            if (this.#isStale(i)) {
+                this.#delete(this.#keyList[i], 'expire');
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Returns `undefined` if the key is not present.
+     *
+     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+     * serialization, the `start` value is always the current timestamp, and the
+     * `ttl` is a calculated remaining time to live (negative if expired).
+     *
+     * Always returns stale values, if their info is found in the cache, so be
+     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+     * if relevant.
+     */
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (i === undefined)
+            return undefined;
+        const v = this.#valList[i];
+        /* c8 ignore start - this isn't tested for the info function,
+         * but it's the same logic as found in other places. */
+        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (value === undefined)
+            return undefined;
+        /* c8 ignore stop */
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (this.#perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) {
+            entry.size = this.#sizes[i];
+        }
+        return entry;
+    }
+    /**
+     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+     * passed to {@link LRUCache#load}.
+     *
+     * The `start` fields are calculated relative to a portable `Date.now()`
+     * timestamp, even if `performance.now()` is available.
+     *
+     * Stale entries are always included in the `dump`, even if
+     * {@link LRUCache.OptionsBase.allowStale} is false.
+     *
+     * Note: this returns an actual array, not a generator, so it can be more
+     * easily passed around.
+     */
+    dump() {
+        const arr = [];
+        for (const i of this.#indexes({ allowStale: true })) {
+            const key = this.#keyList[i];
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+            if (value === undefined || key === undefined)
+                continue;
+            const entry = { value };
+            if (this.#ttls && this.#starts) {
+                entry.ttl = this.#ttls[i];
+                // always dump the start relative to a portable timestamp
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = this.#perf.now() - this.#starts[i];
+                entry.start = Math.floor(Date.now() - age);
+            }
+            if (this.#sizes) {
+                entry.size = this.#sizes[i];
+            }
+            arr.unshift([key, entry]);
+        }
+        return arr;
+    }
+    /**
+     * Reset the cache and load in the items in entries in the order listed.
+     *
+     * The shape of the resulting cache may be different if the same options are
+     * not used in both caches.
+     *
+     * The `start` fields are assumed to be calculated relative to a portable
+     * `Date.now()` timestamp, even if `performance.now()` is available.
+     */
+    load(arr) {
+        this.clear();
+        for (const [key, entry] of arr) {
+            if (entry.start) {
+                // entry.start is a portable timestamp, but we may be using
+                // node's performance.now(), so calculate the offset, so that
+                // we get the intended remaining TTL, no matter how long it's
+                // been on ice.
+                //
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = Date.now() - entry.start;
+                entry.start = this.#perf.now() - age;
+            }
+            this.#set(key, entry.value, entry);
+        }
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * Note: if `undefined` is specified as a value, this is an alias for
+     * {@link LRUCache#delete}
+     *
+     * Fields on the {@link LRUCache.SetOptions} options param will override
+     * their corresponding values in the constructor options for the scope
+     * of this single `set()` operation.
+     *
+     * If `start` is provided, then that will set the effective start
+     * time for the TTL calculation. Note that this must be a previous
+     * value of `performance.now()` if supported, or a previous value of
+     * `Date.now()` if not.
+     *
+     * Options object may also include `size`, which will prevent
+     * calling the `sizeCalculation` function and just use the specified
+     * number if it is a positive integer, and `noDisposeOnSet` which
+     * will prevent calling a `dispose` function in the case of
+     * overwrites.
+     *
+     * If the `size` (or return value of `sizeCalculation`) for a given
+     * entry is greater than `maxEntrySize`, then the item will not be
+     * added to the cache.
+     *
+     * Will update the recency of the entry.
+     *
+     * If the value is `undefined`, then this is an alias for
+     * `cache.delete(key)`. `undefined` is never stored in the cache.
+     */
+    set(k, v, setOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = setOptions;
+        setOptions.status = status;
+        if (status) {
+            status.op = 'set';
+            status.key = k;
+            if (v !== undefined)
+                status.value = v;
+            status.cache = this;
+        }
+        const result = this.#set(k, v, setOptions);
+        if (status && diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #set(k, v, setOptions, bf) {
+        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
+        if (v === undefined) {
+            if (status)
+                status.set = 'deleted';
+            this.delete(k);
+            return this;
+        }
+        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+        if (status && !isBF)
+            status.value = v;
+        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
+        // if the item doesn't fit, don't do anything
+        // NB: maxEntrySize set to maxSize by default
+        if (this.maxEntrySize && size > this.maxEntrySize) {
+            // have to delete, in case something is there already.
+            this.#delete(k, 'set');
+            if (status) {
+                status.set = 'miss';
+                status.maxEntrySizeExceeded = true;
+            }
+            return this;
+        }
+        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+        if (index === undefined) {
+            // addition
+            index = (this.#size === 0 ? this.#tail
+                : this.#free.length !== 0 ? this.#free.pop()
+                    : this.#size === this.#max ? this.#evict(false)
+                        : this.#size);
+            this.#keyList[index] = k;
+            this.#valList[index] = v;
+            this.#keyMap.set(k, index);
+            this.#next[this.#tail] = index;
+            this.#prev[index] = this.#tail;
+            this.#tail = index;
+            this.#size++;
+            this.#addItemSize(index, size, status);
+            if (status)
+                status.set = 'add';
+            noUpdateTTL = false;
+            if (this.#hasOnInsert && !isBF) {
+                this.#onInsert?.(v, k, 'add');
+            }
+        }
+        else {
+            // update
+            // might be updating a background fetch!
+            this.#moveToTail(index);
+            const oldVal = this.#valList[index];
+            if (v !== oldVal) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(oldVal, k, 'set');
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([oldVal, k, 'set']);
+                        }
+                    }
+                }
+                this.#removeItemSize(index);
+                this.#addItemSize(index, size, status);
+                this.#valList[index] = v;
+                if (!isBF) {
+                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
+                        oldVal.__staleWhileFetching
+                        : oldVal;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
+                }
+            }
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
+            }
+        }
+        if (ttl !== 0 && !this.#ttls) {
+            this.#initializeTTLTracking();
+        }
+        if (this.#ttls) {
+            if (!noUpdateTTL) {
+                this.#setItemTTL(index, ttl, start);
+            }
+            if (status)
+                this.#statusTTL(status, index);
+        }
+        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return this;
+    }
+    /**
+     * Evict the least recently used item, returning its value or
+     * `undefined` if cache is empty.
+     */
+    pop() {
+        try {
+            while (this.#size) {
+                const val = this.#valList[this.#head];
+                this.#evict(true);
+                if (this.#isBackgroundFetch(val)) {
+                    if (val.__staleWhileFetching) {
+                        return val.__staleWhileFetching;
+                    }
+                }
+                else if (val !== undefined) {
+                    return val;
+                }
+            }
+        }
+        finally {
+            if (this.#hasDisposeAfter && this.#disposed) {
+                const dt = this.#disposed;
+                let task;
+                while ((task = dt?.shift())) {
+                    this.#disposeAfter?.(...task);
+                }
+            }
+        }
+    }
+    #evict(free) {
+        const head = this.#head;
+        const k = this.#keyList[head];
+        const v = this.#valList[head];
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
+            v.__abortController.abort(new Error('evicted'));
+        }
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
+            if (this.#hasDispose) {
+                this.#dispose?.(oldValue, k, 'evict');
+            }
+            if (this.#hasDisposeAfter) {
+                this.#disposed?.push([oldValue, k, 'evict']);
+            }
+        }
+        this.#removeItemSize(head);
+        if (this.#autopurgeTimers?.[head]) {
+            clearTimeout(this.#autopurgeTimers[head]);
+            this.#autopurgeTimers[head] = undefined;
+        }
+        // if we aren't about to use the index, then null these out
+        if (free) {
+            this.#keyList[head] = undefined;
+            this.#valList[head] = undefined;
+            this.#free.push(head);
+        }
+        if (this.#size === 1) {
+            this.#head = this.#tail = 0;
+            this.#free.length = 0;
+        }
+        else {
+            this.#head = this.#next[head];
+        }
+        this.#keyMap.delete(k);
+        this.#size--;
+        return head;
+    }
+    /**
+     * Check if a key is in the cache, without updating the recency of use.
+     * Will return false if the item is stale, even though it is technically
+     * in the cache.
+     *
+     * Check if a key is in the cache, without updating the recency of
+     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+     * to `true` in either the options or the constructor.
+     *
+     * Will return `false` if the item is stale, even though it is technically in
+     * the cache. The difference can be determined (if it matters) by using a
+     * `status` argument, and inspecting the `has` field.
+     *
+     * Will not update item age unless
+     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+     */
+    has(k, hasOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = hasOptions;
+        hasOptions.status = status;
+        if (status) {
+            status.op = 'has';
+            status.key = k;
+            status.cache = this;
+        }
+        const result = this.#has(k, hasOptions);
+        if (diagnostics_channel_js_1.metrics.hasSubscribers)
+            diagnostics_channel_js_1.metrics.publish(status);
+        return result;
+    }
+    #has(k, hasOptions = {}) {
+        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v) &&
+                v.__staleWhileFetching === undefined) {
+                return false;
+            }
+            if (!this.#isStale(index)) {
+                if (updateAgeOnHas) {
+                    this.#updateItemAge(index);
+                }
+                if (status) {
+                    status.has = 'hit';
+                    this.#statusTTL(status, index);
+                }
+                return true;
+            }
+            else if (status) {
+                status.has = 'stale';
+                this.#statusTTL(status, index);
+            }
+        }
+        else if (status) {
+            status.has = 'miss';
+        }
+        return false;
+    }
+    /**
+     * Like {@link LRUCache#get} but doesn't update recency or delete stale
+     * items.
+     *
+     * Returns `undefined` if the item is stale, unless
+     * {@link LRUCache.OptionsBase.allowStale} is set.
+     */
+    peek(k, peekOptions = {}) {
+        const { status = hasSubscribers() ? {} : undefined } = peekOptions;
+        if (status) {
+            status.op = 'peek';
+            status.key = k;
+            status.cache = this;
+        }
+        peekOptions.status = status;
+        const result = this.#peek(k, peekOptions);
+        if (diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #peek(k, peekOptions) {
+        const { status, allowStale = this.allowStale } = peekOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined || (!allowStale && this.#isStale(index))) {
+            if (status)
+                status.peek = index === undefined ? 'miss' : 'stale';
+            return undefined;
+        }
+        const v = this.#valList[index];
+        const val = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+        if (status) {
+            if (val !== undefined) {
+                status.peek = 'hit';
+                status.value = val;
+            }
+            else {
+                status.peek = 'miss';
+            }
+        }
+        return val;
+    }
+    #backgroundFetch(k, index, options, context) {
+        const v = index === undefined ? undefined : this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+            return v;
+        }
+        const ac = new AbortController();
+        const { signal } = options;
+        // when/if our AC signals, then stop listening to theirs.
+        signal?.addEventListener('abort', () => ac.abort(signal.reason), {
+            signal: ac.signal,
+        });
+        const fetchOpts = {
+            signal: ac.signal,
+            options,
+            context,
+        };
+        const cb = (v, updateCache = false) => {
+            const { aborted } = ac.signal;
+            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
+            const proceed = options.ignoreFetchAbort ||
+                !!(options.allowStaleOnFetchAbort && v !== undefined);
+            if (options.status) {
+                if (aborted && !updateCache) {
+                    options.status.fetchAborted = true;
+                    options.status.fetchError = ac.signal.reason;
+                    if (ignoreAbort)
+                        options.status.fetchAbortIgnored = true;
+                }
+                else {
+                    options.status.fetchResolved = true;
+                }
+            }
+            if (aborted && !ignoreAbort && !updateCache) {
+                return fetchFail(ac.signal.reason, proceed);
+            }
+            // either we didn't abort, and are still here, or we did, and ignored
+            const bf = p;
+            // if nothing else has been written there but we're set to update the
+            // cache and ignore the abort, or if it's still pending on this specific
+            // background request, then write it to the cache.
+            const vl = this.#valList[index];
+            if (vl === p || (vl === undefined && ignoreAbort && updateCache)) {
+                if (v === undefined) {
+                    if (bf.__staleWhileFetching !== undefined) {
+                        this.#valList[index] = bf.__staleWhileFetching;
+                    }
+                    else {
+                        this.#delete(k, 'fetch');
+                    }
+                }
+                else {
+                    if (options.status)
+                        options.status.fetchUpdated = true;
+                    this.#set(k, v, fetchOpts.options, bf);
+                }
+            }
+            return v;
+        };
+        const eb = (er) => {
+            if (options.status) {
+                options.status.fetchRejected = true;
+                options.status.fetchError = er;
+            }
+            // do not pass go, do not collect $200
+            return fetchFail(er, false);
+        };
+        const fetchFail = (er, proceed) => {
+            const { aborted } = ac.signal;
+            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+            const noDelete = allowStale || options.noDeleteOnFetchRejection;
+            const bf = p;
+            if (this.#valList[index] === p) {
+                // if we allow stale on fetch rejections, then we need to ensure that
+                // the stale value is not removed from the cache when the fetch fails.
+                const del = !noDelete || (!proceed && bf.__staleWhileFetching === undefined);
+                if (del) {
+                    this.#delete(k, 'fetch');
+                }
+                else if (!allowStaleAborted) {
+                    // still replace the *promise* with the stale value,
+                    // since we are done with the promise at this point.
+                    // leave it untouched if we're still waiting for an
+                    // aborted background fetch that hasn't yet returned.
+                    this.#valList[index] = bf.__staleWhileFetching;
+                }
+            }
+            if (allowStale) {
+                if (options.status && bf.__staleWhileFetching !== undefined) {
+                    options.status.returnedStale = true;
+                }
+                return bf.__staleWhileFetching;
+            }
+            else if (bf.__returned === bf) {
+                throw er;
+            }
+        };
+        const pcall = (res, rej) => {
+            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+            // ignored, we go until we finish, regardless.
+            // defer check until we are actually aborting,
+            // so fetchMethod can override.
+            ac.signal.addEventListener('abort', () => {
+                if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+                    res(undefined);
+                    // when it eventually resolves, update the cache.
+                    if (options.allowStaleOnFetchAbort) {
+                        res = v => cb(v, true);
+                    }
+                }
+            });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
+        };
+        if (options.status)
+            options.status.fetchDispatched = true;
+        const p = new Promise(pcall).then(cb, eb);
+        const bf = Object.assign(p, {
+            __abortController: ac,
+            __staleWhileFetching: v,
+            __returned: undefined,
+        });
+        if (index === undefined) {
+            // internal, don't expose status.
+            this.#set(k, bf, { ...fetchOpts.options, status: undefined });
+            index = this.#keyMap.get(k);
+        }
+        else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
+            this.#valList[index] = bf;
+        }
+        return bf;
+    }
+    #isBackgroundFetch(p) {
+        if (!this.#hasFetchMethod)
+            return false;
+        const b = p;
+        return (!!b &&
+            b instanceof Promise &&
+            b.hasOwnProperty('__staleWhileFetching') &&
+            b.__abortController instanceof AbortController);
+    }
+    fetch(k, fetchOptions = {}) {
+        const ths = diagnostics_channel_js_1.tracing.hasSubscribers;
+        const { status = hasSubscribers() ? {} : undefined } = fetchOptions;
+        fetchOptions.status = status;
+        if (status && fetchOptions.context) {
+            status.context = fetchOptions.context;
+        }
+        const p = this.#fetch(k, fetchOptions);
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
+        }
+        return p;
+    }
+    async #fetch(k, fetchOptions = {}) {
+        const {
+        // get options
+        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+        // set options
+        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL,
+        // fetch exclusive options
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal, } = fetchOptions;
+        if (status) {
+            status.op = 'fetch';
+            status.key = k;
+            if (forceRefresh)
+                status.forceRefresh = true;
+            status.cache = this;
+        }
+        if (!this.#hasFetchMethod) {
+            if (status)
+                status.fetch = 'get';
+            return this.#get(k, {
+                allowStale,
+                updateAgeOnGet,
+                noDeleteOnStaleGet,
+                status,
+            });
+        }
+        const options = {
+            allowStale,
+            updateAgeOnGet,
+            noDeleteOnStaleGet,
+            ttl,
+            noDisposeOnSet,
+            size,
+            sizeCalculation,
+            noUpdateTTL,
+            noDeleteOnFetchRejection,
+            allowStaleOnFetchRejection,
+            allowStaleOnFetchAbort,
+            ignoreFetchAbort,
+            status,
+            signal,
+        };
+        let index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.fetch = 'miss';
+            const p = this.#backgroundFetch(k, index, options, context);
+            return (p.__returned = p);
+        }
+        else {
+            // in cache, maybe already fetching
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                const stale = allowStale && v.__staleWhileFetching !== undefined;
+                if (status) {
+                    status.fetch = 'inflight';
+                    if (stale)
+                        status.returnedStale = true;
+                }
+                return stale ? v.__staleWhileFetching : (v.__returned = v);
+            }
+            // if we force a refresh, that means do NOT serve the cached value,
+            // unless we are already in the process of refreshing the cache.
+            const isStale = this.#isStale(index);
+            if (!forceRefresh && !isStale) {
+                if (status)
+                    status.fetch = 'hit';
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                if (status)
+                    this.#statusTTL(status, index);
+                return v;
+            }
+            // ok, it is stale or a forced refresh, and not already fetching.
+            // refresh the cache.
+            const p = this.#backgroundFetch(k, index, options, context);
+            const hasStale = p.__staleWhileFetching !== undefined;
+            const staleVal = hasStale && allowStale;
+            if (status) {
+                status.fetch = isStale ? 'stale' : 'refresh';
+                if (staleVal && isStale)
+                    status.returnedStale = true;
+            }
+            return staleVal ? p.__staleWhileFetching : (p.__returned = p);
+        }
+    }
+    forceFetch(k, fetchOptions = {}) {
+        const ths = diagnostics_channel_js_1.tracing.hasSubscribers;
+        const { status = hasSubscribers() ? {} : undefined } = fetchOptions;
+        fetchOptions.status = status;
+        if (status && fetchOptions.context) {
+            status.context = fetchOptions.context;
+        }
+        const p = this.#forceFetch(k, fetchOptions);
+        if (status && ths) {
+            status.trace = true;
+            diagnostics_channel_js_1.tracing.tracePromise(() => p, status).catch(() => { });
+        }
+        return p;
+    }
+    async #forceFetch(k, fetchOptions = {}) {
+        const v = await this.#fetch(k, fetchOptions);
+        if (v === undefined)
+            throw new Error('fetch() returned undefined');
+        return v;
+    }
+    memo(k, memoOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = memoOptions;
+        memoOptions.status = status;
+        if (status) {
+            status.op = 'memo';
+            status.key = k;
+            if (memoOptions.context) {
+                status.context = memoOptions.context;
+            }
+            status.cache = this;
+        }
+        const result = this.#memo(k, memoOptions);
+        if (status)
+            status.value = result;
+        if (diagnostics_channel_js_1.metrics.hasSubscribers)
+            diagnostics_channel_js_1.metrics.publish(status);
+        return result;
+    }
+    #memo(k, memoOptions = {}) {
+        const memoMethod = this.#memoMethod;
+        if (!memoMethod) {
+            throw new Error('no memoMethod provided to constructor');
+        }
+        const { context, status, forceRefresh, ...options } = memoOptions;
+        if (status && forceRefresh)
+            status.forceRefresh = true;
+        const v = this.#get(k, options);
+        const refresh = forceRefresh || v === undefined;
+        if (status) {
+            status.memo = refresh ? 'miss' : 'hit';
+            if (!refresh)
+                status.value = v;
+        }
+        if (!refresh)
+            return v;
+        const vv = memoMethod(k, v, {
+            options,
+            context,
+        });
+        if (status)
+            status.value = vv;
+        this.#set(k, vv, options);
+        return vv;
+    }
+    /**
+     * Return a value from the cache. Will update the recency of the cache
+     * entry found.
+     *
+     * If the key is not found, get() will return `undefined`.
+     */
+    get(k, getOptions = {}) {
+        const { status = diagnostics_channel_js_1.metrics.hasSubscribers ? {} : undefined } = getOptions;
+        getOptions.status = status;
+        if (status) {
+            status.op = 'get';
+            status.key = k;
+            status.cache = this;
+        }
+        const result = this.#get(k, getOptions);
+        if (status) {
+            if (result !== undefined)
+                status.value = result;
+            if (diagnostics_channel_js_1.metrics.hasSubscribers)
+                diagnostics_channel_js_1.metrics.publish(status);
+        }
+        return result;
+    }
+    #get(k, getOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status, } = getOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.get = 'miss';
+            return undefined;
+        }
+        const value = this.#valList[index];
+        const fetching = this.#isBackgroundFetch(value);
+        if (status)
+            this.#statusTTL(status, index);
+        if (this.#isStale(index)) {
+            // delete only if not an in-flight background fetch
+            if (!fetching) {
+                if (!noDeleteOnStaleGet) {
+                    this.#delete(k, 'expire');
+                }
+                if (status)
+                    status.get = 'stale';
+                if (allowStale) {
+                    if (status)
+                        status.returnedStale = true;
+                    return value;
+                }
+                return undefined;
+            }
+            if (status)
+                status.get = 'stale-fetching';
+            if (allowStale && value.__staleWhileFetching !== undefined) {
+                if (status)
+                    status.returnedStale = true;
+                return value.__staleWhileFetching;
+            }
+            return undefined;
+        }
+        // not stale
+        if (status)
+            status.get = fetching ? 'fetching' : 'hit';
+        // if we're currently fetching it, we don't actually have it yet
+        // it's not stale, which means this isn't a staleWhileRefetching.
+        // If it's not stale, and fetching, AND has a __staleWhileFetching
+        // value, then that means the user fetched with {forceRefresh:true},
+        // so it's safe to return that value.
+        this.#moveToTail(index);
+        if (updateAgeOnGet) {
+            this.#updateItemAge(index);
+        }
+        return fetching ? value.__staleWhileFetching : value;
+    }
+    #connect(p, n) {
+        this.#prev[n] = p;
+        this.#next[p] = n;
+    }
+    #moveToTail(index) {
+        // if tail already, nothing to do
+        // if head, move head to next[index]
+        // else
+        //   move next[prev[index]] to next[index] (head has no prev)
+        //   move prev[next[index]] to prev[index]
+        // prev[index] = tail
+        // next[tail] = index
+        // tail = index
+        if (index !== this.#tail) {
+            if (index === this.#head) {
+                this.#head = this.#next[index];
+            }
+            else {
+                this.#connect(this.#prev[index], this.#next[index]);
+            }
+            this.#connect(this.#tail, index);
+            this.#tail = index;
+        }
+    }
+    /**
+     * Deletes a key out of the cache.
+     *
+     * Returns true if the key was deleted, false otherwise.
+     */
+    delete(k) {
+        return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
+        if (diagnostics_channel_js_1.metrics.hasSubscribers) {
+            diagnostics_channel_js_1.metrics.publish({
+                op: 'delete',
+                delete: reason,
+                key: k,
+                cache: this,
+            });
+        }
+        let deleted = false;
+        if (this.#size !== 0) {
+            const index = this.#keyMap.get(k);
+            if (index !== undefined) {
+                if (this.#autopurgeTimers?.[index]) {
+                    clearTimeout(this.#autopurgeTimers?.[index]);
+                    this.#autopurgeTimers[index] = undefined;
+                }
+                deleted = true;
+                if (this.#size === 1) {
+                    this.#clear(reason);
+                }
+                else {
+                    this.#removeItemSize(index);
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) {
+                        v.__abortController.abort(new Error('deleted'));
+                    }
+                    else if (this.#hasDispose || this.#hasDisposeAfter) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(v, k, reason);
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([v, k, reason]);
+                        }
+                    }
+                    this.#keyMap.delete(k);
+                    this.#keyList[index] = undefined;
+                    this.#valList[index] = undefined;
+                    if (index === this.#tail) {
+                        this.#tail = this.#prev[index];
+                    }
+                    else if (index === this.#head) {
+                        this.#head = this.#next[index];
+                    }
+                    else {
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
+                    }
+                    this.#size--;
+                    this.#free.push(index);
+                }
+            }
+        }
+        if (this.#hasDisposeAfter && this.#disposed?.length) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Clear the cache entirely, throwing away all values.
+     */
+    clear() {
+        return this.#clear('delete');
+    }
+    #clear(reason) {
+        for (const index of this.#rindexes({ allowStale: true })) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                v.__abortController.abort(new Error('deleted'));
+            }
+            else {
+                const k = this.#keyList[index];
+                if (this.#hasDispose) {
+                    this.#dispose?.(v, k, reason);
+                }
+                if (this.#hasDisposeAfter) {
+                    this.#disposed?.push([v, k, reason]);
+                }
+            }
+        }
+        this.#keyMap.clear();
+        void this.#valList.fill(undefined);
+        this.#keyList.fill(undefined);
+        if (this.#ttls && this.#starts) {
+            this.#ttls.fill(0);
+            this.#starts.fill(0);
+            for (const t of this.#autopurgeTimers ?? []) {
+                if (t !== undefined)
+                    clearTimeout(t);
+            }
+            this.#autopurgeTimers?.fill(undefined);
+        }
+        if (this.#sizes) {
+            this.#sizes.fill(0);
+        }
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free.length = 0;
+        this.#calculatedSize = 0;
+        this.#size = 0;
+        if (this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+    }
+}
+exports.LRUCache = LRUCache;
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.min.js b/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.min.js
new file mode 100644
index 00000000000000..a03fc771913873
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/node/index.min.js
@@ -0,0 +1,2 @@
+"use strict";var j=(c,t)=>()=>(t||c((t={exports:{}}).exports,t),t.exports);var I=j(O=>{"use strict";Object.defineProperty(O,"__esModule",{value:!0});O.tracing=O.metrics=void 0;var U=require("node:diagnostics_channel");O.metrics=(0,U.channel)("lru-cache:metrics");O.tracing=(0,U.tracingChannel)("lru-cache")});var P=j(D=>{"use strict";Object.defineProperty(D,"__esModule",{value:!0});D.defaultPerf=void 0;D.defaultPerf=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date});Object.defineProperty(exports,"__esModule",{value:!0});exports.LRUCache=void 0;var g=I(),N=P(),C=()=>g.metrics.hasSubscribers||g.tracing.hasSubscribers,k=new Set,G=typeof process=="object"&&process?process:{},V=(c,t,e,i)=>{typeof G.emitWarning=="function"?G.emitWarning(c,t,e,i):console.error(`[${e}] ${t}: ${c}`)},q=c=>!k.has(c);var T=c=>!!c&&c===Math.floor(c)&&c>0&&isFinite(c),H=c=>T(c)?c<=Math.pow(2,8)?Uint8Array:c<=Math.pow(2,16)?Uint16Array:c<=Math.pow(2,32)?Uint32Array:c<=Number.MAX_SAFE_INTEGER?W:null:null,W=class extends Array{constructor(t){super(t),this.fill(0)}},x=class c{heap;length;static#o=!1;static create(t){let e=H(t);if(!e)return[];c.#o=!0;let i=new c(t,e);return c.#o=!1,i}constructor(t,e){if(!c.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new e(t),this.length=0}push(t){this.heap[this.length++]=t}pop(){return this.heap[--this.length]}},L=class c{#o;#c;#m;#W;#S;#M;#j;#w;get perf(){return this.#w}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#_;#r;#y;#F;#d;#g;#T;#U;#f;#D;static unsafeExposeInternals(t){return{starts:t.#F,ttls:t.#d,autopurgeTimers:t.#g,sizes:t.#y,keyMap:t.#s,keyList:t.#i,valList:t.#t,next:t.#l,prev:t.#u,get head(){return t.#a},get tail(){return t.#h},free:t.#_,isBackgroundFetch:e=>t.#e(e),backgroundFetch:(e,i,s,n)=>t.#G(e,i,s,n),moveToTail:e=>t.#L(e),indexes:e=>t.#A(e),rindexes:e=>t.#z(e),isStale:e=>t.#p(e)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#j}get dispose(){return this.#m}get onInsert(){return this.#W}get disposeAfter(){return this.#S}constructor(t){let{max:e=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:_,noDisposeOnSet:y,noUpdateTTL:u,maxSize:p=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:S,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:w,allowStaleOnFetchRejection:m,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,backgroundFetchSize:M=1,perf:v}=t;if(this.backgroundFetchSize=M,v!==void 0&&typeof v?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#w=v??N.defaultPerf,e!==0&&!T(e))throw new TypeError("max option must be a nonnegative integer");let E=e?H(e):Array;if(!E)throw new Error("invalid max value: "+e);if(this.#o=e,this.#c=p,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(S!==void 0&&typeof S!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#j=S,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:e}).fill(void 0),this.#t=Array.from({length:e}).fill(void 0),this.#l=new E(e),this.#u=new E(e),this.#a=0,this.#h=0,this.#_=x.create(e),this.#n=0,this.#b=0,typeof o=="function"&&(this.#m=o),typeof d=="function"&&(this.#W=d),typeof _=="function"?(this.#S=_,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#m,this.#D=!!this.#W,this.#f=!!this.#S,this.noDisposeOnSet=!!y,this.noUpdateTTL=!!u,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!m,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!w,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let R="LRU_CACHE_UNBOUNDED";q(R)&&(k.add(R),V("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",R,c))}}getRemainingTTL(t){return this.#s.has(t)?1/0:0}#k(){let t=new W(this.#o),e=new W(this.#o);this.#d=t,this.#F=e;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#w.now())=>{e[h]=a!==0?o:0,t[h]=a,s(h,a)},this.#R=h=>{e[h]=t[h]!==0?this.#w.now():0,s(h,t[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#v(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#E=(h,a)=>{if(t[a]){let o=t[a],d=e[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let _=h.now-d;h.remainingTTL=o-_}};let n=0,r=()=>{let h=this.#w.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=t[a],d=e[a];if(!o||!d)return 1/0;let _=(n||r())-d;return o-_},this.#p=h=>{let a=e[h],o=t[h];return!!o&&!!a&&(n||r())-a>o}}#R=()=>{};#E=()=>{};#H=()=>{};#p=()=>!1;#X(){let t=new W(this.#o);this.#b=0,this.#y=t,this.#C=e=>{this.#b-=t[e],t[e]=0},this.#N=(e,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,e),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#I=(e,i,s)=>{if(t[e]=i,this.#c){let n=this.#c-t[e];for(;this.#b>n;)this.#P(!0)}this.#b+=t[e],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#C=t=>{};#I=(t,e,i)=>{};#N=(t,e,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#h;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#a);)e=this.#u[e]}*#z({allowStale:t=this.allowStale}={}){if(this.#n)for(let e=this.#a;this.#V(e)&&((t||!this.#p(e))&&(yield e),e!==this.#h);)e=this.#l[e]}#V(t){return t!==void 0&&this.#s.get(this.#i[t])===t}*entries(){for(let t of this.#A())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*rentries(){for(let t of this.#z())this.#t[t]!==void 0&&this.#i[t]!==void 0&&!this.#e(this.#t[t])&&(yield[this.#i[t],this.#t[t]])}*keys(){for(let t of this.#A()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*rkeys(){for(let t of this.#z()){let e=this.#i[t];e!==void 0&&!this.#e(this.#t[t])&&(yield e)}}*values(){for(let t of this.#A())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}*rvalues(){for(let t of this.#z())this.#t[t]!==void 0&&!this.#e(this.#t[t])&&(yield this.#t[t])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(t,e={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&t(n,this.#i[i],this))return this.#x(this.#i[i],e)}}forEach(t,e=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}rforEach(t,e=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&t.call(e,n,this.#i[i],this)}}purgeStale(){let t=!1;for(let e of this.#z({allowStale:!0}))this.#p(e)&&(this.#v(this.#i[e],"expire"),t=!0);return t}info(t){let e=this.#s.get(t);if(e===void 0)return;let i=this.#t[e],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[e],h=this.#F[e];if(r&&h){let a=r-(this.#w.now()-h);n.ttl=a,n.start=Date.now()}}return this.#y&&(n.size=this.#y[e]),n}dump(){let t=[];for(let e of this.#A({allowStale:!0})){let i=this.#i[e],s=this.#t[e],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[e];let h=this.#w.now()-this.#F[e];r.start=Math.floor(Date.now()-h)}this.#y&&(r.size=this.#y[e]),t.unshift([i,r])}return t}load(t){this.clear();for(let[e,i]of t){if(i.start){let s=Date.now()-i.start;i.start=this.#w.now()-s}this.#O(e,i.value,i)}}set(t,e,i={}){let{status:s=g.metrics.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=t,e!==void 0&&(s.value=e),s.cache=this);let n=this.#O(t,e,i);return s&&g.metrics.hasSubscribers&&g.metrics.publish(s),n}#O(t,e,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(e);if(e===void 0)return o&&(o.set="deleted"),this.delete(t),this;let{noUpdateTTL:_=this.noUpdateTTL}=i;o&&!d&&(o.value=e);let y=this.#N(t,e,i.size||0,a,o);if(this.maxEntrySize&&y>this.maxEntrySize)return this.#v(t,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let u=this.#n===0?void 0:this.#s.get(t);if(u===void 0)u=this.#n===0?this.#h:this.#_.length!==0?this.#_.pop():this.#n===this.#o?this.#P(!1):this.#n,this.#i[u]=t,this.#t[u]=e,this.#s.set(t,u),this.#l[this.#h]=u,this.#u[u]=this.#h,this.#h=u,this.#n++,this.#I(u,y,o),o&&(o.set="add"),_=!1,this.#D&&!d&&this.#W?.(e,t,"add");else{this.#L(u);let p=this.#t[u];if(e!==p){if(!h)if(this.#e(p)){p!==s&&p.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=p;f!==void 0&&f!==e&&(this.#T&&this.#m?.(f,t,"set"),this.#f&&this.#r?.push([f,t,"set"]))}else this.#T&&this.#m?.(p,t,"set"),this.#f&&this.#r?.push([p,t,"set"]);if(this.#C(u),this.#I(u,y,o),this.#t[u]=e,!d){let f=p&&this.#e(p)?p.__staleWhileFetching:p,b=f===void 0?"add":e!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#D&&this.onInsert?.(e,t,b)}}else d||(o&&(o.set="update"),this.#D&&this.onInsert?.(e,t,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(_||this.#H(u,n,r),o&&this.#E(o,u)),!h&&this.#f&&this.#r){let p=this.#r,f;for(;f=p?.shift();)this.#S?.(...f)}return this}pop(){try{for(;this.#n;){let t=this.#t[this.#a];if(this.#P(!0),this.#e(t)){if(t.__staleWhileFetching)return t.__staleWhileFetching}else if(t!==void 0)return t}}finally{if(this.#f&&this.#r){let t=this.#r,e;for(;e=t?.shift();)this.#S?.(...e)}}}#P(t){let e=this.#a,i=this.#i[e],s=this.#t[e],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#m?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#C(e),this.#g?.[e]&&(clearTimeout(this.#g[e]),this.#g[e]=void 0),t&&(this.#i[e]=void 0,this.#t[e]=void 0,this.#_.push(e)),this.#n===1?(this.#a=this.#h=0,this.#_.length=0):this.#a=this.#l[e],this.#s.delete(i),this.#n--,e}has(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="has",i.key=t,i.cache=this);let s=this.#Y(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Y(t,e={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=e,n=this.#s.get(t);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#R(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(t,e={}){let{status:i=C()?{}:void 0}=e;i&&(i.op="peek",i.key=t,i.cache=this),e.status=i;let s=this.#J(t,e);return g.metrics.hasSubscribers&&g.metrics.publish(i),s}#J(t,e){let{status:i,allowStale:s=this.allowStale}=e,n=this.#s.get(t);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#G(t,e,i,s){let n=e===void 0?void 0:this.#t[e];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,S=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,S&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!S&&!b)return _(r.signal.reason,F);let w=u,m=this.#t[e];return(m===u||m===void 0&&S&&b)&&(f===void 0?w.__staleWhileFetching!==void 0?this.#t[e]=w.__staleWhileFetching:this.#v(t,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(t,f,a.options,w))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),_(f,!1)),_=(f,b)=>{let{aborted:l}=r.signal,S=l&&i.allowStaleOnFetchAbort,F=S||i.allowStaleOnFetchRejection,w=F||i.noDeleteOnFetchRejection,m=u;if(this.#t[e]===u&&(!w||!b&&m.__staleWhileFetching===void 0?this.#v(t,"fetch"):S||(this.#t[e]=m.__staleWhileFetching)),F)return i.status&&m.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),m.__staleWhileFetching;if(m.__returned===m)throw f},y=(f,b)=>{let l=this.#M?.(t,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=S=>o(S,!0)))}),l&&l instanceof Promise?l.then(S=>f(S===void 0?void 0:S),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let u=new Promise(y).then(o,d),p=Object.assign(u,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return e===void 0?(this.#O(t,p,{...a.options,status:void 0}),e=this.#s.get(t)):this.#t[e]=p,p}#e(t){if(!this.#U)return!1;let e=t;return!!e&&e instanceof Promise&&e.hasOwnProperty("__staleWhileFetching")&&e.__abortController instanceof AbortController}fetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=C()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#q(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#q(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:_=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:y=this.allowStaleOnFetchRejection,ignoreFetchAbort:u=this.ignoreFetchAbort,allowStaleOnFetchAbort:p=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:S}=e;if(l&&(l.op="fetch",l.key=t,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#x(t,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:_,allowStaleOnFetchRejection:y,allowStaleOnFetchAbort:p,ignoreFetchAbort:u,status:l,signal:S},w=this.#s.get(t);if(w===void 0){l&&(l.fetch="miss");let m=this.#G(t,w,F,f);return m.__returned=m}else{let m=this.#t[w];if(this.#e(m)){let E=i&&m.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",E&&(l.returnedStale=!0)),E?m.__staleWhileFetching:m.__returned=m}let A=this.#p(w);if(!b&&!A)return l&&(l.fetch="hit"),this.#L(w),s&&this.#R(w),l&&this.#E(l,w),m;let z=this.#G(t,w,F,f),v=z.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",v&&A&&(l.returnedStale=!0)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(t,e={}){let i=g.tracing.hasSubscribers,{status:s=C()?{}:void 0}=e;e.status=s,s&&e.context&&(s.context=e.context);let n=this.#K(t,e);return s&&i&&(s.trace=!0,g.tracing.tracePromise(()=>n,s).catch(()=>{})),n}async#K(t,e={}){let i=await this.#q(t,e);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="memo",i.key=t,e.context&&(i.context=e.context),i.cache=this);let s=this.#Q(t,e);return i&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i),s}#Q(t,e={}){let i=this.#j;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=e;n&&r&&(n.forceRefresh=!0);let a=this.#x(t,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(t,a,{options:h,context:s});return n&&(n.value=d),this.#O(t,d,h),d}get(t,e={}){let{status:i=g.metrics.hasSubscribers?{}:void 0}=e;e.status=i,i&&(i.op="get",i.key=t,i.cache=this);let s=this.#x(t,e);return i&&(s!==void 0&&(i.value=s),g.metrics.hasSubscribers&&g.metrics.publish(i)),s}#x(t,e={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=e,h=this.#s.get(t);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#E(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#v(t,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#R(h),o?a.__staleWhileFetching:a)}#B(t,e){this.#u[e]=t,this.#l[t]=e}#L(t){t!==this.#h&&(t===this.#a?this.#a=this.#l[t]:this.#B(this.#u[t],this.#l[t]),this.#B(this.#h,t),this.#h=t)}delete(t){return this.#v(t,"delete")}#v(t,e){g.metrics.hasSubscribers&&g.metrics.publish({op:"delete",delete:e,key:t,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(t);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#$(e);else{this.#C(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#m?.(n,t,e),this.#f&&this.#r?.push([n,t,e])),this.#s.delete(t),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#_.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#$("delete")}#$(t){for(let e of this.#z({allowStale:!0})){let i=this.#t[e];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[e];this.#T&&this.#m?.(i,s,t),this.#f&&this.#r?.push([i,s,t])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let e of this.#g??[])e!==void 0&&clearTimeout(e);this.#g?.fill(void 0)}if(this.#y&&this.#y.fill(0),this.#a=0,this.#h=0,this.#_.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let e=this.#r,i;for(;i=e?.shift();)this.#S?.(...i)}}};exports.LRUCache=L;
+//# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/node/perf.js b/deps/npm/node_modules/lru-cache/dist/commonjs/node/perf.js
new file mode 100644
index 00000000000000..bd4c80f461d6c1
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/node/perf.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPerf = void 0;
+exports.defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/commonjs/perf.js b/deps/npm/node_modules/lru-cache/dist/commonjs/perf.js
new file mode 100644
index 00000000000000..bd4c80f461d6c1
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/commonjs/perf.js
@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPerf = void 0;
+exports.defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/browser/diagnostics-channel.js b/deps/npm/node_modules/lru-cache/dist/esm/browser/diagnostics-channel.js
index 08ec4d4d484b44..37524f355f050c 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/browser/diagnostics-channel.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/browser/diagnostics-channel.js
@@ -1,4 +1,4 @@
 const dummy = { hasSubscribers: false };
 export const metrics = dummy;
 export const tracing = dummy;
-//# sourceMappingURL=diagnostics-channel-browser.mjs.map
\ No newline at end of file
+//# sourceMappingURL=diagnostics-channel-browser.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/browser/index.js b/deps/npm/node_modules/lru-cache/dist/esm/browser/index.js
index 11c8cd8dfbf5cf..114a4e9908390f 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/browser/index.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/browser/index.js
@@ -2,12 +2,8 @@
  * @module LRUCache
  */
 import { metrics, tracing } from './diagnostics-channel.js';
+import { defaultPerf } from './perf.js';
 const hasSubscribers = () => metrics.hasSubscribers || tracing.hasSubscribers;
-const defaultPerf = (typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function') ?
-    performance
-    : Date;
 const warned = new Set();
 /* c8 ignore start */
 const PROCESS = (typeof process === 'object' && !!process ?
@@ -49,7 +45,9 @@ class ZeroArray extends Array {
     }
 }
 class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
     heap;
+    /* c8 ignore stop */
     length;
     // private constructor
     static #constructing = false;
@@ -169,6 +167,8 @@ export class LRUCache {
      * {@link LRUCache.OptionsBase.ignoreFetchAbort}
      */
     ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
     // computed properties
     #size;
     #calculatedSize;
@@ -279,7 +279,8 @@ export class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
         if (perf !== undefined) {
             if (typeof perf?.now !== 'function') {
                 throw new TypeError('perf option must have a now() method if specified');
@@ -507,12 +508,15 @@ export class LRUCache {
             sizes[index] = 0;
         };
         this.#requireSize = (k, v, size, sizeCalculation) => {
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
             if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
                 if (sizeCalculation) {
                     if (typeof sizeCalculation !== 'function') {
                         throw new TypeError('sizeCalculation must be a function');
@@ -879,6 +883,7 @@ export class LRUCache {
             status.key = k;
             if (v !== undefined)
                 status.value = v;
+            status.cache = this;
         }
         const result = this.#set(k, v, setOptions);
         if (status && metrics.hasSubscribers) {
@@ -886,8 +891,9 @@ export class LRUCache {
         }
         return result;
     }
-    #set(k, v, setOptions = {}) {
+    #set(k, v, setOptions, bf) {
         const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
         if (v === undefined) {
             if (status)
                 status.set = 'deleted';
@@ -895,7 +901,7 @@ export class LRUCache {
             return this;
         }
         let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        if (status && !this.#isBackgroundFetch(v))
+        if (status && !isBF)
             status.value = v;
         const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
         // if the item doesn't fit, don't do anything
@@ -927,52 +933,68 @@ export class LRUCache {
             if (status)
                 status.set = 'add';
             noUpdateTTL = false;
-            if (this.#hasOnInsert) {
+            if (this.#hasOnInsert && !isBF) {
                 this.#onInsert?.(v, k, 'add');
             }
         }
         else {
             // update
+            // might be updating a background fetch!
             this.#moveToTail(index);
             const oldVal = this.#valList[index];
             if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                    const { __staleWhileFetching: s } = oldVal;
-                    if (s !== undefined && !noDisposeOnSet) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
                         if (this.#hasDispose) {
-                            this.#dispose?.(s, k, 'set');
+                            this.#dispose?.(oldVal, k, 'set');
                         }
                         if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([s, k, 'set']);
+                            this.#disposed?.push([oldVal, k, 'set']);
                         }
                     }
                 }
-                else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([oldVal, k, 'set']);
-                    }
-                }
                 this.#removeItemSize(index);
                 this.#addItemSize(index, size, status);
                 this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
+                if (!isBF) {
                     const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
                         oldVal.__staleWhileFetching
                         : oldVal;
-                    if (oldValue !== undefined)
-                        status.oldValue = oldValue;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
                 }
             }
-            else if (status) {
-                status.set = 'update';
-            }
-            if (this.#hasOnInsert) {
-                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
             }
         }
         if (ttl !== 0 && !this.#ttls) {
@@ -1027,15 +1049,18 @@ export class LRUCache {
         const head = this.#head;
         const k = this.#keyList[head];
         const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
             v.__abortController.abort(new Error('evicted'));
         }
-        else if (this.#hasDispose || this.#hasDisposeAfter) {
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
             if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
+                this.#dispose?.(oldValue, k, 'evict');
             }
             if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, 'evict']);
+                this.#disposed?.push([oldValue, k, 'evict']);
             }
         }
         this.#removeItemSize(head);
@@ -1082,6 +1107,7 @@ export class LRUCache {
         if (status) {
             status.op = 'has';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#has(k, hasOptions);
         if (metrics.hasSubscribers)
@@ -1129,6 +1155,7 @@ export class LRUCache {
         if (status) {
             status.op = 'peek';
             status.key = k;
+            status.cache = this;
         }
         peekOptions.status = status;
         const result = this.#peek(k, peekOptions);
@@ -1211,7 +1238,7 @@ export class LRUCache {
                 else {
                     if (options.status)
                         options.status.fetchUpdated = true;
-                    this.#set(k, v, fetchOpts.options);
+                    this.#set(k, v, fetchOpts.options, bf);
                 }
             }
             return v;
@@ -1257,9 +1284,6 @@ export class LRUCache {
         };
         const pcall = (res, rej) => {
             const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then(v => res(v === undefined ? undefined : v), rej);
-            }
             // ignored, we go until we finish, regardless.
             // defer check until we are actually aborting,
             // so fetchMethod can override.
@@ -1272,6 +1296,12 @@ export class LRUCache {
                     }
                 }
             });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
         };
         if (options.status)
             options.status.fetchDispatched = true;
@@ -1287,6 +1317,10 @@ export class LRUCache {
             index = this.#keyMap.get(k);
         }
         else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
             this.#valList[index] = bf;
         }
         return bf;
@@ -1308,11 +1342,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#fetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1329,6 +1361,7 @@ export class LRUCache {
             status.key = k;
             if (forceRefresh)
                 status.forceRefresh = true;
+            status.cache = this;
         }
         if (!this.#hasFetchMethod) {
             if (status)
@@ -1410,11 +1443,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#forceFetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1433,6 +1464,7 @@ export class LRUCache {
             if (memoOptions.context) {
                 status.context = memoOptions.context;
             }
+            status.cache = this;
         }
         const result = this.#memo(k, memoOptions);
         if (status)
@@ -1479,6 +1511,7 @@ export class LRUCache {
         if (status) {
             status.op = 'get';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#get(k, getOptions);
         if (status) {
@@ -1577,6 +1610,7 @@ export class LRUCache {
                 op: 'delete',
                 delete: reason,
                 key: k,
+                cache: this,
             });
         }
         let deleted = false;
@@ -1657,7 +1691,7 @@ export class LRUCache {
             }
         }
         this.#keyMap.clear();
-        this.#valList.fill(undefined);
+        void this.#valList.fill(undefined);
         this.#keyList.fill(undefined);
         if (this.#ttls && this.#starts) {
             this.#ttls.fill(0);
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/browser/index.min.js b/deps/npm/node_modules/lru-cache/dist/esm/browser/index.min.js
index 50dd21a570e15f..86618ad212c13e 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/browser/index.min.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/browser/index.min.js
@@ -1,2 +1,2 @@
-var C={hasSubscribers:!1},S=C,W=C;var D=()=>S.hasSubscribers||W.hasSubscribers,I=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date,U=new Set,L=typeof process=="object"&&process?process:{},G=(u,e,t,i)=>{typeof L.emitWarning=="function"?L.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`)},P=u=>!U.has(u),V=Symbol("type"),F=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),j=u=>F(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class u{heap;length;static#o=!1;static create(e){let t=j(e);if(!t)return[];u.#o=!0;let i=new u(e,t);return u.#o=!1,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},M=class u{#o;#u;#w;#D;#S;#M;#U;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;#n;#b;#s;#i;#t;#a;#c;#l;#h;#y;#r;#_;#F;#d;#g;#T;#W;#f;#j;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#a,prev:e.#c,get head(){return e.#l},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#u}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#U}get dispose(){return this.#w}get onInsert(){return this.#D}get disposeAfter(){return this.#S}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:o,updateAgeOnHas:r,allowStale:h,dispose:l,onInsert:c,disposeAfter:f,noDisposeOnSet:g,noUpdateTTL:p,maxSize:T=0,maxEntrySize:w=0,sizeCalculation:y,fetchMethod:a,memoMethod:m,noDeleteOnFetchRejection:_,noDeleteOnStaleGet:b,allowStaleOnFetchRejection:d,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,perf:x}=e;if(x!==void 0&&typeof x?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=x??I,t!==0&&!F(t))throw new TypeError("max option must be a nonnegative integer");let v=t?j(t):Array;if(!v)throw new Error("invalid max value: "+t);if(this.#o=t,this.#u=T,this.maxEntrySize=w||this.#u,this.sizeCalculation=y,this.sizeCalculation){if(!this.#u&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(m!==void 0&&typeof m!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#U=m,a!==void 0&&typeof a!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=a,this.#W=!!a,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#a=new v(t),this.#c=new v(t),this.#l=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof l=="function"&&(this.#w=l),typeof c=="function"&&(this.#D=c),typeof f=="function"?(this.#S=f,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#w,this.#j=!!this.#D,this.#f=!!this.#S,this.noDisposeOnSet=!!g,this.noUpdateTTL=!!p,this.noDeleteOnFetchRejection=!!_,this.allowStaleOnFetchRejection=!!d,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#u!==0&&!F(this.#u))throw new TypeError("maxSize must be a positive integer if specified");if(!F(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!h,this.noDeleteOnStaleGet=!!b,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!r,this.ttlResolution=F(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!F(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#H()}if(this.#o===0&&this.ttl===0&&this.#u===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#u){let E="LRU_CACHE_UNBOUNDED";P(E)&&(U.add(E),G("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",E,u))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#H(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#N=(r,h,l=this.#m.now())=>{t[r]=h!==0?l:0,e[r]=h,s(r,h)},this.#x=r=>{t[r]=e[r]!==0?this.#m.now():0,s(r,e[r])};let s=this.ttlAutopurge?(r,h)=>{if(i?.[r]&&(clearTimeout(i[r]),i[r]=void 0),h&&h!==0&&i){let l=setTimeout(()=>{this.#p(r)&&this.#v(this.#i[r],"expire")},h+1);l.unref&&l.unref(),i[r]=l}}:()=>{};this.#E=(r,h)=>{if(e[h]){let l=e[h],c=t[h];if(!l||!c)return;r.ttl=l,r.start=c,r.now=n||o();let f=r.now-c;r.remainingTTL=l-f}};let n=0,o=()=>{let r=this.#m.now();if(this.ttlResolution>0){n=r;let h=setTimeout(()=>n=0,this.ttlResolution);h.unref&&h.unref()}return r};this.getRemainingTTL=r=>{let h=this.#s.get(r);if(h===void 0)return 0;let l=e[h],c=t[h];if(!l||!c)return 1/0;let f=(n||o())-c;return l-f},this.#p=r=>{let h=t[r],l=e[r];return!!l&&!!h&&(n||o())-h>l}}#x=()=>{};#E=()=>{};#N=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#k=(t,i,s,n)=>{if(this.#e(i))return 0;if(!F(s))if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!F(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");return s},this.#I=(t,i,s)=>{if(e[t]=i,this.#u){let n=this.#u-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#I=(e,t,i)=>{};#k=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#l);)t=this.#c[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#l;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#a[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#v(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let o=this.#d[t],r=this.#F[t];if(o&&r){let h=o-(this.#m.now()-r);n.ttl=h,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let o={value:n};if(this.#d&&this.#F){o.ttl=this.#d[t];let r=this.#m.now()-this.#F[t];o.start=Math.floor(Date.now()-r)}this.#_&&(o.size=this.#_[t]),e.unshift([i,o])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#O(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t));let n=this.#O(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#O(e,t,i={}){let{ttl:s=this.ttl,start:n,noDisposeOnSet:o=this.noDisposeOnSet,sizeCalculation:r=this.sizeCalculation,status:h}=i;if(t===void 0)return h&&(h.set="deleted"),this.delete(e),this;let{noUpdateTTL:l=this.noUpdateTTL}=i;h&&!this.#e(t)&&(h.value=t);let c=this.#k(e,t,i.size||0,r,h);if(this.maxEntrySize&&c>this.maxEntrySize)return this.#v(e,"set"),h&&(h.set="miss",h.maxEntrySizeExceeded=!0),this;let f=this.#n===0?void 0:this.#s.get(e);if(f===void 0)f=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[f]=e,this.#t[f]=t,this.#s.set(e,f),this.#a[this.#h]=f,this.#c[f]=this.#h,this.#h=f,this.#n++,this.#I(f,c,h),h&&(h.set="add"),l=!1,this.#j&&this.#D?.(t,e,"add");else{this.#L(f);let g=this.#t[f];if(t!==g){if(this.#W&&this.#e(g)){g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:p}=g;p!==void 0&&!o&&(this.#T&&this.#w?.(p,e,"set"),this.#f&&this.#r?.push([p,e,"set"]))}else o||(this.#T&&this.#w?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]));if(this.#R(f),this.#I(f,c,h),this.#t[f]=t,h){h.set="replace";let p=g&&this.#e(g)?g.__staleWhileFetching:g;p!==void 0&&(h.oldValue=p)}}else h&&(h.set="update");this.#j&&this.onInsert?.(t,e,t===g?"update":"replace")}if(s!==0&&!this.#d&&this.#H(),this.#d&&(l||this.#N(f,s,n),h&&this.#E(h,f)),!o&&this.#f&&this.#r){let g=this.#r,p;for(;p=g?.shift();)this.#S?.(...p)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#l];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#S?.(...t)}}}#G(e){let t=this.#l,i=this.#i[t],s=this.#t[t];return this.#W&&this.#e(s)?s.__abortController.abort(new Error("evicted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(s,i,"evict"),this.#f&&this.#r?.push([s,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#l=this.#h=0,this.#y.length=0):this.#l=this.#a[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let o=this.#t[n];if(this.#e(o)&&o.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#x(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let o=this.#t[n],r=this.#e(o)?o.__staleWhileFetching:o;return i&&(r!==void 0?(i.peek="hit",i.value=r):i.peek="miss"),r}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let o=new AbortController,{signal:r}=i;r?.addEventListener("abort",()=>o.abort(r.reason),{signal:o.signal});let h={signal:o.signal,options:i,context:s},l=(w,y=!1)=>{let{aborted:a}=o.signal,m=i.ignoreFetchAbort&&w!==void 0,_=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&w!==void 0);if(i.status&&(a&&!y?(i.status.fetchAborted=!0,i.status.fetchError=o.signal.reason,m&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),a&&!m&&!y)return f(o.signal.reason,_);let b=p,d=this.#t[t];return(d===p||d===void 0&&m&&y)&&(w===void 0?b.__staleWhileFetching!==void 0?this.#t[t]=b.__staleWhileFetching:this.#v(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(e,w,h.options))),w},c=w=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=w),f(w,!1)),f=(w,y)=>{let{aborted:a}=o.signal,m=a&&i.allowStaleOnFetchAbort,_=m||i.allowStaleOnFetchRejection,b=_||i.noDeleteOnFetchRejection,d=p;if(this.#t[t]===p&&(!b||!y&&d.__staleWhileFetching===void 0?this.#v(e,"fetch"):m||(this.#t[t]=d.__staleWhileFetching)),_)return i.status&&d.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),d.__staleWhileFetching;if(d.__returned===d)throw w},g=(w,y)=>{let a=this.#M?.(e,n,h);a&&a instanceof Promise&&a.then(m=>w(m===void 0?void 0:m),y),o.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(w(void 0),i.allowStaleOnFetchAbort&&(w=m=>l(m,!0)))})};i.status&&(i.status.fetchDispatched=!0);let p=new Promise(g).then(l,c),T=Object.assign(p,{__abortController:o,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#O(e,T,{...h.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=T,T}#e(e){if(!this.#W)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&D()&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:o=this.ttl,noDisposeOnSet:r=this.noDisposeOnSet,size:h=0,sizeCalculation:l=this.sizeCalculation,noUpdateTTL:c=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:g=this.allowStaleOnFetchRejection,ignoreFetchAbort:p=this.ignoreFetchAbort,allowStaleOnFetchAbort:T=this.allowStaleOnFetchAbort,context:w,forceRefresh:y=!1,status:a,signal:m}=t;if(a&&(a.op="fetch",a.key=e,y&&(a.forceRefresh=!0)),!this.#W)return a&&(a.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:a});let _={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:o,noDisposeOnSet:r,size:h,sizeCalculation:l,noUpdateTTL:c,noDeleteOnFetchRejection:f,allowStaleOnFetchRejection:g,allowStaleOnFetchAbort:T,ignoreFetchAbort:p,status:a,signal:m},b=this.#s.get(e);if(b===void 0){a&&(a.fetch="miss");let d=this.#P(e,b,_,w);return d.__returned=d}else{let d=this.#t[b];if(this.#e(d)){let E=i&&d.__staleWhileFetching!==void 0;return a&&(a.fetch="inflight",E&&(a.returnedStale=!0)),E?d.__staleWhileFetching:d.__returned=d}let A=this.#p(b);if(!y&&!A)return a&&(a.fetch="hit"),this.#L(b),s&&this.#x(b),a&&this.#E(a,b),d;let z=this.#P(e,b,_,w),v=z.__staleWhileFetching!==void 0&&i;return a&&(a.fetch=A?"stale":"refresh",v&&A&&(a.returnedStale=!0)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&D()&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context));let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#U;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:o,...r}=t;n&&o&&(n.forceRefresh=!0);let h=this.#C(e,r),l=o||h===void 0;if(n&&(n.memo=l?"miss":"hit",l||(n.value=h)),!l)return h;let c=i(e,h,{options:r,context:s});return n&&(n.value=c),this.#O(e,c,r),c}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:o}=t,r=this.#s.get(e);if(r===void 0){o&&(o.get="miss");return}let h=this.#t[r],l=this.#e(h);return o&&this.#E(o,r),this.#p(r)?l?(o&&(o.get="stale-fetching"),i&&h.__staleWhileFetching!==void 0?(o&&(o.returnedStale=!0),h.__staleWhileFetching):void 0):(n||this.#v(e,"expire"),o&&(o.get="stale"),i?(o&&(o.returnedStale=!0),h):void 0):(o&&(o.get=l?"fetching":"hit"),this.#L(r),s&&this.#x(r),l?h.__staleWhileFetching:h)}#$(e,t){this.#c[t]=e,this.#a[e]=t}#L(e){e!==this.#h&&(e===this.#l?this.#l=this.#a[e]:this.#$(this.#c[e],this.#a[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#v(e,"delete")}#v(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#c[s];else if(s===this.#l)this.#l=this.#a[s];else{let o=this.#c[s];this.#a[o]=this.#a[s];let r=this.#a[s];this.#c[r]=this.#c[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#w?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#l=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#S?.(...i)}}};export{M as LRUCache};
+var L={hasSubscribers:!1},S=L,W=L;var M=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date;var D=()=>S.hasSubscribers||W.hasSubscribers,j=new Set,I=typeof process=="object"&&process?process:{},P=(u,e,t,i)=>{typeof I.emitWarning=="function"?I.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`)},k=u=>!j.has(u);var T=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),G=u=>T(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class u{heap;length;static#o=!1;static create(e){let t=G(e);if(!t)return[];u.#o=!0;let i=new u(e,t);return u.#o=!1,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},U=class u{#o;#c;#S;#O;#w;#M;#I;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#U;#f;#x;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#l,prev:e.#u,get head(){return e.#a},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#I}get dispose(){return this.#S}get onInsert(){return this.#O}get disposeAfter(){return this.#w}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:y,noDisposeOnSet:_,noUpdateTTL:c,maxSize:g=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:w,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:m,allowStaleOnFetchRejection:p,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,backgroundFetchSize:C=1,perf:E}=e;if(this.backgroundFetchSize=C,E!==void 0&&typeof E?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=E??M,t!==0&&!T(t))throw new TypeError("max option must be a nonnegative integer");let v=t?G(t):Array;if(!v)throw new Error("invalid max value: "+t);if(this.#o=t,this.#c=g,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(w!==void 0&&typeof w!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#I=w,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#l=new v(t),this.#u=new v(t),this.#a=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof o=="function"&&(this.#S=o),typeof d=="function"&&(this.#O=d),typeof y=="function"?(this.#w=y,this.#r=[]):(this.#w=void 0,this.#r=void 0),this.#T=!!this.#S,this.#x=!!this.#O,this.#f=!!this.#w,this.noDisposeOnSet=!!_,this.noUpdateTTL=!!c,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!p,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!m,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let x="LRU_CACHE_UNBOUNDED";k(x)&&(j.add(x),P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",x,u))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#k(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#m.now())=>{t[h]=a!==0?o:0,e[h]=a,s(h,a)},this.#D=h=>{t[h]=e[h]!==0?this.#m.now():0,s(h,e[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#E(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#v=(h,a)=>{if(e[a]){let o=e[a],d=t[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let y=h.now-d;h.remainingTTL=o-y}};let n=0,r=()=>{let h=this.#m.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=e[a],d=t[a];if(!o||!d)return 1/0;let y=(n||r())-d;return o-y},this.#p=h=>{let a=t[h],o=e[h];return!!o&&!!a&&(n||r())-a>o}}#D=()=>{};#v=()=>{};#H=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#N=(t,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#j=(t,i,s)=>{if(e[t]=i,this.#c){let n=this.#c-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#j=(e,t,i)=>{};#N=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#a);)t=this.#u[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#a;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#l[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#E(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[t],h=this.#F[t];if(r&&h){let a=r-(this.#m.now()-h);n.ttl=a,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[t];let h=this.#m.now()-this.#F[t];r.start=Math.floor(Date.now()-h)}this.#_&&(r.size=this.#_[t]),e.unshift([i,r])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#W(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t),s.cache=this);let n=this.#W(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#W(e,t,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(t);if(t===void 0)return o&&(o.set="deleted"),this.delete(e),this;let{noUpdateTTL:y=this.noUpdateTTL}=i;o&&!d&&(o.value=t);let _=this.#N(e,t,i.size||0,a,o);if(this.maxEntrySize&&_>this.maxEntrySize)return this.#E(e,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let c=this.#n===0?void 0:this.#s.get(e);if(c===void 0)c=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[c]=e,this.#t[c]=t,this.#s.set(e,c),this.#l[this.#h]=c,this.#u[c]=this.#h,this.#h=c,this.#n++,this.#j(c,_,o),o&&(o.set="add"),y=!1,this.#x&&!d&&this.#O?.(t,e,"add");else{this.#L(c);let g=this.#t[c];if(t!==g){if(!h)if(this.#e(g)){g!==s&&g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=g;f!==void 0&&f!==t&&(this.#T&&this.#S?.(f,e,"set"),this.#f&&this.#r?.push([f,e,"set"]))}else this.#T&&this.#S?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]);if(this.#R(c),this.#j(c,_,o),this.#t[c]=t,!d){let f=g&&this.#e(g)?g.__staleWhileFetching:g,b=f===void 0?"add":t!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#x&&this.onInsert?.(t,e,b)}}else d||(o&&(o.set="update"),this.#x&&this.onInsert?.(t,e,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(y||this.#H(c,n,r),o&&this.#v(o,c)),!h&&this.#f&&this.#r){let g=this.#r,f;for(;f=g?.shift();)this.#w?.(...f)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#a];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#w?.(...t)}}}#G(e){let t=this.#a,i=this.#i[t],s=this.#t[t],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#S?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e,i.cache=this);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#v(s,n));else return i&&this.#D(n),s&&(s.has="hit",this.#v(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e,i.cache=this),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,w=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,w&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!w&&!b)return y(r.signal.reason,F);let m=c,p=this.#t[t];return(p===c||p===void 0&&w&&b)&&(f===void 0?m.__staleWhileFetching!==void 0?this.#t[t]=m.__staleWhileFetching:this.#E(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#W(e,f,a.options,m))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),y(f,!1)),y=(f,b)=>{let{aborted:l}=r.signal,w=l&&i.allowStaleOnFetchAbort,F=w||i.allowStaleOnFetchRejection,m=F||i.noDeleteOnFetchRejection,p=c;if(this.#t[t]===c&&(!m||!b&&p.__staleWhileFetching===void 0?this.#E(e,"fetch"):w||(this.#t[t]=p.__staleWhileFetching)),F)return i.status&&p.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),p.__staleWhileFetching;if(p.__returned===p)throw f},_=(f,b)=>{let l=this.#M?.(e,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=w=>o(w,!0)))}),l&&l instanceof Promise?l.then(w=>f(w===void 0?void 0:w),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let c=new Promise(_).then(o,d),g=Object.assign(c,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#W(e,g,{...a.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=g,g}#e(e){if(!this.#U)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:y=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:_=this.allowStaleOnFetchRejection,ignoreFetchAbort:c=this.ignoreFetchAbort,allowStaleOnFetchAbort:g=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:w}=t;if(l&&(l.op="fetch",l.key=e,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:y,allowStaleOnFetchRejection:_,allowStaleOnFetchAbort:g,ignoreFetchAbort:c,status:l,signal:w},m=this.#s.get(e);if(m===void 0){l&&(l.fetch="miss");let p=this.#P(e,m,F,f);return p.__returned=p}else{let p=this.#t[m];if(this.#e(p)){let v=i&&p.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",v&&(l.returnedStale=!0)),v?p.__staleWhileFetching:p.__returned=p}let A=this.#p(m);if(!b&&!A)return l&&(l.fetch="hit"),this.#L(m),s&&this.#D(m),l&&this.#v(l,m),p;let z=this.#P(e,m,F,f),E=z.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",E&&A&&(l.returnedStale=!0)),E?z.__staleWhileFetching:z.__returned=z}}forceFetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context),i.cache=this);let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#I;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=t;n&&r&&(n.forceRefresh=!0);let a=this.#C(e,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(e,a,{options:h,context:s});return n&&(n.value=d),this.#W(e,d,h),d}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e,i.cache=this);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=t,h=this.#s.get(e);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#v(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#E(e,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#D(h),o?a.__staleWhileFetching:a)}#$(e,t){this.#u[t]=e,this.#l[e]=t}#L(e){e!==this.#h&&(e===this.#a?this.#a=this.#l[e]:this.#$(this.#u[e],this.#l[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#E(e,"delete")}#E(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#S?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#w?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#S?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#w?.(...i)}}};export{U as LRUCache};
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/browser/perf.js b/deps/npm/node_modules/lru-cache/dist/esm/browser/perf.js
new file mode 100644
index 00000000000000..f21cd88c8692d7
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/esm/browser/perf.js
@@ -0,0 +1,7 @@
+export const defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/index.js b/deps/npm/node_modules/lru-cache/dist/esm/index.js
index 11c8cd8dfbf5cf..114a4e9908390f 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/index.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/index.js
@@ -2,12 +2,8 @@
  * @module LRUCache
  */
 import { metrics, tracing } from './diagnostics-channel.js';
+import { defaultPerf } from './perf.js';
 const hasSubscribers = () => metrics.hasSubscribers || tracing.hasSubscribers;
-const defaultPerf = (typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function') ?
-    performance
-    : Date;
 const warned = new Set();
 /* c8 ignore start */
 const PROCESS = (typeof process === 'object' && !!process ?
@@ -49,7 +45,9 @@ class ZeroArray extends Array {
     }
 }
 class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
     heap;
+    /* c8 ignore stop */
     length;
     // private constructor
     static #constructing = false;
@@ -169,6 +167,8 @@ export class LRUCache {
      * {@link LRUCache.OptionsBase.ignoreFetchAbort}
      */
     ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
     // computed properties
     #size;
     #calculatedSize;
@@ -279,7 +279,8 @@ export class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
         if (perf !== undefined) {
             if (typeof perf?.now !== 'function') {
                 throw new TypeError('perf option must have a now() method if specified');
@@ -507,12 +508,15 @@ export class LRUCache {
             sizes[index] = 0;
         };
         this.#requireSize = (k, v, size, sizeCalculation) => {
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
             if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
                 if (sizeCalculation) {
                     if (typeof sizeCalculation !== 'function') {
                         throw new TypeError('sizeCalculation must be a function');
@@ -879,6 +883,7 @@ export class LRUCache {
             status.key = k;
             if (v !== undefined)
                 status.value = v;
+            status.cache = this;
         }
         const result = this.#set(k, v, setOptions);
         if (status && metrics.hasSubscribers) {
@@ -886,8 +891,9 @@ export class LRUCache {
         }
         return result;
     }
-    #set(k, v, setOptions = {}) {
+    #set(k, v, setOptions, bf) {
         const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
         if (v === undefined) {
             if (status)
                 status.set = 'deleted';
@@ -895,7 +901,7 @@ export class LRUCache {
             return this;
         }
         let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        if (status && !this.#isBackgroundFetch(v))
+        if (status && !isBF)
             status.value = v;
         const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
         // if the item doesn't fit, don't do anything
@@ -927,52 +933,68 @@ export class LRUCache {
             if (status)
                 status.set = 'add';
             noUpdateTTL = false;
-            if (this.#hasOnInsert) {
+            if (this.#hasOnInsert && !isBF) {
                 this.#onInsert?.(v, k, 'add');
             }
         }
         else {
             // update
+            // might be updating a background fetch!
             this.#moveToTail(index);
             const oldVal = this.#valList[index];
             if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                    const { __staleWhileFetching: s } = oldVal;
-                    if (s !== undefined && !noDisposeOnSet) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
                         if (this.#hasDispose) {
-                            this.#dispose?.(s, k, 'set');
+                            this.#dispose?.(oldVal, k, 'set');
                         }
                         if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([s, k, 'set']);
+                            this.#disposed?.push([oldVal, k, 'set']);
                         }
                     }
                 }
-                else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([oldVal, k, 'set']);
-                    }
-                }
                 this.#removeItemSize(index);
                 this.#addItemSize(index, size, status);
                 this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
+                if (!isBF) {
                     const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
                         oldVal.__staleWhileFetching
                         : oldVal;
-                    if (oldValue !== undefined)
-                        status.oldValue = oldValue;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
                 }
             }
-            else if (status) {
-                status.set = 'update';
-            }
-            if (this.#hasOnInsert) {
-                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
             }
         }
         if (ttl !== 0 && !this.#ttls) {
@@ -1027,15 +1049,18 @@ export class LRUCache {
         const head = this.#head;
         const k = this.#keyList[head];
         const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
             v.__abortController.abort(new Error('evicted'));
         }
-        else if (this.#hasDispose || this.#hasDisposeAfter) {
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
             if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
+                this.#dispose?.(oldValue, k, 'evict');
             }
             if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, 'evict']);
+                this.#disposed?.push([oldValue, k, 'evict']);
             }
         }
         this.#removeItemSize(head);
@@ -1082,6 +1107,7 @@ export class LRUCache {
         if (status) {
             status.op = 'has';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#has(k, hasOptions);
         if (metrics.hasSubscribers)
@@ -1129,6 +1155,7 @@ export class LRUCache {
         if (status) {
             status.op = 'peek';
             status.key = k;
+            status.cache = this;
         }
         peekOptions.status = status;
         const result = this.#peek(k, peekOptions);
@@ -1211,7 +1238,7 @@ export class LRUCache {
                 else {
                     if (options.status)
                         options.status.fetchUpdated = true;
-                    this.#set(k, v, fetchOpts.options);
+                    this.#set(k, v, fetchOpts.options, bf);
                 }
             }
             return v;
@@ -1257,9 +1284,6 @@ export class LRUCache {
         };
         const pcall = (res, rej) => {
             const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then(v => res(v === undefined ? undefined : v), rej);
-            }
             // ignored, we go until we finish, regardless.
             // defer check until we are actually aborting,
             // so fetchMethod can override.
@@ -1272,6 +1296,12 @@ export class LRUCache {
                     }
                 }
             });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
         };
         if (options.status)
             options.status.fetchDispatched = true;
@@ -1287,6 +1317,10 @@ export class LRUCache {
             index = this.#keyMap.get(k);
         }
         else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
             this.#valList[index] = bf;
         }
         return bf;
@@ -1308,11 +1342,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#fetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1329,6 +1361,7 @@ export class LRUCache {
             status.key = k;
             if (forceRefresh)
                 status.forceRefresh = true;
+            status.cache = this;
         }
         if (!this.#hasFetchMethod) {
             if (status)
@@ -1410,11 +1443,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#forceFetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1433,6 +1464,7 @@ export class LRUCache {
             if (memoOptions.context) {
                 status.context = memoOptions.context;
             }
+            status.cache = this;
         }
         const result = this.#memo(k, memoOptions);
         if (status)
@@ -1479,6 +1511,7 @@ export class LRUCache {
         if (status) {
             status.op = 'get';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#get(k, getOptions);
         if (status) {
@@ -1577,6 +1610,7 @@ export class LRUCache {
                 op: 'delete',
                 delete: reason,
                 key: k,
+                cache: this,
             });
         }
         let deleted = false;
@@ -1657,7 +1691,7 @@ export class LRUCache {
             }
         }
         this.#keyMap.clear();
-        this.#valList.fill(undefined);
+        void this.#valList.fill(undefined);
         this.#keyList.fill(undefined);
         if (this.#ttls && this.#starts) {
             this.#ttls.fill(0);
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/index.min.js b/deps/npm/node_modules/lru-cache/dist/esm/index.min.js
index fab73dbf022822..5715ef55079b71 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/index.min.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/index.min.js
@@ -1,2 +1,2 @@
-var C={hasSubscribers:!1},S=C,A=C;import("node:diagnostics_channel").then(u=>{S=u.channel("lru-cache:metrics"),A=u.tracingChannel("lru-cache")}).catch(()=>{});var D=()=>S.hasSubscribers||A.hasSubscribers,I=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date,U=new Set,L=typeof process=="object"&&process?process:{},G=(u,e,t,i)=>{typeof L.emitWarning=="function"?L.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`)},P=u=>!U.has(u),V=Symbol("type"),F=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),j=u=>F(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class u{heap;length;static#o=!1;static create(e){let t=j(e);if(!t)return[];u.#o=!0;let i=new u(e,t);return u.#o=!1,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},M=class u{#o;#u;#w;#D;#S;#M;#U;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;#n;#b;#s;#i;#t;#a;#c;#l;#h;#y;#r;#_;#F;#d;#g;#T;#W;#f;#j;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#a,prev:e.#c,get head(){return e.#l},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#u}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#U}get dispose(){return this.#w}get onInsert(){return this.#D}get disposeAfter(){return this.#S}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:o,updateAgeOnHas:r,allowStale:h,dispose:l,onInsert:c,disposeAfter:f,noDisposeOnSet:g,noUpdateTTL:p,maxSize:T=0,maxEntrySize:w=0,sizeCalculation:y,fetchMethod:a,memoMethod:m,noDeleteOnFetchRejection:_,noDeleteOnStaleGet:b,allowStaleOnFetchRejection:d,allowStaleOnFetchAbort:z,ignoreFetchAbort:v,perf:x}=e;if(x!==void 0&&typeof x?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=x??I,t!==0&&!F(t))throw new TypeError("max option must be a nonnegative integer");let E=t?j(t):Array;if(!E)throw new Error("invalid max value: "+t);if(this.#o=t,this.#u=T,this.maxEntrySize=w||this.#u,this.sizeCalculation=y,this.sizeCalculation){if(!this.#u&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(m!==void 0&&typeof m!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#U=m,a!==void 0&&typeof a!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=a,this.#W=!!a,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#a=new E(t),this.#c=new E(t),this.#l=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof l=="function"&&(this.#w=l),typeof c=="function"&&(this.#D=c),typeof f=="function"?(this.#S=f,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#w,this.#j=!!this.#D,this.#f=!!this.#S,this.noDisposeOnSet=!!g,this.noUpdateTTL=!!p,this.noDeleteOnFetchRejection=!!_,this.allowStaleOnFetchRejection=!!d,this.allowStaleOnFetchAbort=!!z,this.ignoreFetchAbort=!!v,this.maxEntrySize!==0){if(this.#u!==0&&!F(this.#u))throw new TypeError("maxSize must be a positive integer if specified");if(!F(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!h,this.noDeleteOnStaleGet=!!b,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!r,this.ttlResolution=F(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!F(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#H()}if(this.#o===0&&this.ttl===0&&this.#u===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#u){let W="LRU_CACHE_UNBOUNDED";P(W)&&(U.add(W),G("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",W,u))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#H(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#N=(r,h,l=this.#m.now())=>{t[r]=h!==0?l:0,e[r]=h,s(r,h)},this.#x=r=>{t[r]=e[r]!==0?this.#m.now():0,s(r,e[r])};let s=this.ttlAutopurge?(r,h)=>{if(i?.[r]&&(clearTimeout(i[r]),i[r]=void 0),h&&h!==0&&i){let l=setTimeout(()=>{this.#p(r)&&this.#v(this.#i[r],"expire")},h+1);l.unref&&l.unref(),i[r]=l}}:()=>{};this.#E=(r,h)=>{if(e[h]){let l=e[h],c=t[h];if(!l||!c)return;r.ttl=l,r.start=c,r.now=n||o();let f=r.now-c;r.remainingTTL=l-f}};let n=0,o=()=>{let r=this.#m.now();if(this.ttlResolution>0){n=r;let h=setTimeout(()=>n=0,this.ttlResolution);h.unref&&h.unref()}return r};this.getRemainingTTL=r=>{let h=this.#s.get(r);if(h===void 0)return 0;let l=e[h],c=t[h];if(!l||!c)return 1/0;let f=(n||o())-c;return l-f},this.#p=r=>{let h=t[r],l=e[r];return!!l&&!!h&&(n||o())-h>l}}#x=()=>{};#E=()=>{};#N=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#k=(t,i,s,n)=>{if(this.#e(i))return 0;if(!F(s))if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!F(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");return s},this.#I=(t,i,s)=>{if(e[t]=i,this.#u){let n=this.#u-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#I=(e,t,i)=>{};#k=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#l);)t=this.#c[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#l;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#a[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#v(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let o=this.#d[t],r=this.#F[t];if(o&&r){let h=o-(this.#m.now()-r);n.ttl=h,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let o={value:n};if(this.#d&&this.#F){o.ttl=this.#d[t];let r=this.#m.now()-this.#F[t];o.start=Math.floor(Date.now()-r)}this.#_&&(o.size=this.#_[t]),e.unshift([i,o])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#O(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t));let n=this.#O(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#O(e,t,i={}){let{ttl:s=this.ttl,start:n,noDisposeOnSet:o=this.noDisposeOnSet,sizeCalculation:r=this.sizeCalculation,status:h}=i;if(t===void 0)return h&&(h.set="deleted"),this.delete(e),this;let{noUpdateTTL:l=this.noUpdateTTL}=i;h&&!this.#e(t)&&(h.value=t);let c=this.#k(e,t,i.size||0,r,h);if(this.maxEntrySize&&c>this.maxEntrySize)return this.#v(e,"set"),h&&(h.set="miss",h.maxEntrySizeExceeded=!0),this;let f=this.#n===0?void 0:this.#s.get(e);if(f===void 0)f=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[f]=e,this.#t[f]=t,this.#s.set(e,f),this.#a[this.#h]=f,this.#c[f]=this.#h,this.#h=f,this.#n++,this.#I(f,c,h),h&&(h.set="add"),l=!1,this.#j&&this.#D?.(t,e,"add");else{this.#L(f);let g=this.#t[f];if(t!==g){if(this.#W&&this.#e(g)){g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:p}=g;p!==void 0&&!o&&(this.#T&&this.#w?.(p,e,"set"),this.#f&&this.#r?.push([p,e,"set"]))}else o||(this.#T&&this.#w?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]));if(this.#R(f),this.#I(f,c,h),this.#t[f]=t,h){h.set="replace";let p=g&&this.#e(g)?g.__staleWhileFetching:g;p!==void 0&&(h.oldValue=p)}}else h&&(h.set="update");this.#j&&this.onInsert?.(t,e,t===g?"update":"replace")}if(s!==0&&!this.#d&&this.#H(),this.#d&&(l||this.#N(f,s,n),h&&this.#E(h,f)),!o&&this.#f&&this.#r){let g=this.#r,p;for(;p=g?.shift();)this.#S?.(...p)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#l];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#S?.(...t)}}}#G(e){let t=this.#l,i=this.#i[t],s=this.#t[t];return this.#W&&this.#e(s)?s.__abortController.abort(new Error("evicted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(s,i,"evict"),this.#f&&this.#r?.push([s,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#l=this.#h=0,this.#y.length=0):this.#l=this.#a[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let o=this.#t[n];if(this.#e(o)&&o.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#x(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let o=this.#t[n],r=this.#e(o)?o.__staleWhileFetching:o;return i&&(r!==void 0?(i.peek="hit",i.value=r):i.peek="miss"),r}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let o=new AbortController,{signal:r}=i;r?.addEventListener("abort",()=>o.abort(r.reason),{signal:o.signal});let h={signal:o.signal,options:i,context:s},l=(w,y=!1)=>{let{aborted:a}=o.signal,m=i.ignoreFetchAbort&&w!==void 0,_=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&w!==void 0);if(i.status&&(a&&!y?(i.status.fetchAborted=!0,i.status.fetchError=o.signal.reason,m&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),a&&!m&&!y)return f(o.signal.reason,_);let b=p,d=this.#t[t];return(d===p||d===void 0&&m&&y)&&(w===void 0?b.__staleWhileFetching!==void 0?this.#t[t]=b.__staleWhileFetching:this.#v(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(e,w,h.options))),w},c=w=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=w),f(w,!1)),f=(w,y)=>{let{aborted:a}=o.signal,m=a&&i.allowStaleOnFetchAbort,_=m||i.allowStaleOnFetchRejection,b=_||i.noDeleteOnFetchRejection,d=p;if(this.#t[t]===p&&(!b||!y&&d.__staleWhileFetching===void 0?this.#v(e,"fetch"):m||(this.#t[t]=d.__staleWhileFetching)),_)return i.status&&d.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),d.__staleWhileFetching;if(d.__returned===d)throw w},g=(w,y)=>{let a=this.#M?.(e,n,h);a&&a instanceof Promise&&a.then(m=>w(m===void 0?void 0:m),y),o.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(w(void 0),i.allowStaleOnFetchAbort&&(w=m=>l(m,!0)))})};i.status&&(i.status.fetchDispatched=!0);let p=new Promise(g).then(l,c),T=Object.assign(p,{__abortController:o,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#O(e,T,{...h.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=T,T}#e(e){if(!this.#W)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=A.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&D()&&i&&(s.trace=!0,A.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:o=this.ttl,noDisposeOnSet:r=this.noDisposeOnSet,size:h=0,sizeCalculation:l=this.sizeCalculation,noUpdateTTL:c=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:g=this.allowStaleOnFetchRejection,ignoreFetchAbort:p=this.ignoreFetchAbort,allowStaleOnFetchAbort:T=this.allowStaleOnFetchAbort,context:w,forceRefresh:y=!1,status:a,signal:m}=t;if(a&&(a.op="fetch",a.key=e,y&&(a.forceRefresh=!0)),!this.#W)return a&&(a.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:a});let _={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:o,noDisposeOnSet:r,size:h,sizeCalculation:l,noUpdateTTL:c,noDeleteOnFetchRejection:f,allowStaleOnFetchRejection:g,allowStaleOnFetchAbort:T,ignoreFetchAbort:p,status:a,signal:m},b=this.#s.get(e);if(b===void 0){a&&(a.fetch="miss");let d=this.#P(e,b,_,w);return d.__returned=d}else{let d=this.#t[b];if(this.#e(d)){let W=i&&d.__staleWhileFetching!==void 0;return a&&(a.fetch="inflight",W&&(a.returnedStale=!0)),W?d.__staleWhileFetching:d.__returned=d}let z=this.#p(b);if(!y&&!z)return a&&(a.fetch="hit"),this.#L(b),s&&this.#x(b),a&&this.#E(a,b),d;let v=this.#P(e,b,_,w),E=v.__staleWhileFetching!==void 0&&i;return a&&(a.fetch=z?"stale":"refresh",E&&z&&(a.returnedStale=!0)),E?v.__staleWhileFetching:v.__returned=v}}forceFetch(e,t={}){let i=A.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&D()&&i&&(s.trace=!0,A.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context));let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#U;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:o,...r}=t;n&&o&&(n.forceRefresh=!0);let h=this.#C(e,r),l=o||h===void 0;if(n&&(n.memo=l?"miss":"hit",l||(n.value=h)),!l)return h;let c=i(e,h,{options:r,context:s});return n&&(n.value=c),this.#O(e,c,r),c}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:o}=t,r=this.#s.get(e);if(r===void 0){o&&(o.get="miss");return}let h=this.#t[r],l=this.#e(h);return o&&this.#E(o,r),this.#p(r)?l?(o&&(o.get="stale-fetching"),i&&h.__staleWhileFetching!==void 0?(o&&(o.returnedStale=!0),h.__staleWhileFetching):void 0):(n||this.#v(e,"expire"),o&&(o.get="stale"),i?(o&&(o.returnedStale=!0),h):void 0):(o&&(o.get=l?"fetching":"hit"),this.#L(r),s&&this.#x(r),l?h.__staleWhileFetching:h)}#$(e,t){this.#c[t]=e,this.#a[e]=t}#L(e){e!==this.#h&&(e===this.#l?this.#l=this.#a[e]:this.#$(this.#c[e],this.#a[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#v(e,"delete")}#v(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#c[s];else if(s===this.#l)this.#l=this.#a[s];else{let o=this.#c[s];this.#a[o]=this.#a[s];let r=this.#a[s];this.#c[r]=this.#c[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#w?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#l=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#S?.(...i)}}};export{M as LRUCache};
+var L={hasSubscribers:!1},S=L,A=L;import("node:diagnostics_channel").then(c=>{S=c.channel("lru-cache:metrics"),A=c.tracingChannel("lru-cache")}).catch(()=>{});var M=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date;var D=()=>S.hasSubscribers||A.hasSubscribers,j=new Set,I=typeof process=="object"&&process?process:{},P=(c,e,t,i)=>{typeof I.emitWarning=="function"?I.emitWarning(c,e,t,i):console.error(`[${t}] ${e}: ${c}`)},k=c=>!j.has(c);var T=c=>!!c&&c===Math.floor(c)&&c>0&&isFinite(c),G=c=>T(c)?c<=Math.pow(2,8)?Uint8Array:c<=Math.pow(2,16)?Uint16Array:c<=Math.pow(2,32)?Uint32Array:c<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class c{heap;length;static#o=!1;static create(e){let t=G(e);if(!t)return[];c.#o=!0;let i=new c(e,t);return c.#o=!1,i}constructor(e,t){if(!c.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},U=class c{#o;#c;#S;#O;#w;#M;#I;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#U;#f;#x;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#l,prev:e.#u,get head(){return e.#a},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#I}get dispose(){return this.#S}get onInsert(){return this.#O}get disposeAfter(){return this.#w}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:y,noDisposeOnSet:_,noUpdateTTL:u,maxSize:g=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:w,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:m,allowStaleOnFetchRejection:p,allowStaleOnFetchAbort:z,ignoreFetchAbort:E,backgroundFetchSize:C=1,perf:v}=e;if(this.backgroundFetchSize=C,v!==void 0&&typeof v?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=v??M,t!==0&&!T(t))throw new TypeError("max option must be a nonnegative integer");let W=t?G(t):Array;if(!W)throw new Error("invalid max value: "+t);if(this.#o=t,this.#c=g,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(w!==void 0&&typeof w!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#I=w,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#l=new W(t),this.#u=new W(t),this.#a=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof o=="function"&&(this.#S=o),typeof d=="function"&&(this.#O=d),typeof y=="function"?(this.#w=y,this.#r=[]):(this.#w=void 0,this.#r=void 0),this.#T=!!this.#S,this.#x=!!this.#O,this.#f=!!this.#w,this.noDisposeOnSet=!!_,this.noUpdateTTL=!!u,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!p,this.allowStaleOnFetchAbort=!!z,this.ignoreFetchAbort=!!E,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!m,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let x="LRU_CACHE_UNBOUNDED";k(x)&&(j.add(x),P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",x,c))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#k(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#m.now())=>{t[h]=a!==0?o:0,e[h]=a,s(h,a)},this.#D=h=>{t[h]=e[h]!==0?this.#m.now():0,s(h,e[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#E(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#v=(h,a)=>{if(e[a]){let o=e[a],d=t[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let y=h.now-d;h.remainingTTL=o-y}};let n=0,r=()=>{let h=this.#m.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=e[a],d=t[a];if(!o||!d)return 1/0;let y=(n||r())-d;return o-y},this.#p=h=>{let a=t[h],o=e[h];return!!o&&!!a&&(n||r())-a>o}}#D=()=>{};#v=()=>{};#H=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#N=(t,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#j=(t,i,s)=>{if(e[t]=i,this.#c){let n=this.#c-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#j=(e,t,i)=>{};#N=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#a);)t=this.#u[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#a;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#l[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#E(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[t],h=this.#F[t];if(r&&h){let a=r-(this.#m.now()-h);n.ttl=a,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[t];let h=this.#m.now()-this.#F[t];r.start=Math.floor(Date.now()-h)}this.#_&&(r.size=this.#_[t]),e.unshift([i,r])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#W(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t),s.cache=this);let n=this.#W(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#W(e,t,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(t);if(t===void 0)return o&&(o.set="deleted"),this.delete(e),this;let{noUpdateTTL:y=this.noUpdateTTL}=i;o&&!d&&(o.value=t);let _=this.#N(e,t,i.size||0,a,o);if(this.maxEntrySize&&_>this.maxEntrySize)return this.#E(e,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let u=this.#n===0?void 0:this.#s.get(e);if(u===void 0)u=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[u]=e,this.#t[u]=t,this.#s.set(e,u),this.#l[this.#h]=u,this.#u[u]=this.#h,this.#h=u,this.#n++,this.#j(u,_,o),o&&(o.set="add"),y=!1,this.#x&&!d&&this.#O?.(t,e,"add");else{this.#L(u);let g=this.#t[u];if(t!==g){if(!h)if(this.#e(g)){g!==s&&g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=g;f!==void 0&&f!==t&&(this.#T&&this.#S?.(f,e,"set"),this.#f&&this.#r?.push([f,e,"set"]))}else this.#T&&this.#S?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]);if(this.#R(u),this.#j(u,_,o),this.#t[u]=t,!d){let f=g&&this.#e(g)?g.__staleWhileFetching:g,b=f===void 0?"add":t!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#x&&this.onInsert?.(t,e,b)}}else d||(o&&(o.set="update"),this.#x&&this.onInsert?.(t,e,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(y||this.#H(u,n,r),o&&this.#v(o,u)),!h&&this.#f&&this.#r){let g=this.#r,f;for(;f=g?.shift();)this.#w?.(...f)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#a];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#w?.(...t)}}}#G(e){let t=this.#a,i=this.#i[t],s=this.#t[t],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#S?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e,i.cache=this);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#v(s,n));else return i&&this.#D(n),s&&(s.has="hit",this.#v(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e,i.cache=this),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,w=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,w&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!w&&!b)return y(r.signal.reason,F);let m=u,p=this.#t[t];return(p===u||p===void 0&&w&&b)&&(f===void 0?m.__staleWhileFetching!==void 0?this.#t[t]=m.__staleWhileFetching:this.#E(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#W(e,f,a.options,m))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),y(f,!1)),y=(f,b)=>{let{aborted:l}=r.signal,w=l&&i.allowStaleOnFetchAbort,F=w||i.allowStaleOnFetchRejection,m=F||i.noDeleteOnFetchRejection,p=u;if(this.#t[t]===u&&(!m||!b&&p.__staleWhileFetching===void 0?this.#E(e,"fetch"):w||(this.#t[t]=p.__staleWhileFetching)),F)return i.status&&p.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),p.__staleWhileFetching;if(p.__returned===p)throw f},_=(f,b)=>{let l=this.#M?.(e,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=w=>o(w,!0)))}),l&&l instanceof Promise?l.then(w=>f(w===void 0?void 0:w),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let u=new Promise(_).then(o,d),g=Object.assign(u,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#W(e,g,{...a.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=g,g}#e(e){if(!this.#U)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=A.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&i&&(s.trace=!0,A.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:y=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:_=this.allowStaleOnFetchRejection,ignoreFetchAbort:u=this.ignoreFetchAbort,allowStaleOnFetchAbort:g=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:w}=t;if(l&&(l.op="fetch",l.key=e,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:y,allowStaleOnFetchRejection:_,allowStaleOnFetchAbort:g,ignoreFetchAbort:u,status:l,signal:w},m=this.#s.get(e);if(m===void 0){l&&(l.fetch="miss");let p=this.#P(e,m,F,f);return p.__returned=p}else{let p=this.#t[m];if(this.#e(p)){let W=i&&p.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",W&&(l.returnedStale=!0)),W?p.__staleWhileFetching:p.__returned=p}let z=this.#p(m);if(!b&&!z)return l&&(l.fetch="hit"),this.#L(m),s&&this.#D(m),l&&this.#v(l,m),p;let E=this.#P(e,m,F,f),v=E.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=z?"stale":"refresh",v&&z&&(l.returnedStale=!0)),v?E.__staleWhileFetching:E.__returned=E}}forceFetch(e,t={}){let i=A.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&i&&(s.trace=!0,A.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context),i.cache=this);let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#I;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=t;n&&r&&(n.forceRefresh=!0);let a=this.#C(e,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(e,a,{options:h,context:s});return n&&(n.value=d),this.#W(e,d,h),d}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e,i.cache=this);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=t,h=this.#s.get(e);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#v(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#E(e,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#D(h),o?a.__staleWhileFetching:a)}#$(e,t){this.#u[t]=e,this.#l[e]=t}#L(e){e!==this.#h&&(e===this.#a?this.#a=this.#l[e]:this.#$(this.#u[e],this.#l[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#E(e,"delete")}#E(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#S?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#w?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#S?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#w?.(...i)}}};export{U as LRUCache};
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/node/diagnostics-channel.js b/deps/npm/node_modules/lru-cache/dist/esm/node/diagnostics-channel.js
index d6d8c48f2be7db..f37e0baac5977d 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/node/diagnostics-channel.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/node/diagnostics-channel.js
@@ -1,7 +1,6 @@
 // simple node version that imports from node builtin
-// this gets compiled to a require() commonjs-style override,
-// not using top level await on a conditional dynamic import
+// this is built to both ESM and CommonJS on the 'node' import path
 import { tracingChannel, channel } from 'node:diagnostics_channel';
 export const metrics = channel('lru-cache:metrics');
 export const tracing = tracingChannel('lru-cache');
-//# sourceMappingURL=diagnostics-channel-node.mjs.map
\ No newline at end of file
+//# sourceMappingURL=diagnostics-channel-node.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/node/index.js b/deps/npm/node_modules/lru-cache/dist/esm/node/index.js
index 11c8cd8dfbf5cf..114a4e9908390f 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/node/index.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/node/index.js
@@ -2,12 +2,8 @@
  * @module LRUCache
  */
 import { metrics, tracing } from './diagnostics-channel.js';
+import { defaultPerf } from './perf.js';
 const hasSubscribers = () => metrics.hasSubscribers || tracing.hasSubscribers;
-const defaultPerf = (typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function') ?
-    performance
-    : Date;
 const warned = new Set();
 /* c8 ignore start */
 const PROCESS = (typeof process === 'object' && !!process ?
@@ -49,7 +45,9 @@ class ZeroArray extends Array {
     }
 }
 class Stack {
+    /* c8 ignore start - not sure why this is showing up uncovered?? */
     heap;
+    /* c8 ignore stop */
     length;
     // private constructor
     static #constructing = false;
@@ -169,6 +167,8 @@ export class LRUCache {
      * {@link LRUCache.OptionsBase.ignoreFetchAbort}
      */
     ignoreFetchAbort;
+    /** {@link LRUCache.OptionsBase.backgroundFetchSize} */
+    backgroundFetchSize;
     // computed properties
     #size;
     #calculatedSize;
@@ -279,7 +279,8 @@ export class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, perf, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, backgroundFetchSize = 1, perf, } = options;
+        this.backgroundFetchSize = backgroundFetchSize;
         if (perf !== undefined) {
             if (typeof perf?.now !== 'function') {
                 throw new TypeError('perf option must have a now() method if specified');
@@ -507,12 +508,15 @@ export class LRUCache {
             sizes[index] = 0;
         };
         this.#requireSize = (k, v, size, sizeCalculation) => {
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
             if (!isPosInt(size)) {
+                // provisionally accept background fetches.
+                // actual value size will be checked when they return.
+                if (this.#isBackgroundFetch(v)) {
+                    // NB: this cannot occur if v.__staleWhileFetching is set,
+                    // because in that case, it would take on the size of the
+                    // existing entry that it temporarily replaces.
+                    return this.backgroundFetchSize;
+                }
                 if (sizeCalculation) {
                     if (typeof sizeCalculation !== 'function') {
                         throw new TypeError('sizeCalculation must be a function');
@@ -879,6 +883,7 @@ export class LRUCache {
             status.key = k;
             if (v !== undefined)
                 status.value = v;
+            status.cache = this;
         }
         const result = this.#set(k, v, setOptions);
         if (status && metrics.hasSubscribers) {
@@ -886,8 +891,9 @@ export class LRUCache {
         }
         return result;
     }
-    #set(k, v, setOptions = {}) {
+    #set(k, v, setOptions, bf) {
         const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        const isBF = this.#isBackgroundFetch(v);
         if (v === undefined) {
             if (status)
                 status.set = 'deleted';
@@ -895,7 +901,7 @@ export class LRUCache {
             return this;
         }
         let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        if (status && !this.#isBackgroundFetch(v))
+        if (status && !isBF)
             status.value = v;
         const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation, status);
         // if the item doesn't fit, don't do anything
@@ -927,52 +933,68 @@ export class LRUCache {
             if (status)
                 status.set = 'add';
             noUpdateTTL = false;
-            if (this.#hasOnInsert) {
+            if (this.#hasOnInsert && !isBF) {
                 this.#onInsert?.(v, k, 'add');
             }
         }
         else {
             // update
+            // might be updating a background fetch!
             this.#moveToTail(index);
             const oldVal = this.#valList[index];
             if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                    const { __staleWhileFetching: s } = oldVal;
-                    if (s !== undefined && !noDisposeOnSet) {
+                if (!noDisposeOnSet) {
+                    if (this.#isBackgroundFetch(oldVal)) {
+                        if (oldVal !== bf) {
+                            // setting over a background fetch, not merely resolving it.
+                            oldVal.__abortController.abort(new Error('replaced'));
+                        }
+                        const { __staleWhileFetching: s } = oldVal;
+                        if (s !== undefined && s !== v) {
+                            if (this.#hasDispose) {
+                                this.#dispose?.(s, k, 'set');
+                            }
+                            if (this.#hasDisposeAfter) {
+                                this.#disposed?.push([s, k, 'set']);
+                            }
+                        }
+                    }
+                    else {
                         if (this.#hasDispose) {
-                            this.#dispose?.(s, k, 'set');
+                            this.#dispose?.(oldVal, k, 'set');
                         }
                         if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([s, k, 'set']);
+                            this.#disposed?.push([oldVal, k, 'set']);
                         }
                     }
                 }
-                else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([oldVal, k, 'set']);
-                    }
-                }
                 this.#removeItemSize(index);
                 this.#addItemSize(index, size, status);
                 this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
+                if (!isBF) {
                     const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ?
                         oldVal.__staleWhileFetching
                         : oldVal;
-                    if (oldValue !== undefined)
-                        status.oldValue = oldValue;
+                    const setType = oldValue === undefined ? 'add'
+                        : v !== oldValue ? 'replace'
+                            : 'update';
+                    if (status) {
+                        status.set = setType;
+                        if (oldValue !== undefined)
+                            status.oldValue = oldValue;
+                    }
+                    if (this.#hasOnInsert) {
+                        this.onInsert?.(v, k, setType);
+                    }
                 }
             }
-            else if (status) {
-                status.set = 'update';
-            }
-            if (this.#hasOnInsert) {
-                this.onInsert?.(v, k, v === oldVal ? 'update' : 'replace');
+            else if (!isBF) {
+                if (status) {
+                    status.set = 'update';
+                }
+                if (this.#hasOnInsert) {
+                    this.onInsert?.(v, k, 'update');
+                }
             }
         }
         if (ttl !== 0 && !this.#ttls) {
@@ -1027,15 +1049,18 @@ export class LRUCache {
         const head = this.#head;
         const k = this.#keyList[head];
         const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+        const isBF = this.#isBackgroundFetch(v);
+        if (isBF) {
             v.__abortController.abort(new Error('evicted'));
         }
-        else if (this.#hasDispose || this.#hasDisposeAfter) {
+        const oldValue = isBF ? v.__staleWhileFetching : v;
+        if ((this.#hasDispose || this.#hasDisposeAfter) &&
+            oldValue !== undefined) {
             if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
+                this.#dispose?.(oldValue, k, 'evict');
             }
             if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, 'evict']);
+                this.#disposed?.push([oldValue, k, 'evict']);
             }
         }
         this.#removeItemSize(head);
@@ -1082,6 +1107,7 @@ export class LRUCache {
         if (status) {
             status.op = 'has';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#has(k, hasOptions);
         if (metrics.hasSubscribers)
@@ -1129,6 +1155,7 @@ export class LRUCache {
         if (status) {
             status.op = 'peek';
             status.key = k;
+            status.cache = this;
         }
         peekOptions.status = status;
         const result = this.#peek(k, peekOptions);
@@ -1211,7 +1238,7 @@ export class LRUCache {
                 else {
                     if (options.status)
                         options.status.fetchUpdated = true;
-                    this.#set(k, v, fetchOpts.options);
+                    this.#set(k, v, fetchOpts.options, bf);
                 }
             }
             return v;
@@ -1257,9 +1284,6 @@ export class LRUCache {
         };
         const pcall = (res, rej) => {
             const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then(v => res(v === undefined ? undefined : v), rej);
-            }
             // ignored, we go until we finish, regardless.
             // defer check until we are actually aborting,
             // so fetchMethod can override.
@@ -1272,6 +1296,12 @@ export class LRUCache {
                     }
                 }
             });
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            else if (fmp !== undefined) {
+                res(fmp);
+            }
         };
         if (options.status)
             options.status.fetchDispatched = true;
@@ -1287,6 +1317,10 @@ export class LRUCache {
             index = this.#keyMap.get(k);
         }
         else {
+            // do not call #set, because we do not want to adjust its place
+            // in the lru queue, as it has not yet been "used". Also, we don't
+            // need to worry about evicting for size, because a background fetch
+            // over a stale value is treated as the same size as its stale value.
             this.#valList[index] = bf;
         }
         return bf;
@@ -1308,11 +1342,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#fetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1329,6 +1361,7 @@ export class LRUCache {
             status.key = k;
             if (forceRefresh)
                 status.forceRefresh = true;
+            status.cache = this;
         }
         if (!this.#hasFetchMethod) {
             if (status)
@@ -1410,11 +1443,9 @@ export class LRUCache {
             status.context = fetchOptions.context;
         }
         const p = this.#forceFetch(k, fetchOptions);
-        if (status && hasSubscribers()) {
-            if (ths) {
-                status.trace = true;
-                tracing.tracePromise(() => p, status).catch(() => { });
-            }
+        if (status && ths) {
+            status.trace = true;
+            tracing.tracePromise(() => p, status).catch(() => { });
         }
         return p;
     }
@@ -1433,6 +1464,7 @@ export class LRUCache {
             if (memoOptions.context) {
                 status.context = memoOptions.context;
             }
+            status.cache = this;
         }
         const result = this.#memo(k, memoOptions);
         if (status)
@@ -1479,6 +1511,7 @@ export class LRUCache {
         if (status) {
             status.op = 'get';
             status.key = k;
+            status.cache = this;
         }
         const result = this.#get(k, getOptions);
         if (status) {
@@ -1577,6 +1610,7 @@ export class LRUCache {
                 op: 'delete',
                 delete: reason,
                 key: k,
+                cache: this,
             });
         }
         let deleted = false;
@@ -1657,7 +1691,7 @@ export class LRUCache {
             }
         }
         this.#keyMap.clear();
-        this.#valList.fill(undefined);
+        void this.#valList.fill(undefined);
         this.#keyList.fill(undefined);
         if (this.#ttls && this.#starts) {
             this.#ttls.fill(0);
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/node/index.min.js b/deps/npm/node_modules/lru-cache/dist/esm/node/index.min.js
index bd92365ef37894..84c4c3ec14ffa3 100644
--- a/deps/npm/node_modules/lru-cache/dist/esm/node/index.min.js
+++ b/deps/npm/node_modules/lru-cache/dist/esm/node/index.min.js
@@ -1,2 +1,2 @@
-import{tracingChannel as j,channel as I}from"node:diagnostics_channel";var S=I("lru-cache:metrics"),W=j("lru-cache");var D=()=>S.hasSubscribers||W.hasSubscribers,G=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date,M=new Set,C=typeof process=="object"&&process?process:{},P=(u,e,t,i)=>{typeof C.emitWarning=="function"?C.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`)},H=u=>!M.has(u),$=Symbol("type"),F=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),U=u=>F(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class u{heap;length;static#o=!1;static create(e){let t=U(e);if(!t)return[];u.#o=!0;let i=new u(e,t);return u.#o=!1,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},L=class u{#o;#u;#w;#D;#S;#M;#U;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;#n;#b;#s;#i;#t;#a;#c;#l;#h;#y;#r;#_;#F;#d;#g;#T;#W;#f;#j;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#a,prev:e.#c,get head(){return e.#l},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#u}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#U}get dispose(){return this.#w}get onInsert(){return this.#D}get disposeAfter(){return this.#S}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:o,updateAgeOnHas:r,allowStale:h,dispose:l,onInsert:c,disposeAfter:f,noDisposeOnSet:g,noUpdateTTL:p,maxSize:T=0,maxEntrySize:w=0,sizeCalculation:y,fetchMethod:a,memoMethod:m,noDeleteOnFetchRejection:_,noDeleteOnStaleGet:b,allowStaleOnFetchRejection:d,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,perf:x}=e;if(x!==void 0&&typeof x?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=x??G,t!==0&&!F(t))throw new TypeError("max option must be a nonnegative integer");let v=t?U(t):Array;if(!v)throw new Error("invalid max value: "+t);if(this.#o=t,this.#u=T,this.maxEntrySize=w||this.#u,this.sizeCalculation=y,this.sizeCalculation){if(!this.#u&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(m!==void 0&&typeof m!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#U=m,a!==void 0&&typeof a!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=a,this.#W=!!a,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#a=new v(t),this.#c=new v(t),this.#l=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof l=="function"&&(this.#w=l),typeof c=="function"&&(this.#D=c),typeof f=="function"?(this.#S=f,this.#r=[]):(this.#S=void 0,this.#r=void 0),this.#T=!!this.#w,this.#j=!!this.#D,this.#f=!!this.#S,this.noDisposeOnSet=!!g,this.noUpdateTTL=!!p,this.noDeleteOnFetchRejection=!!_,this.allowStaleOnFetchRejection=!!d,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#u!==0&&!F(this.#u))throw new TypeError("maxSize must be a positive integer if specified");if(!F(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!h,this.noDeleteOnStaleGet=!!b,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!r,this.ttlResolution=F(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!F(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#H()}if(this.#o===0&&this.ttl===0&&this.#u===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#u){let E="LRU_CACHE_UNBOUNDED";H(E)&&(M.add(E),P("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",E,u))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#H(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#N=(r,h,l=this.#m.now())=>{t[r]=h!==0?l:0,e[r]=h,s(r,h)},this.#x=r=>{t[r]=e[r]!==0?this.#m.now():0,s(r,e[r])};let s=this.ttlAutopurge?(r,h)=>{if(i?.[r]&&(clearTimeout(i[r]),i[r]=void 0),h&&h!==0&&i){let l=setTimeout(()=>{this.#p(r)&&this.#v(this.#i[r],"expire")},h+1);l.unref&&l.unref(),i[r]=l}}:()=>{};this.#E=(r,h)=>{if(e[h]){let l=e[h],c=t[h];if(!l||!c)return;r.ttl=l,r.start=c,r.now=n||o();let f=r.now-c;r.remainingTTL=l-f}};let n=0,o=()=>{let r=this.#m.now();if(this.ttlResolution>0){n=r;let h=setTimeout(()=>n=0,this.ttlResolution);h.unref&&h.unref()}return r};this.getRemainingTTL=r=>{let h=this.#s.get(r);if(h===void 0)return 0;let l=e[h],c=t[h];if(!l||!c)return 1/0;let f=(n||o())-c;return l-f},this.#p=r=>{let h=t[r],l=e[r];return!!l&&!!h&&(n||o())-h>l}}#x=()=>{};#E=()=>{};#N=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#k=(t,i,s,n)=>{if(this.#e(i))return 0;if(!F(s))if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!F(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");return s},this.#I=(t,i,s)=>{if(e[t]=i,this.#u){let n=this.#u-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#I=(e,t,i)=>{};#k=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#l);)t=this.#c[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#l;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#a[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#v(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let o=this.#d[t],r=this.#F[t];if(o&&r){let h=o-(this.#m.now()-r);n.ttl=h,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let o={value:n};if(this.#d&&this.#F){o.ttl=this.#d[t];let r=this.#m.now()-this.#F[t];o.start=Math.floor(Date.now()-r)}this.#_&&(o.size=this.#_[t]),e.unshift([i,o])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#O(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t));let n=this.#O(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#O(e,t,i={}){let{ttl:s=this.ttl,start:n,noDisposeOnSet:o=this.noDisposeOnSet,sizeCalculation:r=this.sizeCalculation,status:h}=i;if(t===void 0)return h&&(h.set="deleted"),this.delete(e),this;let{noUpdateTTL:l=this.noUpdateTTL}=i;h&&!this.#e(t)&&(h.value=t);let c=this.#k(e,t,i.size||0,r,h);if(this.maxEntrySize&&c>this.maxEntrySize)return this.#v(e,"set"),h&&(h.set="miss",h.maxEntrySizeExceeded=!0),this;let f=this.#n===0?void 0:this.#s.get(e);if(f===void 0)f=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[f]=e,this.#t[f]=t,this.#s.set(e,f),this.#a[this.#h]=f,this.#c[f]=this.#h,this.#h=f,this.#n++,this.#I(f,c,h),h&&(h.set="add"),l=!1,this.#j&&this.#D?.(t,e,"add");else{this.#L(f);let g=this.#t[f];if(t!==g){if(this.#W&&this.#e(g)){g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:p}=g;p!==void 0&&!o&&(this.#T&&this.#w?.(p,e,"set"),this.#f&&this.#r?.push([p,e,"set"]))}else o||(this.#T&&this.#w?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]));if(this.#R(f),this.#I(f,c,h),this.#t[f]=t,h){h.set="replace";let p=g&&this.#e(g)?g.__staleWhileFetching:g;p!==void 0&&(h.oldValue=p)}}else h&&(h.set="update");this.#j&&this.onInsert?.(t,e,t===g?"update":"replace")}if(s!==0&&!this.#d&&this.#H(),this.#d&&(l||this.#N(f,s,n),h&&this.#E(h,f)),!o&&this.#f&&this.#r){let g=this.#r,p;for(;p=g?.shift();)this.#S?.(...p)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#l];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#S?.(...t)}}}#G(e){let t=this.#l,i=this.#i[t],s=this.#t[t];return this.#W&&this.#e(s)?s.__abortController.abort(new Error("evicted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(s,i,"evict"),this.#f&&this.#r?.push([s,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#l=this.#h=0,this.#y.length=0):this.#l=this.#a[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let o=this.#t[n];if(this.#e(o)&&o.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#E(s,n));else return i&&this.#x(n),s&&(s.has="hit",this.#E(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let o=this.#t[n],r=this.#e(o)?o.__staleWhileFetching:o;return i&&(r!==void 0?(i.peek="hit",i.value=r):i.peek="miss"),r}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let o=new AbortController,{signal:r}=i;r?.addEventListener("abort",()=>o.abort(r.reason),{signal:o.signal});let h={signal:o.signal,options:i,context:s},l=(w,y=!1)=>{let{aborted:a}=o.signal,m=i.ignoreFetchAbort&&w!==void 0,_=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&w!==void 0);if(i.status&&(a&&!y?(i.status.fetchAborted=!0,i.status.fetchError=o.signal.reason,m&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),a&&!m&&!y)return f(o.signal.reason,_);let b=p,d=this.#t[t];return(d===p||d===void 0&&m&&y)&&(w===void 0?b.__staleWhileFetching!==void 0?this.#t[t]=b.__staleWhileFetching:this.#v(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#O(e,w,h.options))),w},c=w=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=w),f(w,!1)),f=(w,y)=>{let{aborted:a}=o.signal,m=a&&i.allowStaleOnFetchAbort,_=m||i.allowStaleOnFetchRejection,b=_||i.noDeleteOnFetchRejection,d=p;if(this.#t[t]===p&&(!b||!y&&d.__staleWhileFetching===void 0?this.#v(e,"fetch"):m||(this.#t[t]=d.__staleWhileFetching)),_)return i.status&&d.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),d.__staleWhileFetching;if(d.__returned===d)throw w},g=(w,y)=>{let a=this.#M?.(e,n,h);a&&a instanceof Promise&&a.then(m=>w(m===void 0?void 0:m),y),o.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(w(void 0),i.allowStaleOnFetchAbort&&(w=m=>l(m,!0)))})};i.status&&(i.status.fetchDispatched=!0);let p=new Promise(g).then(l,c),T=Object.assign(p,{__abortController:o,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#O(e,T,{...h.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=T,T}#e(e){if(!this.#W)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&D()&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:o=this.ttl,noDisposeOnSet:r=this.noDisposeOnSet,size:h=0,sizeCalculation:l=this.sizeCalculation,noUpdateTTL:c=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:g=this.allowStaleOnFetchRejection,ignoreFetchAbort:p=this.ignoreFetchAbort,allowStaleOnFetchAbort:T=this.allowStaleOnFetchAbort,context:w,forceRefresh:y=!1,status:a,signal:m}=t;if(a&&(a.op="fetch",a.key=e,y&&(a.forceRefresh=!0)),!this.#W)return a&&(a.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:a});let _={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:o,noDisposeOnSet:r,size:h,sizeCalculation:l,noUpdateTTL:c,noDeleteOnFetchRejection:f,allowStaleOnFetchRejection:g,allowStaleOnFetchAbort:T,ignoreFetchAbort:p,status:a,signal:m},b=this.#s.get(e);if(b===void 0){a&&(a.fetch="miss");let d=this.#P(e,b,_,w);return d.__returned=d}else{let d=this.#t[b];if(this.#e(d)){let E=i&&d.__staleWhileFetching!==void 0;return a&&(a.fetch="inflight",E&&(a.returnedStale=!0)),E?d.__staleWhileFetching:d.__returned=d}let A=this.#p(b);if(!y&&!A)return a&&(a.fetch="hit"),this.#L(b),s&&this.#x(b),a&&this.#E(a,b),d;let z=this.#P(e,b,_,w),v=z.__staleWhileFetching!==void 0&&i;return a&&(a.fetch=A?"stale":"refresh",v&&A&&(a.returnedStale=!0)),v?z.__staleWhileFetching:z.__returned=z}}forceFetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&D()&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context));let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#U;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:o,...r}=t;n&&o&&(n.forceRefresh=!0);let h=this.#C(e,r),l=o||h===void 0;if(n&&(n.memo=l?"miss":"hit",l||(n.value=h)),!l)return h;let c=i(e,h,{options:r,context:s});return n&&(n.value=c),this.#O(e,c,r),c}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:o}=t,r=this.#s.get(e);if(r===void 0){o&&(o.get="miss");return}let h=this.#t[r],l=this.#e(h);return o&&this.#E(o,r),this.#p(r)?l?(o&&(o.get="stale-fetching"),i&&h.__staleWhileFetching!==void 0?(o&&(o.returnedStale=!0),h.__staleWhileFetching):void 0):(n||this.#v(e,"expire"),o&&(o.get="stale"),i?(o&&(o.returnedStale=!0),h):void 0):(o&&(o.get=l?"fetching":"hit"),this.#L(r),s&&this.#x(r),l?h.__staleWhileFetching:h)}#$(e,t){this.#c[t]=e,this.#a[e]=t}#L(e){e!==this.#h&&(e===this.#l?this.#l=this.#a[e]:this.#$(this.#c[e],this.#a[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#v(e,"delete")}#v(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#w?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#c[s];else if(s===this.#l)this.#l=this.#a[s];else{let o=this.#c[s];this.#a[o]=this.#a[s];let r=this.#a[s];this.#c[r]=this.#c[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#S?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#w?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#l=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#S?.(...i)}}};export{L as LRUCache};
+import{tracingChannel as G,channel as P}from"node:diagnostics_channel";var S=P("lru-cache:metrics"),W=G("lru-cache");var L=typeof performance=="object"&&performance&&typeof performance.now=="function"?performance:Date;var D=()=>S.hasSubscribers||W.hasSubscribers,U=new Set,M=typeof process=="object"&&process?process:{},k=(u,e,t,i)=>{typeof M.emitWarning=="function"?M.emitWarning(u,e,t,i):console.error(`[${t}] ${e}: ${u}`)},H=u=>!U.has(u);var T=u=>!!u&&u===Math.floor(u)&&u>0&&isFinite(u),j=u=>T(u)?u<=Math.pow(2,8)?Uint8Array:u<=Math.pow(2,16)?Uint16Array:u<=Math.pow(2,32)?Uint32Array:u<=Number.MAX_SAFE_INTEGER?O:null:null,O=class extends Array{constructor(e){super(e),this.fill(0)}},R=class u{heap;length;static#o=!1;static create(e){let t=j(e);if(!t)return[];u.#o=!0;let i=new u(e,t);return u.#o=!1,i}constructor(e,t){if(!u.#o)throw new TypeError("instantiate Stack using Stack.create(n)");this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}},I=class u{#o;#c;#S;#O;#w;#M;#I;#m;get perf(){return this.#m}ttl;ttlResolution;ttlAutopurge;updateAgeOnGet;updateAgeOnHas;allowStale;noDisposeOnSet;noUpdateTTL;maxEntrySize;sizeCalculation;noDeleteOnFetchRejection;noDeleteOnStaleGet;allowStaleOnFetchAbort;allowStaleOnFetchRejection;ignoreFetchAbort;backgroundFetchSize;#n;#b;#s;#i;#t;#l;#u;#a;#h;#y;#r;#_;#F;#d;#g;#T;#U;#f;#x;static unsafeExposeInternals(e){return{starts:e.#F,ttls:e.#d,autopurgeTimers:e.#g,sizes:e.#_,keyMap:e.#s,keyList:e.#i,valList:e.#t,next:e.#l,prev:e.#u,get head(){return e.#a},get tail(){return e.#h},free:e.#y,isBackgroundFetch:t=>e.#e(t),backgroundFetch:(t,i,s,n)=>e.#P(t,i,s,n),moveToTail:t=>e.#L(t),indexes:t=>e.#A(t),rindexes:t=>e.#z(t),isStale:t=>e.#p(t)}}get max(){return this.#o}get maxSize(){return this.#c}get calculatedSize(){return this.#b}get size(){return this.#n}get fetchMethod(){return this.#M}get memoMethod(){return this.#I}get dispose(){return this.#S}get onInsert(){return this.#O}get disposeAfter(){return this.#w}constructor(e){let{max:t=0,ttl:i,ttlResolution:s=1,ttlAutopurge:n,updateAgeOnGet:r,updateAgeOnHas:h,allowStale:a,dispose:o,onInsert:d,disposeAfter:y,noDisposeOnSet:_,noUpdateTTL:c,maxSize:g=0,maxEntrySize:f=0,sizeCalculation:b,fetchMethod:l,memoMethod:w,noDeleteOnFetchRejection:F,noDeleteOnStaleGet:m,allowStaleOnFetchRejection:p,allowStaleOnFetchAbort:A,ignoreFetchAbort:z,backgroundFetchSize:C=1,perf:E}=e;if(this.backgroundFetchSize=C,E!==void 0&&typeof E?.now!="function")throw new TypeError("perf option must have a now() method if specified");if(this.#m=E??L,t!==0&&!T(t))throw new TypeError("max option must be a nonnegative integer");let v=t?j(t):Array;if(!v)throw new Error("invalid max value: "+t);if(this.#o=t,this.#c=g,this.maxEntrySize=f||this.#c,this.sizeCalculation=b,this.sizeCalculation){if(!this.#c&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if(typeof this.sizeCalculation!="function")throw new TypeError("sizeCalculation set to non-function")}if(w!==void 0&&typeof w!="function")throw new TypeError("memoMethod must be a function if defined");if(this.#I=w,l!==void 0&&typeof l!="function")throw new TypeError("fetchMethod must be a function if specified");if(this.#M=l,this.#U=!!l,this.#s=new Map,this.#i=Array.from({length:t}).fill(void 0),this.#t=Array.from({length:t}).fill(void 0),this.#l=new v(t),this.#u=new v(t),this.#a=0,this.#h=0,this.#y=R.create(t),this.#n=0,this.#b=0,typeof o=="function"&&(this.#S=o),typeof d=="function"&&(this.#O=d),typeof y=="function"?(this.#w=y,this.#r=[]):(this.#w=void 0,this.#r=void 0),this.#T=!!this.#S,this.#x=!!this.#O,this.#f=!!this.#w,this.noDisposeOnSet=!!_,this.noUpdateTTL=!!c,this.noDeleteOnFetchRejection=!!F,this.allowStaleOnFetchRejection=!!p,this.allowStaleOnFetchAbort=!!A,this.ignoreFetchAbort=!!z,this.maxEntrySize!==0){if(this.#c!==0&&!T(this.#c))throw new TypeError("maxSize must be a positive integer if specified");if(!T(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.#X()}if(this.allowStale=!!a,this.noDeleteOnStaleGet=!!m,this.updateAgeOnGet=!!r,this.updateAgeOnHas=!!h,this.ttlResolution=T(s)||s===0?s:1,this.ttlAutopurge=!!n,this.ttl=i||0,this.ttl){if(!T(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.#k()}if(this.#o===0&&this.ttl===0&&this.#c===0)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.#o&&!this.#c){let x="LRU_CACHE_UNBOUNDED";H(x)&&(U.add(x),k("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.","UnboundedCacheWarning",x,u))}}getRemainingTTL(e){return this.#s.has(e)?1/0:0}#k(){let e=new O(this.#o),t=new O(this.#o);this.#d=e,this.#F=t;let i=this.ttlAutopurge?Array.from({length:this.#o}):void 0;this.#g=i,this.#H=(h,a,o=this.#m.now())=>{t[h]=a!==0?o:0,e[h]=a,s(h,a)},this.#D=h=>{t[h]=e[h]!==0?this.#m.now():0,s(h,e[h])};let s=this.ttlAutopurge?(h,a)=>{if(i?.[h]&&(clearTimeout(i[h]),i[h]=void 0),a&&a!==0&&i){let o=setTimeout(()=>{this.#p(h)&&this.#E(this.#i[h],"expire")},a+1);o.unref&&o.unref(),i[h]=o}}:()=>{};this.#v=(h,a)=>{if(e[a]){let o=e[a],d=t[a];if(!o||!d)return;h.ttl=o,h.start=d,h.now=n||r();let y=h.now-d;h.remainingTTL=o-y}};let n=0,r=()=>{let h=this.#m.now();if(this.ttlResolution>0){n=h;let a=setTimeout(()=>n=0,this.ttlResolution);a.unref&&a.unref()}return h};this.getRemainingTTL=h=>{let a=this.#s.get(h);if(a===void 0)return 0;let o=e[a],d=t[a];if(!o||!d)return 1/0;let y=(n||r())-d;return o-y},this.#p=h=>{let a=t[h],o=e[h];return!!o&&!!a&&(n||r())-a>o}}#D=()=>{};#v=()=>{};#H=()=>{};#p=()=>!1;#X(){let e=new O(this.#o);this.#b=0,this.#_=e,this.#R=t=>{this.#b-=e[t],e[t]=0},this.#N=(t,i,s,n)=>{if(!T(s)){if(this.#e(i))return this.backgroundFetchSize;if(n){if(typeof n!="function")throw new TypeError("sizeCalculation must be a function");if(s=n(i,t),!T(s))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.")}return s},this.#j=(t,i,s)=>{if(e[t]=i,this.#c){let n=this.#c-e[t];for(;this.#b>n;)this.#G(!0)}this.#b+=e[t],s&&(s.entrySize=i,s.totalCalculatedSize=this.#b)}}#R=e=>{};#j=(e,t,i)=>{};#N=(e,t,i,s)=>{if(i||s)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");return 0};*#A({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#h;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#a);)t=this.#u[t]}*#z({allowStale:e=this.allowStale}={}){if(this.#n)for(let t=this.#a;this.#V(t)&&((e||!this.#p(t))&&(yield t),t!==this.#h);)t=this.#l[t]}#V(e){return e!==void 0&&this.#s.get(this.#i[e])===e}*entries(){for(let e of this.#A())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*rentries(){for(let e of this.#z())this.#t[e]!==void 0&&this.#i[e]!==void 0&&!this.#e(this.#t[e])&&(yield[this.#i[e],this.#t[e]])}*keys(){for(let e of this.#A()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*rkeys(){for(let e of this.#z()){let t=this.#i[e];t!==void 0&&!this.#e(this.#t[e])&&(yield t)}}*values(){for(let e of this.#A())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}*rvalues(){for(let e of this.#z())this.#t[e]!==void 0&&!this.#e(this.#t[e])&&(yield this.#t[e])}[Symbol.iterator](){return this.entries()}[Symbol.toStringTag]="LRUCache";find(e,t={}){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;if(n!==void 0&&e(n,this.#i[i],this))return this.#C(this.#i[i],t)}}forEach(e,t=this){for(let i of this.#A()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}rforEach(e,t=this){for(let i of this.#z()){let s=this.#t[i],n=this.#e(s)?s.__staleWhileFetching:s;n!==void 0&&e.call(t,n,this.#i[i],this)}}purgeStale(){let e=!1;for(let t of this.#z({allowStale:!0}))this.#p(t)&&(this.#E(this.#i[t],"expire"),e=!0);return e}info(e){let t=this.#s.get(e);if(t===void 0)return;let i=this.#t[t],s=this.#e(i)?i.__staleWhileFetching:i;if(s===void 0)return;let n={value:s};if(this.#d&&this.#F){let r=this.#d[t],h=this.#F[t];if(r&&h){let a=r-(this.#m.now()-h);n.ttl=a,n.start=Date.now()}}return this.#_&&(n.size=this.#_[t]),n}dump(){let e=[];for(let t of this.#A({allowStale:!0})){let i=this.#i[t],s=this.#t[t],n=this.#e(s)?s.__staleWhileFetching:s;if(n===void 0||i===void 0)continue;let r={value:n};if(this.#d&&this.#F){r.ttl=this.#d[t];let h=this.#m.now()-this.#F[t];r.start=Math.floor(Date.now()-h)}this.#_&&(r.size=this.#_[t]),e.unshift([i,r])}return e}load(e){this.clear();for(let[t,i]of e){if(i.start){let s=Date.now()-i.start;i.start=this.#m.now()-s}this.#W(t,i.value,i)}}set(e,t,i={}){let{status:s=S.hasSubscribers?{}:void 0}=i;i.status=s,s&&(s.op="set",s.key=e,t!==void 0&&(s.value=t),s.cache=this);let n=this.#W(e,t,i);return s&&S.hasSubscribers&&S.publish(s),n}#W(e,t,i,s){let{ttl:n=this.ttl,start:r,noDisposeOnSet:h=this.noDisposeOnSet,sizeCalculation:a=this.sizeCalculation,status:o}=i,d=this.#e(t);if(t===void 0)return o&&(o.set="deleted"),this.delete(e),this;let{noUpdateTTL:y=this.noUpdateTTL}=i;o&&!d&&(o.value=t);let _=this.#N(e,t,i.size||0,a,o);if(this.maxEntrySize&&_>this.maxEntrySize)return this.#E(e,"set"),o&&(o.set="miss",o.maxEntrySizeExceeded=!0),this;let c=this.#n===0?void 0:this.#s.get(e);if(c===void 0)c=this.#n===0?this.#h:this.#y.length!==0?this.#y.pop():this.#n===this.#o?this.#G(!1):this.#n,this.#i[c]=e,this.#t[c]=t,this.#s.set(e,c),this.#l[this.#h]=c,this.#u[c]=this.#h,this.#h=c,this.#n++,this.#j(c,_,o),o&&(o.set="add"),y=!1,this.#x&&!d&&this.#O?.(t,e,"add");else{this.#L(c);let g=this.#t[c];if(t!==g){if(!h)if(this.#e(g)){g!==s&&g.__abortController.abort(new Error("replaced"));let{__staleWhileFetching:f}=g;f!==void 0&&f!==t&&(this.#T&&this.#S?.(f,e,"set"),this.#f&&this.#r?.push([f,e,"set"]))}else this.#T&&this.#S?.(g,e,"set"),this.#f&&this.#r?.push([g,e,"set"]);if(this.#R(c),this.#j(c,_,o),this.#t[c]=t,!d){let f=g&&this.#e(g)?g.__staleWhileFetching:g,b=f===void 0?"add":t!==f?"replace":"update";o&&(o.set=b,f!==void 0&&(o.oldValue=f)),this.#x&&this.onInsert?.(t,e,b)}}else d||(o&&(o.set="update"),this.#x&&this.onInsert?.(t,e,"update"))}if(n!==0&&!this.#d&&this.#k(),this.#d&&(y||this.#H(c,n,r),o&&this.#v(o,c)),!h&&this.#f&&this.#r){let g=this.#r,f;for(;f=g?.shift();)this.#w?.(...f)}return this}pop(){try{for(;this.#n;){let e=this.#t[this.#a];if(this.#G(!0),this.#e(e)){if(e.__staleWhileFetching)return e.__staleWhileFetching}else if(e!==void 0)return e}}finally{if(this.#f&&this.#r){let e=this.#r,t;for(;t=e?.shift();)this.#w?.(...t)}}}#G(e){let t=this.#a,i=this.#i[t],s=this.#t[t],n=this.#e(s);n&&s.__abortController.abort(new Error("evicted"));let r=n?s.__staleWhileFetching:s;return(this.#T||this.#f)&&r!==void 0&&(this.#T&&this.#S?.(r,i,"evict"),this.#f&&this.#r?.push([r,i,"evict"])),this.#R(t),this.#g?.[t]&&(clearTimeout(this.#g[t]),this.#g[t]=void 0),e&&(this.#i[t]=void 0,this.#t[t]=void 0,this.#y.push(t)),this.#n===1?(this.#a=this.#h=0,this.#y.length=0):this.#a=this.#l[t],this.#s.delete(i),this.#n--,t}has(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="has",i.key=e,i.cache=this);let s=this.#Y(e,t);return S.hasSubscribers&&S.publish(i),s}#Y(e,t={}){let{updateAgeOnHas:i=this.updateAgeOnHas,status:s}=t,n=this.#s.get(e);if(n!==void 0){let r=this.#t[n];if(this.#e(r)&&r.__staleWhileFetching===void 0)return!1;if(this.#p(n))s&&(s.has="stale",this.#v(s,n));else return i&&this.#D(n),s&&(s.has="hit",this.#v(s,n)),!0}else s&&(s.has="miss");return!1}peek(e,t={}){let{status:i=D()?{}:void 0}=t;i&&(i.op="peek",i.key=e,i.cache=this),t.status=i;let s=this.#J(e,t);return S.hasSubscribers&&S.publish(i),s}#J(e,t){let{status:i,allowStale:s=this.allowStale}=t,n=this.#s.get(e);if(n===void 0||!s&&this.#p(n)){i&&(i.peek=n===void 0?"miss":"stale");return}let r=this.#t[n],h=this.#e(r)?r.__staleWhileFetching:r;return i&&(h!==void 0?(i.peek="hit",i.value=h):i.peek="miss"),h}#P(e,t,i,s){let n=t===void 0?void 0:this.#t[t];if(this.#e(n))return n;let r=new AbortController,{signal:h}=i;h?.addEventListener("abort",()=>r.abort(h.reason),{signal:r.signal});let a={signal:r.signal,options:i,context:s},o=(f,b=!1)=>{let{aborted:l}=r.signal,w=i.ignoreFetchAbort&&f!==void 0,F=i.ignoreFetchAbort||!!(i.allowStaleOnFetchAbort&&f!==void 0);if(i.status&&(l&&!b?(i.status.fetchAborted=!0,i.status.fetchError=r.signal.reason,w&&(i.status.fetchAbortIgnored=!0)):i.status.fetchResolved=!0),l&&!w&&!b)return y(r.signal.reason,F);let m=c,p=this.#t[t];return(p===c||p===void 0&&w&&b)&&(f===void 0?m.__staleWhileFetching!==void 0?this.#t[t]=m.__staleWhileFetching:this.#E(e,"fetch"):(i.status&&(i.status.fetchUpdated=!0),this.#W(e,f,a.options,m))),f},d=f=>(i.status&&(i.status.fetchRejected=!0,i.status.fetchError=f),y(f,!1)),y=(f,b)=>{let{aborted:l}=r.signal,w=l&&i.allowStaleOnFetchAbort,F=w||i.allowStaleOnFetchRejection,m=F||i.noDeleteOnFetchRejection,p=c;if(this.#t[t]===c&&(!m||!b&&p.__staleWhileFetching===void 0?this.#E(e,"fetch"):w||(this.#t[t]=p.__staleWhileFetching)),F)return i.status&&p.__staleWhileFetching!==void 0&&(i.status.returnedStale=!0),p.__staleWhileFetching;if(p.__returned===p)throw f},_=(f,b)=>{let l=this.#M?.(e,n,a);r.signal.addEventListener("abort",()=>{(!i.ignoreFetchAbort||i.allowStaleOnFetchAbort)&&(f(void 0),i.allowStaleOnFetchAbort&&(f=w=>o(w,!0)))}),l&&l instanceof Promise?l.then(w=>f(w===void 0?void 0:w),b):l!==void 0&&f(l)};i.status&&(i.status.fetchDispatched=!0);let c=new Promise(_).then(o,d),g=Object.assign(c,{__abortController:r,__staleWhileFetching:n,__returned:void 0});return t===void 0?(this.#W(e,g,{...a.options,status:void 0}),t=this.#s.get(e)):this.#t[t]=g,g}#e(e){if(!this.#U)return!1;let t=e;return!!t&&t instanceof Promise&&t.hasOwnProperty("__staleWhileFetching")&&t.__abortController instanceof AbortController}fetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#B(e,t);return s&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#B(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:r=this.ttl,noDisposeOnSet:h=this.noDisposeOnSet,size:a=0,sizeCalculation:o=this.sizeCalculation,noUpdateTTL:d=this.noUpdateTTL,noDeleteOnFetchRejection:y=this.noDeleteOnFetchRejection,allowStaleOnFetchRejection:_=this.allowStaleOnFetchRejection,ignoreFetchAbort:c=this.ignoreFetchAbort,allowStaleOnFetchAbort:g=this.allowStaleOnFetchAbort,context:f,forceRefresh:b=!1,status:l,signal:w}=t;if(l&&(l.op="fetch",l.key=e,b&&(l.forceRefresh=!0),l.cache=this),!this.#U)return l&&(l.fetch="get"),this.#C(e,{allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,status:l});let F={allowStale:i,updateAgeOnGet:s,noDeleteOnStaleGet:n,ttl:r,noDisposeOnSet:h,size:a,sizeCalculation:o,noUpdateTTL:d,noDeleteOnFetchRejection:y,allowStaleOnFetchRejection:_,allowStaleOnFetchAbort:g,ignoreFetchAbort:c,status:l,signal:w},m=this.#s.get(e);if(m===void 0){l&&(l.fetch="miss");let p=this.#P(e,m,F,f);return p.__returned=p}else{let p=this.#t[m];if(this.#e(p)){let v=i&&p.__staleWhileFetching!==void 0;return l&&(l.fetch="inflight",v&&(l.returnedStale=!0)),v?p.__staleWhileFetching:p.__returned=p}let A=this.#p(m);if(!b&&!A)return l&&(l.fetch="hit"),this.#L(m),s&&this.#D(m),l&&this.#v(l,m),p;let z=this.#P(e,m,F,f),E=z.__staleWhileFetching!==void 0&&i;return l&&(l.fetch=A?"stale":"refresh",E&&A&&(l.returnedStale=!0)),E?z.__staleWhileFetching:z.__returned=z}}forceFetch(e,t={}){let i=W.hasSubscribers,{status:s=D()?{}:void 0}=t;t.status=s,s&&t.context&&(s.context=t.context);let n=this.#K(e,t);return s&&i&&(s.trace=!0,W.tracePromise(()=>n,s).catch(()=>{})),n}async#K(e,t={}){let i=await this.#B(e,t);if(i===void 0)throw new Error("fetch() returned undefined");return i}memo(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="memo",i.key=e,t.context&&(i.context=t.context),i.cache=this);let s=this.#Q(e,t);return i&&(i.value=s),S.hasSubscribers&&S.publish(i),s}#Q(e,t={}){let i=this.#I;if(!i)throw new Error("no memoMethod provided to constructor");let{context:s,status:n,forceRefresh:r,...h}=t;n&&r&&(n.forceRefresh=!0);let a=this.#C(e,h),o=r||a===void 0;if(n&&(n.memo=o?"miss":"hit",o||(n.value=a)),!o)return a;let d=i(e,a,{options:h,context:s});return n&&(n.value=d),this.#W(e,d,h),d}get(e,t={}){let{status:i=S.hasSubscribers?{}:void 0}=t;t.status=i,i&&(i.op="get",i.key=e,i.cache=this);let s=this.#C(e,t);return i&&(s!==void 0&&(i.value=s),S.hasSubscribers&&S.publish(i)),s}#C(e,t={}){let{allowStale:i=this.allowStale,updateAgeOnGet:s=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,status:r}=t,h=this.#s.get(e);if(h===void 0){r&&(r.get="miss");return}let a=this.#t[h],o=this.#e(a);return r&&this.#v(r,h),this.#p(h)?o?(r&&(r.get="stale-fetching"),i&&a.__staleWhileFetching!==void 0?(r&&(r.returnedStale=!0),a.__staleWhileFetching):void 0):(n||this.#E(e,"expire"),r&&(r.get="stale"),i?(r&&(r.returnedStale=!0),a):void 0):(r&&(r.get=o?"fetching":"hit"),this.#L(h),s&&this.#D(h),o?a.__staleWhileFetching:a)}#$(e,t){this.#u[t]=e,this.#l[e]=t}#L(e){e!==this.#h&&(e===this.#a?this.#a=this.#l[e]:this.#$(this.#u[e],this.#l[e]),this.#$(this.#h,e),this.#h=e)}delete(e){return this.#E(e,"delete")}#E(e,t){S.hasSubscribers&&S.publish({op:"delete",delete:t,key:e,cache:this});let i=!1;if(this.#n!==0){let s=this.#s.get(e);if(s!==void 0)if(this.#g?.[s]&&(clearTimeout(this.#g?.[s]),this.#g[s]=void 0),i=!0,this.#n===1)this.#q(t);else{this.#R(s);let n=this.#t[s];if(this.#e(n)?n.__abortController.abort(new Error("deleted")):(this.#T||this.#f)&&(this.#T&&this.#S?.(n,e,t),this.#f&&this.#r?.push([n,e,t])),this.#s.delete(e),this.#i[s]=void 0,this.#t[s]=void 0,s===this.#h)this.#h=this.#u[s];else if(s===this.#a)this.#a=this.#l[s];else{let r=this.#u[s];this.#l[r]=this.#l[s];let h=this.#l[s];this.#u[h]=this.#u[s]}this.#n--,this.#y.push(s)}}if(this.#f&&this.#r?.length){let s=this.#r,n;for(;n=s?.shift();)this.#w?.(...n)}return i}clear(){return this.#q("delete")}#q(e){for(let t of this.#z({allowStale:!0})){let i=this.#t[t];if(this.#e(i))i.__abortController.abort(new Error("deleted"));else{let s=this.#i[t];this.#T&&this.#S?.(i,s,e),this.#f&&this.#r?.push([i,s,e])}}if(this.#s.clear(),this.#t.fill(void 0),this.#i.fill(void 0),this.#d&&this.#F){this.#d.fill(0),this.#F.fill(0);for(let t of this.#g??[])t!==void 0&&clearTimeout(t);this.#g?.fill(void 0)}if(this.#_&&this.#_.fill(0),this.#a=0,this.#h=0,this.#y.length=0,this.#b=0,this.#n=0,this.#f&&this.#r){let t=this.#r,i;for(;i=t?.shift();)this.#w?.(...i)}}};export{I as LRUCache};
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/node/perf.js b/deps/npm/node_modules/lru-cache/dist/esm/node/perf.js
new file mode 100644
index 00000000000000..f21cd88c8692d7
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/esm/node/perf.js
@@ -0,0 +1,7 @@
+export const defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/dist/esm/perf.js b/deps/npm/node_modules/lru-cache/dist/esm/perf.js
new file mode 100644
index 00000000000000..f21cd88c8692d7
--- /dev/null
+++ b/deps/npm/node_modules/lru-cache/dist/esm/perf.js
@@ -0,0 +1,7 @@
+export const defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map
\ No newline at end of file
diff --git a/deps/npm/node_modules/lru-cache/package.json b/deps/npm/node_modules/lru-cache/package.json
index b571016553e727..760fee478270d7 100644
--- a/deps/npm/node_modules/lru-cache/package.json
+++ b/deps/npm/node_modules/lru-cache/package.json
@@ -1,7 +1,7 @@
 {
   "name": "lru-cache",
   "description": "A cache object that deletes the least-recently-used items.",
-  "version": "11.3.5",
+  "version": "11.5.0",
   "author": "Isaac Z. Schlueter <i@izs.me>",
   "keywords": [
     "mru",
@@ -34,25 +34,37 @@
   "types": "./dist/commonjs/index.d.ts",
   "tshy": {
     "esmDialects": [
-      "node",
-      "browser"
+      "browser",
+      "node"
+    ],
+    "commonjsDialects": [
+      "browser",
+      "node"
     ],
     "exports": {
       "./raw": "./src/index.ts",
       ".": {
         "import": {
-          "node": {
-            "types": "./dist/esm/node/index.d.ts",
-            "default": "./dist/esm/node/index.min.js"
-          },
           "browser": {
             "types": "./dist/esm/browser/index.d.ts",
             "default": "./dist/esm/browser/index.min.js"
           },
+          "node": {
+            "types": "./dist/esm/node/index.d.ts",
+            "default": "./dist/esm/node/index.min.js"
+          },
           "types": "./dist/esm/index.d.ts",
           "default": "./dist/esm/index.min.js"
         },
         "require": {
+          "browser": {
+            "types": "./dist/commonjs/browser/index.d.ts",
+            "default": "./dist/commonjs/browser/index.min.js"
+          },
+          "node": {
+            "types": "./dist/commonjs/node/index.d.ts",
+            "default": "./dist/commonjs/node/index.min.js"
+          },
           "types": "./dist/commonjs/index.d.ts",
           "default": "./dist/commonjs/index.min.js"
         }
@@ -66,15 +78,15 @@
   },
   "devDependencies": {
     "benchmark": "^2.1.4",
-    "esbuild": "^0.25.9",
+    "esbuild": "^0.28.0",
     "marked": "^4.2.12",
     "mkdirp": "^3.0.1",
-    "oxlint": "^1.58.0",
-    "oxlint-tsgolint": "^0.19.0",
-    "prettier": "^3.8.1",
-    "tap": "^21.6.3",
-    "tshy": "^4.1.1",
-    "typedoc": "^0.28.18"
+    "oxlint": "^1.65.0",
+    "oxlint-tsgolint": "^0.22.1",
+    "prettier": "^3.8.3",
+    "tap": "^21.7.4",
+    "tshy": "^4.1.2",
+    "typedoc": "^0.28.19"
   },
   "license": "BlueOak-1.0.0",
   "files": [
@@ -86,36 +98,52 @@
   "exports": {
     "./raw": {
       "import": {
-        "node": {
-          "types": "./dist/esm/node/index.d.ts",
-          "default": "./dist/esm/node/index.js"
-        },
         "browser": {
           "types": "./dist/esm/browser/index.d.ts",
           "default": "./dist/esm/browser/index.js"
         },
+        "node": {
+          "types": "./dist/esm/node/index.d.ts",
+          "default": "./dist/esm/node/index.js"
+        },
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.js"
       },
       "require": {
+        "browser": {
+          "types": "./dist/commonjs/browser/index.d.ts",
+          "default": "./dist/commonjs/browser/index.js"
+        },
+        "node": {
+          "types": "./dist/commonjs/node/index.d.ts",
+          "default": "./dist/commonjs/node/index.js"
+        },
         "types": "./dist/commonjs/index.d.ts",
         "default": "./dist/commonjs/index.js"
       }
     },
     ".": {
       "import": {
-        "node": {
-          "types": "./dist/esm/node/index.d.ts",
-          "default": "./dist/esm/node/index.min.js"
-        },
         "browser": {
           "types": "./dist/esm/browser/index.d.ts",
           "default": "./dist/esm/browser/index.min.js"
         },
+        "node": {
+          "types": "./dist/esm/node/index.d.ts",
+          "default": "./dist/esm/node/index.min.js"
+        },
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.min.js"
       },
       "require": {
+        "browser": {
+          "types": "./dist/commonjs/browser/index.d.ts",
+          "default": "./dist/commonjs/browser/index.min.js"
+        },
+        "node": {
+          "types": "./dist/commonjs/node/index.d.ts",
+          "default": "./dist/commonjs/node/index.min.js"
+        },
         "types": "./dist/commonjs/index.d.ts",
         "default": "./dist/commonjs/index.min.js"
       }
diff --git a/deps/npm/node_modules/semver/README.md b/deps/npm/node_modules/semver/README.md
index f6503bfefd4640..c307e82d46ae44 100644
--- a/deps/npm/node_modules/semver/README.md
+++ b/deps/npm/node_modules/semver/README.md
@@ -56,6 +56,7 @@ const semverCompareLoose = require('semver/functions/compare-loose')
 const semverCompareBuild = require('semver/functions/compare-build')
 const semverSort = require('semver/functions/sort')
 const semverRsort = require('semver/functions/rsort')
+const semverTruncate = require('semver/functions/truncate')
 
 // low-level comparators between versions
 const semverGt = require('semver/functions/gt')
@@ -399,12 +400,19 @@ nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
 tilde      ::= '~' partial
 caret      ::= '^' partial
 qualifier  ::= ( '-' pre )? ( '+' build )?
-pre        ::= parts
-build      ::= parts
-parts      ::= part ( '.' part ) *
-part       ::= nr | [-0-9A-Za-z]+
+pre        ::= prepart ( '.' prepart ) *
+prepart    ::= nr | alphanumid
+build      ::= buildid ( '.' buildid ) *
+alphanumid ::= ( ['0'-'9'] ) * [-A-Za-z] [-0-9A-Za-z] *
+buildid    ::= [-0-9A-Za-z]+
 ```
 
+Note: Prerelease identifiers (`pre`) use `nr` for numeric parts, which
+disallows leading zeros (e.g., `1.2.3-00` is invalid). Build metadata
+identifiers (`build`) allow any alphanumeric string including leading
+zeros (e.g., `1.2.3+00` is valid). This matches the
+[SemVer 2.0.0 specification](https://semver.org/#spec-item-9).
+
 ## Functions
 
 All methods and classes take a final `options` object argument.  All
@@ -449,6 +457,12 @@ strings that they parse.
   or comparators intersect.
 * `parse(v)`: Attempt to parse a string as a semantic version, returning either
   a `SemVer` object or `null`.
+* `truncate(v, releaseType)`: Return the version with components _lower_
+  than `releaseType` dropped off, e.g.:
+  * `major` removes build & prerelease info and sets minor & patch to 0.
+  * `minor` removes build & prerelease info, and sets patch to 0
+  * `patch` removes build & prerelease info
+  * All prerelease types remove build info only
 
 ### Comparison
 
@@ -650,6 +664,7 @@ The following modules are available:
 * `require('semver/functions/rsort')`
 * `require('semver/functions/satisfies')`
 * `require('semver/functions/sort')`
+* `require('semver/functions/truncate')`
 * `require('semver/functions/valid')`
 * `require('semver/ranges/gtr')`
 * `require('semver/ranges/intersects')`
diff --git a/deps/npm/node_modules/semver/bin/semver.js b/deps/npm/node_modules/semver/bin/semver.js
index d62bfc0ecd5216..9ae8aadb95fbd9 100755
--- a/deps/npm/node_modules/semver/bin/semver.js
+++ b/deps/npm/node_modules/semver/bin/semver.js
@@ -46,6 +46,7 @@ const main = () => {
       a = a.slice(0, indexOfEqualSign)
       argv.unshift(value)
     }
+
     switch (a) {
       case '-rv': case '-rev': case '--rev': case '--reverse':
         reverse = true
@@ -60,15 +61,10 @@ const main = () => {
         versions.push(argv.shift())
         break
       case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-          case 'release':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
+        if (semver.RELEASE_TYPES.includes(argv[0]) || (argv[0] === 'release')) {
+          inc = { value: argv.shift(), maybeErrantValue: null, option: a }
+        } else {
+          inc = { value: 'patch', maybeErrantValue: argv[0], option: a }
         }
         break
       case '--preid':
@@ -102,6 +98,14 @@ const main = () => {
 
   options = parseOptions({ loose, includePrerelease, rtl })
 
+  if (
+    inc &&
+    versions.includes(inc.maybeErrantValue) &&
+    !semver.valid(inc.maybeErrantValue, options)
+  ) {
+    console.warn(`Invalid value for ${inc.option}; defaulting to 'patch'. This may become a failure in future major versions.`)
+  }
+
   versions = versions.map((v) => {
     return coerce ? (semver.coerce(v, options) || { version: v }).version : v
   }).filter((v) => {
@@ -125,7 +129,7 @@ const main = () => {
   versions
     .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
     .map(v => semver.clean(v, options))
-    .map(v => inc ? semver.inc(v, inc, options, identifier, identifierBase) : v)
+    .map(v => inc ? semver.inc(v, inc.value, options, identifier, identifierBase) : v)
     .forEach(v => console.log(v))
 }
 
diff --git a/deps/npm/node_modules/semver/functions/truncate.js b/deps/npm/node_modules/semver/functions/truncate.js
new file mode 100644
index 00000000000000..8314e4e922a418
--- /dev/null
+++ b/deps/npm/node_modules/semver/functions/truncate.js
@@ -0,0 +1,48 @@
+'use strict'
+
+const parse = require('./parse')
+const constants = require('../internal/constants')
+const SemVer = require('../classes/semver')
+
+const truncate = (version, truncation, options) => {
+  if (!constants.RELEASE_TYPES.includes(truncation)) {
+    return null
+  }
+
+  const clonedVersion = cloneInputVersion(version, options)
+  return clonedVersion && doTruncation(clonedVersion, truncation)
+}
+
+const cloneInputVersion = (version, options) => {
+  const versionStringToParse = (
+    version instanceof SemVer ? version.version : version
+  )
+
+  return parse(versionStringToParse, options)
+}
+
+const doTruncation = (version, truncation) => {
+  if (isPrerelease(truncation)) {
+    return version.version
+  }
+
+  version.prerelease = []
+
+  switch (truncation) {
+    case 'major':
+      version.minor = 0
+      version.patch = 0
+      break
+    case 'minor':
+      version.patch = 0
+      break
+  }
+
+  return version.format()
+}
+
+const isPrerelease = (type) => {
+  return type.startsWith('pre')
+}
+
+module.exports = truncate
diff --git a/deps/npm/node_modules/semver/index.js b/deps/npm/node_modules/semver/index.js
index 285662acb32892..bc1f608ceaad3d 100644
--- a/deps/npm/node_modules/semver/index.js
+++ b/deps/npm/node_modules/semver/index.js
@@ -28,6 +28,7 @@ const gte = require('./functions/gte')
 const lte = require('./functions/lte')
 const cmp = require('./functions/cmp')
 const coerce = require('./functions/coerce')
+const truncate = require('./functions/truncate')
 const Comparator = require('./classes/comparator')
 const Range = require('./classes/range')
 const satisfies = require('./functions/satisfies')
@@ -66,6 +67,7 @@ module.exports = {
   lte,
   cmp,
   coerce,
+  truncate,
   Comparator,
   Range,
   satisfies,
diff --git a/deps/npm/node_modules/semver/internal/re.js b/deps/npm/node_modules/semver/internal/re.js
index 639fca89de8e63..2ec2c22c972d32 100644
--- a/deps/npm/node_modules/semver/internal/re.js
+++ b/deps/npm/node_modules/semver/internal/re.js
@@ -136,7 +136,7 @@ createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
 createToken('GTLT', '((?:<|>)?=?)')
 
 // Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Note that "x.x" is a valid xRange identifier, meaning "any version"
 // Only the first item is strictly required.
 createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
 createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
diff --git a/deps/npm/node_modules/semver/package.json b/deps/npm/node_modules/semver/package.json
index a84de916085998..f8447c4951594d 100644
--- a/deps/npm/node_modules/semver/package.json
+++ b/deps/npm/node_modules/semver/package.json
@@ -1,6 +1,6 @@
 {
   "name": "semver",
-  "version": "7.7.4",
+  "version": "7.8.0",
   "description": "The semantic version parser used by npm.",
   "main": "index.js",
   "scripts": {
@@ -15,7 +15,7 @@
   },
   "devDependencies": {
     "@npmcli/eslint-config": "^6.0.0",
-    "@npmcli/template-oss": "4.29.0",
+    "@npmcli/template-oss": "5.0.0",
     "benchmark": "^2.1.4",
     "tap": "^16.0.0"
   },
@@ -52,7 +52,7 @@
   "author": "GitHub Inc.",
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "4.29.0",
+    "version": "5.0.0",
     "engines": ">=10",
     "distPaths": [
       "classes/",
diff --git a/deps/npm/node_modules/semver/range.bnf b/deps/npm/node_modules/semver/range.bnf
index d4c6ae0d76c9ac..a7a4bc37831127 100644
--- a/deps/npm/node_modules/semver/range.bnf
+++ b/deps/npm/node_modules/semver/range.bnf
@@ -10,7 +10,8 @@ nr         ::= '0' | [1-9] ( [0-9] ) *
 tilde      ::= '~' partial
 caret      ::= '^' partial
 qualifier  ::= ( '-' pre )? ( '+' build )?
-pre        ::= parts
-build      ::= parts
-parts      ::= part ( '.' part ) *
-part       ::= nr | [-0-9A-Za-z]+
+pre        ::= prepart ( '.' prepart ) *
+prepart    ::= nr | alphanumid
+build      ::= buildid ( '.' buildid ) *
+alphanumid ::= ( [0-9] ) * [A-Za-z-] [-0-9A-Za-z] *
+buildid    ::= [-0-9A-Za-z]+
diff --git a/deps/npm/node_modules/socks/package.json b/deps/npm/node_modules/socks/package.json
index a7a2a20190ad3a..078e21216b782e 100644
--- a/deps/npm/node_modules/socks/package.json
+++ b/deps/npm/node_modules/socks/package.json
@@ -1,14 +1,14 @@
 {
   "name": "socks",
   "private": false,
-  "version": "2.8.7",
+  "version": "2.8.9",
   "description": "Fully featured SOCKS proxy client supporting SOCKSv4, SOCKSv4a, and SOCKSv5. Includes Bind and Associate functionality.",
   "main": "build/index.js",
   "typings": "typings/index.d.ts",
   "homepage": "https://github.com/JoshGlazebrook/socks/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JoshGlazebrook/socks.git"
+    "url": "git+https://github.com/JoshGlazebrook/socks.git"
   },
   "bugs": {
     "url": "https://github.com/JoshGlazebrook/socks/issues"
@@ -44,7 +44,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "ip-address": "^10.0.1",
+    "ip-address": "^10.1.1",
     "smart-buffer": "^4.2.0"
   },
   "scripts": {
diff --git a/deps/npm/node_modules/tar/dist/commonjs/index.min.js b/deps/npm/node_modules/tar/dist/commonjs/index.min.js
index 6563e9e669054d..5bdc937545e805 100644
--- a/deps/npm/node_modules/tar/dist/commonjs/index.min.js
+++ b/deps/npm/node_modules/tar/dist/commonjs/index.min.js
@@ -1,4 +1,4 @@
-"use strict";var d=(s,e)=>()=>(e||s((e={exports:{}}).exports,e),e.exports);var We=d(F=>{"use strict";var Oo=F&&F.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(F,"__esModule",{value:!0});F.Minipass=F.isWritable=F.isReadable=F.isStream=void 0;var Cr=typeof process=="object"&&process?process:{stdout:null,stderr:null},ts=require("node:events"),jr=Oo(require("node:stream")),Ro=require("node:string_decoder"),vo=s=>!!s&&typeof s=="object"&&(s instanceof Ht||s instanceof jr.default||(0,F.isReadable)(s)||(0,F.isWritable)(s));F.isStream=vo;var To=s=>!!s&&typeof s=="object"&&s instanceof ts.EventEmitter&&typeof s.pipe=="function"&&s.pipe!==jr.default.Writable.prototype.pipe;F.isReadable=To;var Do=s=>!!s&&typeof s=="object"&&s instanceof ts.EventEmitter&&typeof s.write=="function"&&typeof s.end=="function";F.isWritable=Do;var le=Symbol("EOF"),ue=Symbol("maybeEmitEnd"),_e=Symbol("emittedEnd"),kt=Symbol("emittingEnd"),ft=Symbol("emittedError"),jt=Symbol("closed"),Br=Symbol("read"),xt=Symbol("flush"),zr=Symbol("flushChunk"),K=Symbol("encoding"),Ue=Symbol("decoder"),O=Symbol("flowing"),dt=Symbol("paused"),qe=Symbol("resume"),R=Symbol("buffer"),I=Symbol("pipes"),v=Symbol("bufferLength"),Vi=Symbol("bufferPush"),Ut=Symbol("bufferShift"),N=Symbol("objectMode"),y=Symbol("destroyed"),$i=Symbol("error"),Xi=Symbol("emitData"),kr=Symbol("emitEnd"),Qi=Symbol("emitEnd2"),J=Symbol("async"),Ji=Symbol("abort"),qt=Symbol("aborted"),mt=Symbol("signal"),Pe=Symbol("dataListeners"),k=Symbol("discarded"),pt=s=>Promise.resolve().then(s),Po=s=>s(),No=s=>s==="end"||s==="finish"||s==="prefinish",Mo=s=>s instanceof ArrayBuffer||!!s&&typeof s=="object"&&s.constructor&&s.constructor.name==="ArrayBuffer"&&s.byteLength>=0,Lo=s=>!Buffer.isBuffer(s)&&ArrayBuffer.isView(s),Wt=class{src;dest;opts;ondrain;constructor(e,t,i){this.src=e,this.dest=t,this.opts=i,this.ondrain=()=>e[qe](),this.dest.on("drain",this.ondrain)}unpipe(){this.dest.removeListener("drain",this.ondrain)}proxyErrors(e){}end(){this.unpipe(),this.opts.end&&this.dest.end()}},es=class extends Wt{unpipe(){this.src.removeListener("error",this.proxyErrors),super.unpipe()}constructor(e,t,i){super(e,t,i),this.proxyErrors=r=>this.dest.emit("error",r),e.on("error",this.proxyErrors)}},Ao=s=>!!s.objectMode,Io=s=>!s.objectMode&&!!s.encoding&&s.encoding!=="buffer",Ht=class extends ts.EventEmitter{[O]=!1;[dt]=!1;[I]=[];[R]=[];[N];[K];[J];[Ue];[le]=!1;[_e]=!1;[kt]=!1;[jt]=!1;[ft]=null;[v]=0;[y]=!1;[mt];[qt]=!1;[Pe]=0;[k]=!1;writable=!0;readable=!0;constructor(...e){let t=e[0]||{};if(super(),t.objectMode&&typeof t.encoding=="string")throw new TypeError("Encoding and objectMode may not be used together");Ao(t)?(this[N]=!0,this[K]=null):Io(t)?(this[K]=t.encoding,this[N]=!1):(this[N]=!1,this[K]=null),this[J]=!!t.async,this[Ue]=this[K]?new Ro.StringDecoder(this[K]):null,t&&t.debugExposeBuffer===!0&&Object.defineProperty(this,"buffer",{get:()=>this[R]}),t&&t.debugExposePipes===!0&&Object.defineProperty(this,"pipes",{get:()=>this[I]});let{signal:i}=t;i&&(this[mt]=i,i.aborted?this[Ji]():i.addEventListener("abort",()=>this[Ji]()))}get bufferLength(){return this[v]}get encoding(){return this[K]}set encoding(e){throw new Error("Encoding must be set at instantiation time")}setEncoding(e){throw new Error("Encoding must be set at instantiation time")}get objectMode(){return this[N]}set objectMode(e){throw new Error("objectMode must be set at instantiation time")}get async(){return this[J]}set async(e){this[J]=this[J]||!!e}[Ji](){this[qt]=!0,this.emit("abort",this[mt]?.reason),this.destroy(this[mt]?.reason)}get aborted(){return this[qt]}set aborted(e){}write(e,t,i){if(this[qt])return!1;if(this[le])throw new Error("write after end");if(this[y])return this.emit("error",Object.assign(new Error("Cannot call write after a stream was destroyed"),{code:"ERR_STREAM_DESTROYED"})),!0;typeof t=="function"&&(i=t,t="utf8"),t||(t="utf8");let r=this[J]?pt:Po;if(!this[N]&&!Buffer.isBuffer(e)){if(Lo(e))e=Buffer.from(e.buffer,e.byteOffset,e.byteLength);else if(Mo(e))e=Buffer.from(e);else if(typeof e!="string")throw new Error("Non-contiguous data written to non-objectMode stream")}return this[N]?(this[O]&&this[v]!==0&&this[xt](!0),this[O]?this.emit("data",e):this[Vi](e),this[v]!==0&&this.emit("readable"),i&&r(i),this[O]):e.length?(typeof e=="string"&&!(t===this[K]&&!this[Ue]?.lastNeed)&&(e=Buffer.from(e,t)),Buffer.isBuffer(e)&&this[K]&&(e=this[Ue].write(e)),this[O]&&this[v]!==0&&this[xt](!0),this[O]?this.emit("data",e):this[Vi](e),this[v]!==0&&this.emit("readable"),i&&r(i),this[O]):(this[v]!==0&&this.emit("readable"),i&&r(i),this[O])}read(e){if(this[y])return null;if(this[k]=!1,this[v]===0||e===0||e&&e>this[v])return this[ue](),null;this[N]&&(e=null),this[R].length>1&&!this[N]&&(this[R]=[this[K]?this[R].join(""):Buffer.concat(this[R],this[v])]);let t=this[Br](e||null,this[R][0]);return this[ue](),t}[Br](e,t){if(this[N])this[Ut]();else{let i=t;e===i.length||e===null?this[Ut]():typeof i=="string"?(this[R][0]=i.slice(e),t=i.slice(0,e),this[v]-=e):(this[R][0]=i.subarray(e),t=i.subarray(0,e),this[v]-=e)}return this.emit("data",t),!this[R].length&&!this[le]&&this.emit("drain"),t}end(e,t,i){return typeof e=="function"&&(i=e,e=void 0),typeof t=="function"&&(i=t,t="utf8"),e!==void 0&&this.write(e,t),i&&this.once("end",i),this[le]=!0,this.writable=!1,(this[O]||!this[dt])&&this[ue](),this}[qe](){this[y]||(!this[Pe]&&!this[I].length&&(this[k]=!0),this[dt]=!1,this[O]=!0,this.emit("resume"),this[R].length?this[xt]():this[le]?this[ue]():this.emit("drain"))}resume(){return this[qe]()}pause(){this[O]=!1,this[dt]=!0,this[k]=!1}get destroyed(){return this[y]}get flowing(){return this[O]}get paused(){return this[dt]}[Vi](e){this[N]?this[v]+=1:this[v]+=e.length,this[R].push(e)}[Ut](){return this[N]?this[v]-=1:this[v]-=this[R][0].length,this[R].shift()}[xt](e=!1){do;while(this[zr](this[Ut]())&&this[R].length);!e&&!this[R].length&&!this[le]&&this.emit("drain")}[zr](e){return this.emit("data",e),this[O]}pipe(e,t){if(this[y])return e;this[k]=!1;let i=this[_e];return t=t||{},e===Cr.stdout||e===Cr.stderr?t.end=!1:t.end=t.end!==!1,t.proxyErrors=!!t.proxyErrors,i?t.end&&e.end():(this[I].push(t.proxyErrors?new es(this,e,t):new Wt(this,e,t)),this[J]?pt(()=>this[qe]()):this[qe]()),e}unpipe(e){let t=this[I].find(i=>i.dest===e);t&&(this[I].length===1?(this[O]&&this[Pe]===0&&(this[O]=!1),this[I]=[]):this[I].splice(this[I].indexOf(t),1),t.unpipe())}addListener(e,t){return this.on(e,t)}on(e,t){let i=super.on(e,t);if(e==="data")this[k]=!1,this[Pe]++,!this[I].length&&!this[O]&&this[qe]();else if(e==="readable"&&this[v]!==0)super.emit("readable");else if(No(e)&&this[_e])super.emit(e),this.removeAllListeners(e);else if(e==="error"&&this[ft]){let r=t;this[J]?pt(()=>r.call(this,this[ft])):r.call(this,this[ft])}return i}removeListener(e,t){return this.off(e,t)}off(e,t){let i=super.off(e,t);return e==="data"&&(this[Pe]=this.listeners("data").length,this[Pe]===0&&!this[k]&&!this[I].length&&(this[O]=!1)),i}removeAllListeners(e){let t=super.removeAllListeners(e);return(e==="data"||e===void 0)&&(this[Pe]=0,!this[k]&&!this[I].length&&(this[O]=!1)),t}get emittedEnd(){return this[_e]}[ue](){!this[kt]&&!this[_e]&&!this[y]&&this[R].length===0&&this[le]&&(this[kt]=!0,this.emit("end"),this.emit("prefinish"),this.emit("finish"),this[jt]&&this.emit("close"),this[kt]=!1)}emit(e,...t){let i=t[0];if(e!=="error"&&e!=="close"&&e!==y&&this[y])return!1;if(e==="data")return!this[N]&&!i?!1:this[J]?(pt(()=>this[Xi](i)),!0):this[Xi](i);if(e==="end")return this[kr]();if(e==="close"){if(this[jt]=!0,!this[_e]&&!this[y])return!1;let n=super.emit("close");return this.removeAllListeners("close"),n}else if(e==="error"){this[ft]=i,super.emit($i,i);let n=!this[mt]||this.listeners("error").length?super.emit("error",i):!1;return this[ue](),n}else if(e==="resume"){let n=super.emit("resume");return this[ue](),n}else if(e==="finish"||e==="prefinish"){let n=super.emit(e);return this.removeAllListeners(e),n}let r=super.emit(e,...t);return this[ue](),r}[Xi](e){for(let i of this[I])i.dest.write(e)===!1&&this.pause();let t=this[k]?!1:super.emit("data",e);return this[ue](),t}[kr](){return this[_e]?!1:(this[_e]=!0,this.readable=!1,this[J]?(pt(()=>this[Qi]()),!0):this[Qi]())}[Qi](){if(this[Ue]){let t=this[Ue].end();if(t){for(let i of this[I])i.dest.write(t);this[k]||super.emit("data",t)}}for(let t of this[I])t.end();let e=super.emit("end");return this.removeAllListeners("end"),e}async collect(){let e=Object.assign([],{dataLength:0});this[N]||(e.dataLength=0);let t=this.promise();return this.on("data",i=>{e.push(i),this[N]||(e.dataLength+=i.length)}),await t,e}async concat(){if(this[N])throw new Error("cannot concat in objectMode");let e=await this.collect();return this[K]?e.join(""):Buffer.concat(e,e.dataLength)}async promise(){return new Promise((e,t)=>{this.on(y,()=>t(new Error("stream destroyed"))),this.on("error",i=>t(i)),this.on("end",()=>e())})}[Symbol.asyncIterator](){this[k]=!1;let e=!1,t=async()=>(this.pause(),e=!0,{value:void 0,done:!0});return{next:()=>{if(e)return t();let r=this.read();if(r!==null)return Promise.resolve({done:!1,value:r});if(this[le])return t();let n,o,a=c=>{this.off("data",h),this.off("end",l),this.off(y,u),t(),o(c)},h=c=>{this.off("error",a),this.off("end",l),this.off(y,u),this.pause(),n({value:c,done:!!this[le]})},l=()=>{this.off("error",a),this.off("data",h),this.off(y,u),t(),n({done:!0,value:void 0})},u=()=>a(new Error("stream destroyed"));return new Promise((c,E)=>{o=E,n=c,this.once(y,u),this.once("error",a),this.once("end",l),this.once("data",h)})},throw:t,return:t,[Symbol.asyncIterator](){return this},[Symbol.asyncDispose]:async()=>{}}}[Symbol.iterator](){this[k]=!1;let e=!1,t=()=>(this.pause(),this.off($i,t),this.off(y,t),this.off("end",t),e=!0,{done:!0,value:void 0}),i=()=>{if(e)return t();let r=this.read();return r===null?t():{done:!1,value:r}};return this.once("end",t),this.once($i,t),this.once(y,t),{next:i,throw:t,return:t,[Symbol.iterator](){return this},[Symbol.dispose]:()=>{}}}destroy(e){if(this[y])return e?this.emit("error",e):this.emit(y),this;this[y]=!0,this[k]=!0,this[R].length=0,this[v]=0;let t=this;return typeof t.close=="function"&&!this[jt]&&t.close(),e?this.emit("error",e):this.emit(y),this}static get isStream(){return F.isStream}};F.Minipass=Ht});var Ke=d(W=>{"use strict";var xr=W&&W.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(W,"__esModule",{value:!0});W.WriteStreamSync=W.WriteStream=W.ReadStreamSync=W.ReadStream=void 0;var Fo=xr(require("events")),B=xr(require("fs")),Co=We(),Bo=B.default.writev,ye=Symbol("_autoClose"),$=Symbol("_close"),_t=Symbol("_ended"),p=Symbol("_fd"),is=Symbol("_finished"),fe=Symbol("_flags"),ss=Symbol("_flush"),as=Symbol("_handleChunk"),hs=Symbol("_makeBuf"),yt=Symbol("_mode"),Zt=Symbol("_needDrain"),Ge=Symbol("_onerror"),Ye=Symbol("_onopen"),rs=Symbol("_onread"),He=Symbol("_onwrite"),Ee=Symbol("_open"),V=Symbol("_path"),we=Symbol("_pos"),ee=Symbol("_queue"),Ze=Symbol("_read"),ns=Symbol("_readSize"),ce=Symbol("_reading"),wt=Symbol("_remain"),os=Symbol("_size"),Gt=Symbol("_write"),Ne=Symbol("_writing"),Yt=Symbol("_defaultFlag"),Me=Symbol("_errored"),Kt=class extends Co.Minipass{[Me]=!1;[p];[V];[ns];[ce]=!1;[os];[wt];[ye];constructor(e,t){if(t=t||{},super(t),this.readable=!0,this.writable=!1,typeof e!="string")throw new TypeError("path must be a string");this[Me]=!1,this[p]=typeof t.fd=="number"?t.fd:void 0,this[V]=e,this[ns]=t.readSize||16*1024*1024,this[ce]=!1,this[os]=typeof t.size=="number"?t.size:1/0,this[wt]=this[os],this[ye]=typeof t.autoClose=="boolean"?t.autoClose:!0,typeof this[p]=="number"?this[Ze]():this[Ee]()}get fd(){return this[p]}get path(){return this[V]}write(){throw new TypeError("this is a readable stream")}end(){throw new TypeError("this is a readable stream")}[Ee](){B.default.open(this[V],"r",(e,t)=>this[Ye](e,t))}[Ye](e,t){e?this[Ge](e):(this[p]=t,this.emit("open",t),this[Ze]())}[hs](){return Buffer.allocUnsafe(Math.min(this[ns],this[wt]))}[Ze](){if(!this[ce]){this[ce]=!0;let e=this[hs]();if(e.length===0)return process.nextTick(()=>this[rs](null,0,e));B.default.read(this[p],e,0,e.length,null,(t,i,r)=>this[rs](t,i,r))}}[rs](e,t,i){this[ce]=!1,e?this[Ge](e):this[as](t,i)&&this[Ze]()}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.close(e,t=>t?this.emit("error",t):this.emit("close"))}}[Ge](e){this[ce]=!0,this[$](),this.emit("error",e)}[as](e,t){let i=!1;return this[wt]-=e,e>0&&(i=super.write(e<t.length?t.subarray(0,e):t)),(e===0||this[wt]<=0)&&(i=!1,this[$](),super.end()),i}emit(e,...t){switch(e){case"prefinish":case"finish":return!1;case"drain":return typeof this[p]=="number"&&this[Ze](),!1;case"error":return this[Me]?!1:(this[Me]=!0,super.emit(e,...t));default:return super.emit(e,...t)}}};W.ReadStream=Kt;var ls=class extends Kt{[Ee](){let e=!0;try{this[Ye](null,B.default.openSync(this[V],"r")),e=!1}finally{e&&this[$]()}}[Ze](){let e=!0;try{if(!this[ce]){this[ce]=!0;do{let t=this[hs](),i=t.length===0?0:B.default.readSync(this[p],t,0,t.length,null);if(!this[as](i,t))break}while(!0);this[ce]=!1}e=!1}finally{e&&this[$]()}}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.closeSync(e),this.emit("close")}}};W.ReadStreamSync=ls;var Vt=class extends Fo.default{readable=!1;writable=!0;[Me]=!1;[Ne]=!1;[_t]=!1;[ee]=[];[Zt]=!1;[V];[yt];[ye];[p];[Yt];[fe];[is]=!1;[we];constructor(e,t){t=t||{},super(t),this[V]=e,this[p]=typeof t.fd=="number"?t.fd:void 0,this[yt]=t.mode===void 0?438:t.mode,this[we]=typeof t.start=="number"?t.start:void 0,this[ye]=typeof t.autoClose=="boolean"?t.autoClose:!0;let i=this[we]!==void 0?"r+":"w";this[Yt]=t.flags===void 0,this[fe]=t.flags===void 0?i:t.flags,this[p]===void 0&&this[Ee]()}emit(e,...t){if(e==="error"){if(this[Me])return!1;this[Me]=!0}return super.emit(e,...t)}get fd(){return this[p]}get path(){return this[V]}[Ge](e){this[$](),this[Ne]=!0,this.emit("error",e)}[Ee](){B.default.open(this[V],this[fe],this[yt],(e,t)=>this[Ye](e,t))}[Ye](e,t){this[Yt]&&this[fe]==="r+"&&e&&e.code==="ENOENT"?(this[fe]="w",this[Ee]()):e?this[Ge](e):(this[p]=t,this.emit("open",t),this[Ne]||this[ss]())}end(e,t){return e&&this.write(e,t),this[_t]=!0,!this[Ne]&&!this[ee].length&&typeof this[p]=="number"&&this[He](null,0),this}write(e,t){return typeof e=="string"&&(e=Buffer.from(e,t)),this[_t]?(this.emit("error",new Error("write() after end()")),!1):this[p]===void 0||this[Ne]||this[ee].length?(this[ee].push(e),this[Zt]=!0,!1):(this[Ne]=!0,this[Gt](e),!0)}[Gt](e){B.default.write(this[p],e,0,e.length,this[we],(t,i)=>this[He](t,i))}[He](e,t){e?this[Ge](e):(this[we]!==void 0&&typeof t=="number"&&(this[we]+=t),this[ee].length?this[ss]():(this[Ne]=!1,this[_t]&&!this[is]?(this[is]=!0,this[$](),this.emit("finish")):this[Zt]&&(this[Zt]=!1,this.emit("drain"))))}[ss](){if(this[ee].length===0)this[_t]&&this[He](null,0);else if(this[ee].length===1)this[Gt](this[ee].pop());else{let e=this[ee];this[ee]=[],Bo(this[p],e,this[we],(t,i)=>this[He](t,i))}}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.close(e,t=>t?this.emit("error",t):this.emit("close"))}}};W.WriteStream=Vt;var us=class extends Vt{[Ee](){let e;if(this[Yt]&&this[fe]==="r+")try{e=B.default.openSync(this[V],this[fe],this[yt])}catch(t){if(t?.code==="ENOENT")return this[fe]="w",this[Ee]();throw t}else e=B.default.openSync(this[V],this[fe],this[yt]);this[Ye](null,e)}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.closeSync(e),this.emit("close")}}[Gt](e){let t=!0;try{this[He](null,B.default.writeSync(this[p],e,0,e.length,this[we])),t=!1}finally{if(t)try{this[$]()}catch{}}}};W.WriteStreamSync=us});var $t=d(b=>{"use strict";Object.defineProperty(b,"__esModule",{value:!0});b.dealias=b.isNoFile=b.isFile=b.isAsync=b.isSync=b.isAsyncNoFile=b.isSyncNoFile=b.isAsyncFile=b.isSyncFile=void 0;var zo=new Map([["C","cwd"],["f","file"],["z","gzip"],["P","preservePaths"],["U","unlink"],["strip-components","strip"],["stripComponents","strip"],["keep-newer","newer"],["keepNewer","newer"],["keep-newer-files","newer"],["keepNewerFiles","newer"],["k","keep"],["keep-existing","keep"],["keepExisting","keep"],["m","noMtime"],["no-mtime","noMtime"],["p","preserveOwner"],["L","follow"],["h","follow"],["onentry","onReadEntry"]]),ko=s=>!!s.sync&&!!s.file;b.isSyncFile=ko;var jo=s=>!s.sync&&!!s.file;b.isAsyncFile=jo;var xo=s=>!!s.sync&&!s.file;b.isSyncNoFile=xo;var Uo=s=>!s.sync&&!s.file;b.isAsyncNoFile=Uo;var qo=s=>!!s.sync;b.isSync=qo;var Wo=s=>!s.sync;b.isAsync=Wo;var Ho=s=>!!s.file;b.isFile=Ho;var Zo=s=>!s.file;b.isNoFile=Zo;var Go=s=>{let e=zo.get(s);return e||s},Yo=(s={})=>{if(!s)return{};let e={};for(let[t,i]of Object.entries(s)){let r=Go(t);e[r]=i}return e.chmod===void 0&&e.noChmod===!1&&(e.chmod=!0),delete e.noChmod,e};b.dealias=Yo});var Ve=d(Xt=>{"use strict";Object.defineProperty(Xt,"__esModule",{value:!0});Xt.makeCommand=void 0;var Et=$t(),Ko=(s,e,t,i,r)=>Object.assign((n=[],o,a)=>{Array.isArray(n)&&(o=n,n={}),typeof o=="function"&&(a=o,o=void 0),o=o?Array.from(o):[];let h=(0,Et.dealias)(n);if(r?.(h,o),(0,Et.isSyncFile)(h)){if(typeof a=="function")throw new TypeError("callback not supported for sync tar functions");return s(h,o)}else if((0,Et.isAsyncFile)(h)){let l=e(h,o);return a?l.then(()=>a(),a):l}else if((0,Et.isSyncNoFile)(h)){if(typeof a=="function")throw new TypeError("callback not supported for sync tar functions");return t(h,o)}else if((0,Et.isAsyncNoFile)(h)){if(typeof a=="function")throw new TypeError("callback only supported with file option");return i(h,o)}throw new Error("impossible options??")},{syncFile:s,asyncFile:e,syncNoFile:t,asyncNoFile:i,validate:r});Xt.makeCommand=Ko});var cs=d($e=>{"use strict";var Vo=$e&&$e.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty($e,"__esModule",{value:!0});$e.constants=void 0;var $o=Vo(require("zlib")),Xo=$o.default.constants||{ZLIB_VERNUM:4736};$e.constants=Object.freeze(Object.assign(Object.create(null),{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_VERSION_ERROR:-6,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,DEFLATE:1,INFLATE:2,GZIP:3,GUNZIP:4,DEFLATERAW:5,INFLATERAW:6,UNZIP:7,BROTLI_DECODE:8,BROTLI_ENCODE:9,Z_MIN_WINDOWBITS:8,Z_MAX_WINDOWBITS:15,Z_DEFAULT_WINDOWBITS:15,Z_MIN_CHUNK:64,Z_MAX_CHUNK:1/0,Z_DEFAULT_CHUNK:16384,Z_MIN_MEMLEVEL:1,Z_MAX_MEMLEVEL:9,Z_DEFAULT_MEMLEVEL:8,Z_MIN_LEVEL:-1,Z_MAX_LEVEL:9,Z_DEFAULT_LEVEL:-1,BROTLI_OPERATION_PROCESS:0,BROTLI_OPERATION_FLUSH:1,BROTLI_OPERATION_FINISH:2,BROTLI_OPERATION_EMIT_METADATA:3,BROTLI_MODE_GENERIC:0,BROTLI_MODE_TEXT:1,BROTLI_MODE_FONT:2,BROTLI_DEFAULT_MODE:0,BROTLI_MIN_QUALITY:0,BROTLI_MAX_QUALITY:11,BROTLI_DEFAULT_QUALITY:11,BROTLI_MIN_WINDOW_BITS:10,BROTLI_MAX_WINDOW_BITS:24,BROTLI_LARGE_MAX_WINDOW_BITS:30,BROTLI_DEFAULT_WINDOW:22,BROTLI_MIN_INPUT_BLOCK_BITS:16,BROTLI_MAX_INPUT_BLOCK_BITS:24,BROTLI_PARAM_MODE:0,BROTLI_PARAM_QUALITY:1,BROTLI_PARAM_LGWIN:2,BROTLI_PARAM_LGBLOCK:3,BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:4,BROTLI_PARAM_SIZE_HINT:5,BROTLI_PARAM_LARGE_WINDOW:6,BROTLI_PARAM_NPOSTFIX:7,BROTLI_PARAM_NDIRECT:8,BROTLI_DECODER_RESULT_ERROR:0,BROTLI_DECODER_RESULT_SUCCESS:1,BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:2,BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:0,BROTLI_DECODER_PARAM_LARGE_WINDOW:1,BROTLI_DECODER_NO_ERROR:0,BROTLI_DECODER_SUCCESS:1,BROTLI_DECODER_NEEDS_MORE_INPUT:2,BROTLI_DECODER_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:-1,BROTLI_DECODER_ERROR_FORMAT_RESERVED:-2,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:-3,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:-4,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:-5,BROTLI_DECODER_ERROR_FORMAT_CL_SPACE:-6,BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE:-7,BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT:-8,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1:-9,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2:-10,BROTLI_DECODER_ERROR_FORMAT_TRANSFORM:-11,BROTLI_DECODER_ERROR_FORMAT_DICTIONARY:-12,BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS:-13,BROTLI_DECODER_ERROR_FORMAT_PADDING_1:-14,BROTLI_DECODER_ERROR_FORMAT_PADDING_2:-15,BROTLI_DECODER_ERROR_FORMAT_DISTANCE:-16,BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET:-19,BROTLI_DECODER_ERROR_INVALID_ARGUMENTS:-20,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES:-21,BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS:-22,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP:-25,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1:-26,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2:-27,BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES:-30,BROTLI_DECODER_ERROR_UNREACHABLE:-31},Xo))});var Ts=d(f=>{"use strict";var Qo=f&&f.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),Jo=f&&f.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),ea=f&&f.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Qo(t,e,i[r]);return Jo(t,e),t}})(),ta=f&&f.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(f,"__esModule",{value:!0});f.ZstdDecompress=f.ZstdCompress=f.BrotliDecompress=f.BrotliCompress=f.Unzip=f.InflateRaw=f.DeflateRaw=f.Gunzip=f.Gzip=f.Inflate=f.Deflate=f.Zlib=f.ZlibError=f.constants=void 0;var ms=ta(require("assert")),Le=require("buffer"),ia=We(),Ur=ea(require("zlib")),te=cs(),sa=cs();Object.defineProperty(f,"constants",{enumerable:!0,get:function(){return sa.constants}});var ra=Le.Buffer.concat,qr=Object.getOwnPropertyDescriptor(Le.Buffer,"concat"),na=s=>s,fs=qr?.writable===!0||qr?.set!==void 0?s=>{Le.Buffer.concat=s?na:ra}:s=>{},Ae=Symbol("_superWrite"),Ie=class extends Error{code;errno;constructor(e,t){super("zlib: "+e.message,{cause:e}),this.code=e.code,this.errno=e.errno,this.code||(this.code="ZLIB_ERROR"),this.message="zlib: "+e.message,Error.captureStackTrace(this,t??this.constructor)}get name(){return"ZlibError"}};f.ZlibError=Ie;var ds=Symbol("flushFlag"),bt=class extends ia.Minipass{#e=!1;#i=!1;#s;#n;#r;#t;#o;get sawError(){return this.#e}get handle(){return this.#t}get flushFlag(){return this.#s}constructor(e,t){if(!e||typeof e!="object")throw new TypeError("invalid options for ZlibBase constructor");if(super(e),this.#s=e.flush??0,this.#n=e.finishFlush??0,this.#r=e.fullFlushFlag??0,typeof Ur[t]!="function")throw new TypeError("Compression method not supported: "+t);try{this.#t=new Ur[t](e)}catch(i){throw new Ie(i,this.constructor)}this.#o=i=>{this.#e||(this.#e=!0,this.close(),this.emit("error",i))},this.#t?.on("error",i=>this.#o(new Ie(i))),this.once("end",()=>this.close)}close(){this.#t&&(this.#t.close(),this.#t=void 0,this.emit("close"))}reset(){if(!this.#e)return(0,ms.default)(this.#t,"zlib binding closed"),this.#t.reset?.()}flush(e){this.ended||(typeof e!="number"&&(e=this.#r),this.write(Object.assign(Le.Buffer.alloc(0),{[ds]:e})))}end(e,t,i){return typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),e&&(t?this.write(e,t):this.write(e)),this.flush(this.#n),this.#i=!0,super.end(i)}get ended(){return this.#i}[Ae](e){return super.write(e)}write(e,t,i){if(typeof t=="function"&&(i=t,t="utf8"),typeof e=="string"&&(e=Le.Buffer.from(e,t)),this.#e)return;(0,ms.default)(this.#t,"zlib binding closed");let r=this.#t._handle,n=r.close;r.close=()=>{};let o=this.#t.close;this.#t.close=()=>{},fs(!0);let a;try{let l=typeof e[ds]=="number"?e[ds]:this.#s;a=this.#t._processChunk(e,l),fs(!1)}catch(l){fs(!1),this.#o(new Ie(l,this.write))}finally{this.#t&&(this.#t._handle=r,r.close=n,this.#t.close=o,this.#t.removeAllListeners("error"))}this.#t&&this.#t.on("error",l=>this.#o(new Ie(l,this.write)));let h;if(a)if(Array.isArray(a)&&a.length>0){let l=a[0];h=this[Ae](Le.Buffer.from(l));for(let u=1;u<a.length;u++)h=this[Ae](a[u])}else h=this[Ae](Le.Buffer.from(a));return i&&i(),h}},ie=class extends bt{#e;#i;constructor(e,t){e=e||{},e.flush=e.flush||te.constants.Z_NO_FLUSH,e.finishFlush=e.finishFlush||te.constants.Z_FINISH,e.fullFlushFlag=te.constants.Z_FULL_FLUSH,super(e,t),this.#e=e.level,this.#i=e.strategy}params(e,t){if(!this.sawError){if(!this.handle)throw new Error("cannot switch params when binding is closed");if(!this.handle.params)throw new Error("not supported in this implementation");if(this.#e!==e||this.#i!==t){this.flush(te.constants.Z_SYNC_FLUSH),(0,ms.default)(this.handle,"zlib binding closed");let i=this.handle.flush;this.handle.flush=(r,n)=>{typeof r=="function"&&(n=r,r=this.flushFlag),this.flush(r),n?.()};try{this.handle.params(e,t)}finally{this.handle.flush=i}this.handle&&(this.#e=e,this.#i=t)}}}};f.Zlib=ie;var ps=class extends ie{constructor(e){super(e,"Deflate")}};f.Deflate=ps;var _s=class extends ie{constructor(e){super(e,"Inflate")}};f.Inflate=_s;var ws=class extends ie{#e;constructor(e){super(e,"Gzip"),this.#e=e&&!!e.portable}[Ae](e){return this.#e?(this.#e=!1,e[9]=255,super[Ae](e)):super[Ae](e)}};f.Gzip=ws;var ys=class extends ie{constructor(e){super(e,"Gunzip")}};f.Gunzip=ys;var Es=class extends ie{constructor(e){super(e,"DeflateRaw")}};f.DeflateRaw=Es;var bs=class extends ie{constructor(e){super(e,"InflateRaw")}};f.InflateRaw=bs;var Ss=class extends ie{constructor(e){super(e,"Unzip")}};f.Unzip=Ss;var Qt=class extends bt{constructor(e,t){e=e||{},e.flush=e.flush||te.constants.BROTLI_OPERATION_PROCESS,e.finishFlush=e.finishFlush||te.constants.BROTLI_OPERATION_FINISH,e.fullFlushFlag=te.constants.BROTLI_OPERATION_FLUSH,super(e,t)}},gs=class extends Qt{constructor(e){super(e,"BrotliCompress")}};f.BrotliCompress=gs;var Os=class extends Qt{constructor(e){super(e,"BrotliDecompress")}};f.BrotliDecompress=Os;var Jt=class extends bt{constructor(e,t){e=e||{},e.flush=e.flush||te.constants.ZSTD_e_continue,e.finishFlush=e.finishFlush||te.constants.ZSTD_e_end,e.fullFlushFlag=te.constants.ZSTD_e_flush,super(e,t)}},Rs=class extends Jt{constructor(e){super(e,"ZstdCompress")}};f.ZstdCompress=Rs;var vs=class extends Jt{constructor(e){super(e,"ZstdDecompress")}};f.ZstdDecompress=vs});var Zr=d(Xe=>{"use strict";Object.defineProperty(Xe,"__esModule",{value:!0});Xe.parse=Xe.encode=void 0;var oa=(s,e)=>{if(Number.isSafeInteger(s))s<0?ha(s,e):aa(s,e);else throw Error("cannot encode number outside of javascript safe integer range");return e};Xe.encode=oa;var aa=(s,e)=>{e[0]=128;for(var t=e.length;t>1;t--)e[t-1]=s&255,s=Math.floor(s/256)},ha=(s,e)=>{e[0]=255;var t=!1;s=s*-1;for(var i=e.length;i>1;i--){var r=s&255;s=Math.floor(s/256),t?e[i-1]=Wr(r):r===0?e[i-1]=0:(t=!0,e[i-1]=Hr(r))}},la=s=>{let e=s[0],t=e===128?ca(s.subarray(1,s.length)):e===255?ua(s):null;if(t===null)throw Error("invalid base256 encoding");if(!Number.isSafeInteger(t))throw Error("parsed number outside of javascript safe integer range");return t};Xe.parse=la;var ua=s=>{for(var e=s.length,t=0,i=!1,r=e-1;r>-1;r--){var n=Number(s[r]),o;i?o=Wr(n):n===0?o=n:(i=!0,o=Hr(n)),o!==0&&(t-=o*Math.pow(256,e-r-1))}return t},ca=s=>{for(var e=s.length,t=0,i=e-1;i>-1;i--){var r=Number(s[i]);r!==0&&(t+=r*Math.pow(256,e-i-1))}return t},Wr=s=>(255^s)&255,Hr=s=>(255^s)+1&255});var Ds=d(j=>{"use strict";Object.defineProperty(j,"__esModule",{value:!0});j.code=j.name=j.isName=j.isCode=void 0;var fa=s=>j.name.has(s);j.isCode=fa;var da=s=>j.code.has(s);j.isName=da;j.name=new Map([["0","File"],["","OldFile"],["1","Link"],["2","SymbolicLink"],["3","CharacterDevice"],["4","BlockDevice"],["5","Directory"],["6","FIFO"],["7","ContiguousFile"],["g","GlobalExtendedHeader"],["x","ExtendedHeader"],["A","SolarisACL"],["D","GNUDumpDir"],["I","Inode"],["K","NextFileHasLongLinkpath"],["L","NextFileHasLongPath"],["M","ContinuationFile"],["N","OldGnuLongPath"],["S","SparseFile"],["V","TapeVolumeHeader"],["X","OldExtendedHeader"]]);j.code=new Map(Array.from(j.name).map(s=>[s[1],s[0]]))});var Je=d(se=>{"use strict";var ma=se&&se.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),pa=se&&se.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),Gr=se&&se.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&ma(t,e,i[r]);return pa(t,e),t}})();Object.defineProperty(se,"__esModule",{value:!0});se.Header=void 0;var Qe=require("node:path"),Yr=Gr(Zr()),St=Gr(Ds()),Ms=class{cksumValid=!1;needPax=!1;nullBlock=!1;block;path;mode;uid;gid;size;cksum;#e="Unsupported";linkpath;uname;gname;devmaj=0;devmin=0;atime;ctime;mtime;charset;comment;constructor(e,t=0,i,r){Buffer.isBuffer(e)?this.decode(e,t||0,i,r):e&&this.#i(e)}decode(e,t,i,r){if(t||(t=0),!e||!(e.length>=t+512))throw new Error("need 512 bytes for header");this.path=i?.path??Fe(e,t,100),this.mode=i?.mode??r?.mode??be(e,t+100,8),this.uid=i?.uid??r?.uid??be(e,t+108,8),this.gid=i?.gid??r?.gid??be(e,t+116,8),this.size=i?.size??r?.size??be(e,t+124,12),this.mtime=i?.mtime??r?.mtime??Ps(e,t+136,12),this.cksum=be(e,t+148,12),r&&this.#i(r,!0),i&&this.#i(i);let n=Fe(e,t+156,1);if(St.isCode(n)&&(this.#e=n||"0"),this.#e==="0"&&this.path.slice(-1)==="/"&&(this.#e="5"),this.#e==="5"&&(this.size=0),this.linkpath=Fe(e,t+157,100),e.subarray(t+257,t+265).toString()==="ustar\x0000")if(this.uname=i?.uname??r?.uname??Fe(e,t+265,32),this.gname=i?.gname??r?.gname??Fe(e,t+297,32),this.devmaj=i?.devmaj??r?.devmaj??be(e,t+329,8)??0,this.devmin=i?.devmin??r?.devmin??be(e,t+337,8)??0,e[t+475]!==0){let a=Fe(e,t+345,155);this.path=a+"/"+this.path}else{let a=Fe(e,t+345,130);a&&(this.path=a+"/"+this.path),this.atime=i?.atime??r?.atime??Ps(e,t+476,12),this.ctime=i?.ctime??r?.ctime??Ps(e,t+488,12)}let o=256;for(let a=t;a<t+148;a++)o+=e[a];for(let a=t+156;a<t+512;a++)o+=e[a];this.cksumValid=o===this.cksum,this.cksum===void 0&&o===256&&(this.nullBlock=!0)}#i(e,t=!1){Object.assign(this,Object.fromEntries(Object.entries(e).filter(([i,r])=>!(r==null||i==="path"&&t||i==="linkpath"&&t||i==="global"))))}encode(e,t=0){if(e||(e=this.block=Buffer.alloc(512)),this.#e==="Unsupported"&&(this.#e="0"),!(e.length>=t+512))throw new Error("need 512 bytes for header");let i=this.ctime||this.atime?130:155,r=_a(this.path||"",i),n=r[0],o=r[1];this.needPax=!!r[2],this.needPax=Ce(e,t,100,n)||this.needPax,this.needPax=Se(e,t+100,8,this.mode)||this.needPax,this.needPax=Se(e,t+108,8,this.uid)||this.needPax,this.needPax=Se(e,t+116,8,this.gid)||this.needPax,this.needPax=Se(e,t+124,12,this.size)||this.needPax,this.needPax=Ns(e,t+136,12,this.mtime)||this.needPax,e[t+156]=Number(this.#e.codePointAt(0)),this.needPax=Ce(e,t+157,100,this.linkpath)||this.needPax,e.write("ustar\x0000",t+257,8),this.needPax=Ce(e,t+265,32,this.uname)||this.needPax,this.needPax=Ce(e,t+297,32,this.gname)||this.needPax,this.needPax=Se(e,t+329,8,this.devmaj)||this.needPax,this.needPax=Se(e,t+337,8,this.devmin)||this.needPax,this.needPax=Ce(e,t+345,i,o)||this.needPax,e[t+475]!==0?this.needPax=Ce(e,t+345,155,o)||this.needPax:(this.needPax=Ce(e,t+345,130,o)||this.needPax,this.needPax=Ns(e,t+476,12,this.atime)||this.needPax,this.needPax=Ns(e,t+488,12,this.ctime)||this.needPax);let a=256;for(let h=t;h<t+148;h++)a+=e[h];for(let h=t+156;h<t+512;h++)a+=e[h];return this.cksum=a,Se(e,t+148,8,this.cksum),this.cksumValid=!0,this.needPax}get type(){return this.#e==="Unsupported"?this.#e:St.name.get(this.#e)}get typeKey(){return this.#e}set type(e){let t=String(St.code.get(e));if(St.isCode(t)||t==="Unsupported")this.#e=t;else if(St.isCode(e))this.#e=e;else throw new TypeError("invalid entry type: "+e)}};se.Header=Ms;var _a=(s,e)=>{let i=s,r="",n,o=Qe.posix.parse(s).root||".";if(Buffer.byteLength(i)<100)n=[i,r,!1];else{r=Qe.posix.dirname(i),i=Qe.posix.basename(i);do Buffer.byteLength(i)<=100&&Buffer.byteLength(r)<=e?n=[i,r,!1]:Buffer.byteLength(i)>100&&Buffer.byteLength(r)<=e?n=[i.slice(0,99),r,!0]:(i=Qe.posix.join(Qe.posix.basename(r),i),r=Qe.posix.dirname(r));while(r!==o&&n===void 0);n||(n=[s.slice(0,99),"",!0])}return n},Fe=(s,e,t)=>s.subarray(e,e+t).toString("utf8").replace(/\0.*/,""),Ps=(s,e,t)=>wa(be(s,e,t)),wa=s=>s===void 0?void 0:new Date(s*1e3),be=(s,e,t)=>Number(s[e])&128?Yr.parse(s.subarray(e,e+t)):Ea(s,e,t),ya=s=>isNaN(s)?void 0:s,Ea=(s,e,t)=>ya(parseInt(s.subarray(e,e+t).toString("utf8").replace(/\0.*$/,"").trim(),8)),ba={12:8589934591,8:2097151},Se=(s,e,t,i)=>i===void 0?!1:i>ba[t]||i<0?(Yr.encode(i,s.subarray(e,e+t)),!0):(Sa(s,e,t,i),!1),Sa=(s,e,t,i)=>s.write(ga(i,t),e,t,"ascii"),ga=(s,e)=>Oa(Math.floor(s).toString(8),e),Oa=(s,e)=>(s.length===e-1?s:new Array(e-s.length-1).join("0")+s+" ")+"\0",Ns=(s,e,t,i)=>i===void 0?!1:Se(s,e,t,i.getTime()/1e3),Ra=new Array(156).join("\0"),Ce=(s,e,t,i)=>i===void 0?!1:(s.write(i+Ra,e,t,"utf8"),i.length!==Buffer.byteLength(i)||i.length>t)});var ti=d(ei=>{"use strict";Object.defineProperty(ei,"__esModule",{value:!0});ei.Pax=void 0;var va=require("node:path"),Ta=Je(),Ls=class s{atime;mtime;ctime;charset;comment;gid;uid;gname;uname;linkpath;dev;ino;nlink;path;size;mode;global;constructor(e,t=!1){this.atime=e.atime,this.charset=e.charset,this.comment=e.comment,this.ctime=e.ctime,this.dev=e.dev,this.gid=e.gid,this.global=t,this.gname=e.gname,this.ino=e.ino,this.linkpath=e.linkpath,this.mtime=e.mtime,this.nlink=e.nlink,this.path=e.path,this.size=e.size,this.uid=e.uid,this.uname=e.uname}encode(){let e=this.encodeBody();if(e==="")return Buffer.allocUnsafe(0);let t=Buffer.byteLength(e),i=512*Math.ceil(1+t/512),r=Buffer.allocUnsafe(i);for(let n=0;n<512;n++)r[n]=0;new Ta.Header({path:("PaxHeader/"+(0,va.basename)(this.path??"")).slice(0,99),mode:this.mode||420,uid:this.uid,gid:this.gid,size:t,mtime:this.mtime,type:this.global?"GlobalExtendedHeader":"ExtendedHeader",linkpath:"",uname:this.uname||"",gname:this.gname||"",devmaj:0,devmin:0,atime:this.atime,ctime:this.ctime}).encode(r),r.write(e,512,t,"utf8");for(let n=t+512;n<r.length;n++)r[n]=0;return r}encodeBody(){return this.encodeField("path")+this.encodeField("ctime")+this.encodeField("atime")+this.encodeField("dev")+this.encodeField("ino")+this.encodeField("nlink")+this.encodeField("charset")+this.encodeField("comment")+this.encodeField("gid")+this.encodeField("gname")+this.encodeField("linkpath")+this.encodeField("mtime")+this.encodeField("size")+this.encodeField("uid")+this.encodeField("uname")}encodeField(e){if(this[e]===void 0)return"";let t=this[e],i=t instanceof Date?t.getTime()/1e3:t,r=" "+(e==="dev"||e==="ino"||e==="nlink"?"SCHILY.":"")+e+"="+i+`
-`,n=Buffer.byteLength(r),o=Math.floor(Math.log(n)/Math.log(10))+1;return n+o>=Math.pow(10,o)&&(o+=1),o+n+r}static parse(e,t,i=!1){return new s(Da(Pa(e),t),i)}};ei.Pax=Ls;var Da=(s,e)=>e?Object.assign({},e,s):s,Pa=s=>s.replace(/\n$/,"").split(`
-`).reduce(Na,Object.create(null)),Na=(s,e)=>{let t=parseInt(e,10);if(t!==Buffer.byteLength(e)+1)return s;e=e.slice((t+" ").length);let i=e.split("="),r=i.shift();if(!r)return s;let n=r.replace(/^SCHILY\.(dev|ino|nlink)/,"$1"),o=i.join("=");return s[n]=/^([A-Z]+\.)?([mac]|birth|creation)time$/.test(n)?new Date(Number(o)*1e3):/^[0-9]+$/.test(o)?+o:o,s}});var et=d(ii=>{"use strict";Object.defineProperty(ii,"__esModule",{value:!0});ii.normalizeWindowsPath=void 0;var Ma=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform;ii.normalizeWindowsPath=Ma!=="win32"?s=>s:s=>s&&s.replaceAll(/\\/g,"/")});var ni=d(ri=>{"use strict";Object.defineProperty(ri,"__esModule",{value:!0});ri.ReadEntry=void 0;var La=We(),si=et(),As=class extends La.Minipass{extended;globalExtended;header;startBlockSize;blockRemain;remain;type;meta=!1;ignore=!1;path;mode;uid;gid;uname;gname;size=0;mtime;atime;ctime;linkpath;dev;ino;nlink;invalid=!1;absolute;unsupported=!1;constructor(e,t,i){switch(super({}),this.pause(),this.extended=t,this.globalExtended=i,this.header=e,this.remain=e.size??0,this.startBlockSize=512*Math.ceil(this.remain/512),this.blockRemain=this.startBlockSize,this.type=e.type,this.type){case"File":case"OldFile":case"Link":case"SymbolicLink":case"CharacterDevice":case"BlockDevice":case"Directory":case"FIFO":case"ContiguousFile":case"GNUDumpDir":break;case"NextFileHasLongLinkpath":case"NextFileHasLongPath":case"OldGnuLongPath":case"GlobalExtendedHeader":case"ExtendedHeader":case"OldExtendedHeader":this.meta=!0;break;default:this.ignore=!0}if(!e.path)throw new Error("no path provided for tar.ReadEntry");this.path=(0,si.normalizeWindowsPath)(e.path),this.mode=e.mode,this.mode&&(this.mode=this.mode&4095),this.uid=e.uid,this.gid=e.gid,this.uname=e.uname,this.gname=e.gname,this.size=this.remain,this.mtime=e.mtime,this.atime=e.atime,this.ctime=e.ctime,this.linkpath=e.linkpath?(0,si.normalizeWindowsPath)(e.linkpath):void 0,this.uname=e.uname,this.gname=e.gname,t&&this.#e(t),i&&this.#e(i,!0)}write(e){let t=e.length;if(t>this.blockRemain)throw new Error("writing more to entry than is appropriate");let i=this.remain,r=this.blockRemain;return this.remain=Math.max(0,i-t),this.blockRemain=Math.max(0,r-t),this.ignore?!0:i>=t?super.write(e):super.write(e.subarray(0,i))}#e(e,t=!1){e.path&&(e.path=(0,si.normalizeWindowsPath)(e.path)),e.linkpath&&(e.linkpath=(0,si.normalizeWindowsPath)(e.linkpath)),Object.assign(this,Object.fromEntries(Object.entries(e).filter(([i,r])=>!(r==null||i==="path"&&t))))}};ri.ReadEntry=As});var ai=d(oi=>{"use strict";Object.defineProperty(oi,"__esModule",{value:!0});oi.warnMethod=void 0;var Aa=(s,e,t,i={})=>{s.file&&(i.file=s.file),s.cwd&&(i.cwd=s.cwd),i.code=t instanceof Error&&t.code||e,i.tarCode=e,!s.strict&&i.recoverable!==!1?(t instanceof Error&&(i=Object.assign(t,i),t=t.message),s.emit("warn",e,t,i)):t instanceof Error?s.emit("error",Object.assign(t,i)):s.emit("error",Object.assign(new Error(`${e}: ${t}`),i))};oi.warnMethod=Aa});var pi=d(mi=>{"use strict";Object.defineProperty(mi,"__esModule",{value:!0});mi.Parser=void 0;var Ia=require("events"),Is=Ts(),Kr=Je(),Vr=ti(),Fa=ni(),Ca=ai(),Ba=1024*1024,ks=Buffer.from([31,139]),js=Buffer.from([40,181,47,253]),za=Math.max(ks.length,js.length),H=Symbol("state"),Be=Symbol("writeEntry"),de=Symbol("readEntry"),Fs=Symbol("nextEntry"),$r=Symbol("processEntry"),re=Symbol("extendedHeader"),gt=Symbol("globalExtendedHeader"),ge=Symbol("meta"),Xr=Symbol("emitMeta"),_=Symbol("buffer"),me=Symbol("queue"),Oe=Symbol("ended"),Cs=Symbol("emittedEnd"),ze=Symbol("emit"),S=Symbol("unzip"),hi=Symbol("consumeChunk"),li=Symbol("consumeChunkSub"),Bs=Symbol("consumeBody"),Qr=Symbol("consumeMeta"),Jr=Symbol("consumeHeader"),Ot=Symbol("consuming"),zs=Symbol("bufferConcat"),ui=Symbol("maybeEnd"),tt=Symbol("writing"),Re=Symbol("aborted"),ci=Symbol("onDone"),ke=Symbol("sawValidEntry"),fi=Symbol("sawNullBlock"),di=Symbol("sawEOF"),en=Symbol("closeStream"),ka=()=>!0,xs=class extends Ia.EventEmitter{file;strict;maxMetaEntrySize;filter;brotli;zstd;writable=!0;readable=!1;[me]=[];[_];[de];[Be];[H]="begin";[ge]="";[re];[gt];[Oe]=!1;[S];[Re]=!1;[ke];[fi]=!1;[di]=!1;[tt]=!1;[Ot]=!1;[Cs]=!1;constructor(e={}){super(),this.file=e.file||"",this.on(ci,()=>{(this[H]==="begin"||this[ke]===!1)&&this.warn("TAR_BAD_ARCHIVE","Unrecognized archive format")}),e.ondone?this.on(ci,e.ondone):this.on(ci,()=>{this.emit("prefinish"),this.emit("finish"),this.emit("end")}),this.strict=!!e.strict,this.maxMetaEntrySize=e.maxMetaEntrySize||Ba,this.filter=typeof e.filter=="function"?e.filter:ka;let t=e.file&&(e.file.endsWith(".tar.br")||e.file.endsWith(".tbr"));this.brotli=!(e.gzip||e.zstd)&&e.brotli!==void 0?e.brotli:t?void 0:!1;let i=e.file&&(e.file.endsWith(".tar.zst")||e.file.endsWith(".tzst"));this.zstd=!(e.gzip||e.brotli)&&e.zstd!==void 0?e.zstd:i?!0:void 0,this.on("end",()=>this[en]()),typeof e.onwarn=="function"&&this.on("warn",e.onwarn),typeof e.onReadEntry=="function"&&this.on("entry",e.onReadEntry)}warn(e,t,i={}){(0,Ca.warnMethod)(this,e,t,i)}[Jr](e,t){this[ke]===void 0&&(this[ke]=!1);let i;try{i=new Kr.Header(e,t,this[re],this[gt])}catch(r){return this.warn("TAR_ENTRY_INVALID",r)}if(i.nullBlock)this[fi]?(this[di]=!0,this[H]==="begin"&&(this[H]="header"),this[ze]("eof")):(this[fi]=!0,this[ze]("nullBlock"));else if(this[fi]=!1,!i.cksumValid)this.warn("TAR_ENTRY_INVALID","checksum failure",{header:i});else if(!i.path)this.warn("TAR_ENTRY_INVALID","path is required",{header:i});else{let r=i.type;if(/^(Symbolic)?Link$/.test(r)&&!i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath required",{header:i});else if(!/^(Symbolic)?Link$/.test(r)&&!/^(Global)?ExtendedHeader$/.test(r)&&i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath forbidden",{header:i});else{let n=this[Be]=new Fa.ReadEntry(i,this[re],this[gt]);if(!this[ke])if(n.remain){let o=()=>{n.invalid||(this[ke]=!0)};n.on("end",o)}else this[ke]=!0;n.meta?n.size>this.maxMetaEntrySize?(n.ignore=!0,this[ze]("ignoredEntry",n),this[H]="ignore",n.resume()):n.size>0&&(this[ge]="",n.on("data",o=>this[ge]+=o),this[H]="meta"):(this[re]=void 0,n.ignore=n.ignore||!this.filter(n.path,n),n.ignore?(this[ze]("ignoredEntry",n),this[H]=n.remain?"ignore":"header",n.resume()):(n.remain?this[H]="body":(this[H]="header",n.end()),this[de]?this[me].push(n):(this[me].push(n),this[Fs]())))}}}[en](){queueMicrotask(()=>this.emit("close"))}[$r](e){let t=!0;if(!e)this[de]=void 0,t=!1;else if(Array.isArray(e)){let[i,...r]=e;this.emit(i,...r)}else this[de]=e,this.emit("entry",e),e.emittedEnd||(e.on("end",()=>this[Fs]()),t=!1);return t}[Fs](){do;while(this[$r](this[me].shift()));if(this[me].length===0){let e=this[de];!e||e.flowing||e.size===e.remain?this[tt]||this.emit("drain"):e.once("drain",()=>this.emit("drain"))}}[Bs](e,t){let i=this[Be];if(!i)throw new Error("attempt to consume body without entry??");let r=i.blockRemain??0,n=r>=e.length&&t===0?e:e.subarray(t,t+r);return i.write(n),i.blockRemain||(this[H]="header",this[Be]=void 0,i.end()),n.length}[Qr](e,t){let i=this[Be],r=this[Bs](e,t);return!this[Be]&&i&&this[Xr](i),r}[ze](e,t,i){this[me].length===0&&!this[de]?this.emit(e,t,i):this[me].push([e,t,i])}[Xr](e){switch(this[ze]("meta",this[ge]),e.type){case"ExtendedHeader":case"OldExtendedHeader":this[re]=Vr.Pax.parse(this[ge],this[re],!1);break;case"GlobalExtendedHeader":this[gt]=Vr.Pax.parse(this[ge],this[gt],!0);break;case"NextFileHasLongPath":case"OldGnuLongPath":{let t=this[re]??Object.create(null);this[re]=t,t.path=this[ge].replace(/\0.*/,"");break}case"NextFileHasLongLinkpath":{let t=this[re]||Object.create(null);this[re]=t,t.linkpath=this[ge].replace(/\0.*/,"");break}default:throw new Error("unknown meta: "+e.type)}}abort(e){this[Re]=!0,this.emit("abort",e),this.warn("TAR_ABORT",e,{recoverable:!1})}write(e,t,i){if(typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8")),this[Re])return i?.(),!1;if((this[S]===void 0||this.brotli===void 0&&this[S]===!1)&&e){if(this[_]&&(e=Buffer.concat([this[_],e]),this[_]=void 0),e.length<za)return this[_]=e,i?.(),!0;for(let h=0;this[S]===void 0&&h<ks.length;h++)e[h]!==ks[h]&&(this[S]=!1);let o=!1;if(this[S]===!1&&this.zstd!==!1){o=!0;for(let h=0;h<js.length;h++)if(e[h]!==js[h]){o=!1;break}}let a=this.brotli===void 0&&!o;if(this[S]===!1&&a)if(e.length<512)if(this[Oe])this.brotli=!0;else return this[_]=e,i?.(),!0;else try{new Kr.Header(e.subarray(0,512)),this.brotli=!1}catch{this.brotli=!0}if(this[S]===void 0||this[S]===!1&&(this.brotli||o)){let h=this[Oe];this[Oe]=!1,this[S]=this[S]===void 0?new Is.Unzip({}):o?new Is.ZstdDecompress({}):new Is.BrotliDecompress({}),this[S].on("data",u=>this[hi](u)),this[S].on("error",u=>this.abort(u)),this[S].on("end",()=>{this[Oe]=!0,this[hi]()}),this[tt]=!0;let l=!!this[S][h?"end":"write"](e);return this[tt]=!1,i?.(),l}}this[tt]=!0,this[S]?this[S].write(e):this[hi](e),this[tt]=!1;let n=this[me].length>0?!1:this[de]?this[de].flowing:!0;return!n&&this[me].length===0&&this[de]?.once("drain",()=>this.emit("drain")),i?.(),n}[zs](e){e&&!this[Re]&&(this[_]=this[_]?Buffer.concat([this[_],e]):e)}[ui](){if(this[Oe]&&!this[Cs]&&!this[Re]&&!this[Ot]){this[Cs]=!0;let e=this[Be];if(e&&e.blockRemain){let t=this[_]?this[_].length:0;this.warn("TAR_BAD_ARCHIVE",`Truncated input (needed ${e.blockRemain} more bytes, only ${t} available)`,{entry:e}),this[_]&&e.write(this[_]),e.end()}this[ze](ci)}}[hi](e){if(this[Ot]&&e)this[zs](e);else if(!e&&!this[_])this[ui]();else if(e){if(this[Ot]=!0,this[_]){this[zs](e);let t=this[_];this[_]=void 0,this[li](t)}else this[li](e);for(;this[_]&&this[_]?.length>=512&&!this[Re]&&!this[di];){let t=this[_];this[_]=void 0,this[li](t)}this[Ot]=!1}(!this[_]||this[Oe])&&this[ui]()}[li](e){let t=0,i=e.length;for(;t+512<=i&&!this[Re]&&!this[di];)switch(this[H]){case"begin":case"header":this[Jr](e,t),t+=512;break;case"ignore":case"body":t+=this[Bs](e,t);break;case"meta":t+=this[Qr](e,t);break;default:throw new Error("invalid state: "+this[H])}t<i&&(this[_]=this[_]?Buffer.concat([e.subarray(t),this[_]]):e.subarray(t))}end(e,t,i){return typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,t)),i&&this.once("finish",i),this[Re]||(this[S]?(e&&this[S].write(e),this[S].end()):(this[Oe]=!0,(this.brotli===void 0||this.zstd===void 0)&&(e=e||Buffer.alloc(0)),e&&this.write(e),this[ui]())),this}};mi.Parser=xs});var wi=d(_i=>{"use strict";Object.defineProperty(_i,"__esModule",{value:!0});_i.stripTrailingSlashes=void 0;var ja=s=>{let e=s.length-1,t=-1;for(;e>-1&&s.charAt(e)==="/";)t=e,e--;return t===-1?s:s.slice(0,t)};_i.stripTrailingSlashes=ja});var st=d(C=>{"use strict";var xa=C&&C.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),Ua=C&&C.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),qa=C&&C.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&xa(t,e,i[r]);return Ua(t,e),t}})(),Wa=C&&C.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(C,"__esModule",{value:!0});C.list=C.filesFilter=void 0;var Ha=qa(Ke()),it=Wa(require("node:fs")),tn=require("path"),Za=Ve(),yi=pi(),Us=wi(),Ga=s=>{let e=s.onReadEntry;s.onReadEntry=e?t=>{e(t),t.resume()}:t=>t.resume()},Ya=(s,e)=>{let t=new Map(e.map(n=>[(0,Us.stripTrailingSlashes)(n),!0])),i=s.filter,r=(n,o="")=>{let a=o||(0,tn.parse)(n).root||".",h;if(n===a)h=!1;else{let l=t.get(n);h=l!==void 0?l:r((0,tn.dirname)(n),a)}return t.set(n,h),h};s.filter=i?(n,o)=>i(n,o)&&r((0,Us.stripTrailingSlashes)(n)):n=>r((0,Us.stripTrailingSlashes)(n))};C.filesFilter=Ya;var Ka=s=>{let e=new yi.Parser(s),t=s.file,i;try{i=it.default.openSync(t,"r");let r=it.default.fstatSync(i),n=s.maxReadSize||16*1024*1024;if(r.size<n){let o=Buffer.allocUnsafe(r.size),a=it.default.readSync(i,o,0,r.size,0);e.end(a===o.byteLength?o:o.subarray(0,a))}else{let o=0,a=Buffer.allocUnsafe(n);for(;o<r.size;){let h=it.default.readSync(i,a,0,n,o);if(h===0)break;o+=h,e.write(a.subarray(0,h))}e.end()}}finally{if(typeof i=="number")try{it.default.closeSync(i)}catch{}}},Va=(s,e)=>{let t=new yi.Parser(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,a)=>{t.on("error",a),t.on("end",o),it.default.stat(r,(h,l)=>{if(h)a(h);else{let u=new Ha.ReadStream(r,{readSize:i,size:l.size});u.on("error",a),u.pipe(t)}})})};C.list=(0,Za.makeCommand)(Ka,Va,s=>new yi.Parser(s),s=>new yi.Parser(s),(s,e)=>{e?.length&&(0,C.filesFilter)(s,e),s.noResume||Ga(s)})});var sn=d(Ei=>{"use strict";Object.defineProperty(Ei,"__esModule",{value:!0});Ei.modeFix=void 0;var $a=(s,e,t)=>(s&=4095,t&&(s=(s|384)&-19),e&&(s&256&&(s|=64),s&32&&(s|=8),s&4&&(s|=1)),s);Ei.modeFix=$a});var qs=d(bi=>{"use strict";Object.defineProperty(bi,"__esModule",{value:!0});bi.stripAbsolutePath=void 0;var Xa=require("node:path"),{isAbsolute:Qa,parse:rn}=Xa.win32,Ja=s=>{let e="",t=rn(s);for(;Qa(s)||t.root;){let i=s.charAt(0)==="/"&&s.slice(0,4)!=="//?/"?"/":t.root;s=s.slice(i.length),e+=i,t=rn(s)}return[e,s]};bi.stripAbsolutePath=Ja});var Hs=d(rt=>{"use strict";Object.defineProperty(rt,"__esModule",{value:!0});rt.decode=rt.encode=void 0;var Si=["|","<",">","?",":"],Ws=Si.map(s=>String.fromCodePoint(61440+Number(s.codePointAt(0)))),eh=new Map(Si.map((s,e)=>[s,Ws[e]])),th=new Map(Ws.map((s,e)=>[s,Si[e]])),ih=s=>Si.reduce((e,t)=>e.split(t).join(eh.get(t)),s);rt.encode=ih;var sh=s=>Ws.reduce((e,t)=>e.split(t).join(th.get(t)),s);rt.decode=sh});var tr=d(M=>{"use strict";var rh=M&&M.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),nh=M&&M.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),oh=M&&M.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&rh(t,e,i[r]);return nh(t,e),t}})(),un=M&&M.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(M,"__esModule",{value:!0});M.WriteEntryTar=M.WriteEntrySync=M.WriteEntry=void 0;var oe=un(require("fs")),cn=We(),nn=un(require("path")),fn=Je(),dn=sn(),ne=et(),mn=$t(),pn=ti(),_n=qs(),ah=wi(),wn=ai(),hh=oh(Hs()),yn=(s,e)=>e?(s=(0,ne.normalizeWindowsPath)(s).replace(/^\.(\/|$)/,""),(0,ah.stripTrailingSlashes)(e)+"/"+s):(0,ne.normalizeWindowsPath)(s),lh=16*1024*1024,on=Symbol("process"),an=Symbol("file"),hn=Symbol("directory"),Gs=Symbol("symlink"),ln=Symbol("hardlink"),Rt=Symbol("header"),gi=Symbol("read"),Ys=Symbol("lstat"),Oi=Symbol("onlstat"),Ks=Symbol("onread"),Vs=Symbol("onreadlink"),$s=Symbol("openfile"),Xs=Symbol("onopenfile"),ve=Symbol("close"),Ri=Symbol("mode"),Qs=Symbol("awaitDrain"),Zs=Symbol("ondrain"),ae=Symbol("prefix"),vi=class extends cn.Minipass{path;portable;myuid=process.getuid&&process.getuid()||0;myuser=process.env.USER||"";maxReadSize;linkCache;statCache;preservePaths;cwd;strict;mtime;noPax;noMtime;prefix;fd;blockLen=0;blockRemain=0;buf;pos=0;remain=0;length=0;offset=0;win32;absolute;header;type;linkpath;stat;onWriteEntry;#e=!1;constructor(e,t={}){let i=(0,mn.dealias)(t);super(),this.path=(0,ne.normalizeWindowsPath)(e),this.portable=!!i.portable,this.maxReadSize=i.maxReadSize||lh,this.linkCache=i.linkCache||new Map,this.statCache=i.statCache||new Map,this.preservePaths=!!i.preservePaths,this.cwd=(0,ne.normalizeWindowsPath)(i.cwd||process.cwd()),this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.mtime=i.mtime,this.prefix=i.prefix?(0,ne.normalizeWindowsPath)(i.prefix):void 0,this.onWriteEntry=i.onWriteEntry,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let r=!1;if(!this.preservePaths){let[o,a]=(0,_n.stripAbsolutePath)(this.path);o&&typeof a=="string"&&(this.path=a,r=o)}this.win32=!!i.win32||process.platform==="win32",this.win32&&(this.path=hh.decode(this.path.replaceAll(/\\/g,"/")),e=e.replaceAll(/\\/g,"/")),this.absolute=(0,ne.normalizeWindowsPath)(i.absolute||nn.default.resolve(this.cwd,e)),this.path===""&&(this.path="./"),r&&this.warn("TAR_ENTRY_INFO",`stripping ${r} from absolute path`,{entry:this,path:r+this.path});let n=this.statCache.get(this.absolute);n?this[Oi](n):this[Ys]()}warn(e,t,i={}){return(0,wn.warnMethod)(this,e,t,i)}emit(e,...t){return e==="error"&&(this.#e=!0),super.emit(e,...t)}[Ys](){oe.default.lstat(this.absolute,(e,t)=>{if(e)return this.emit("error",e);this[Oi](t)})}[Oi](e){this.statCache.set(this.absolute,e),this.stat=e,e.isFile()||(e.size=0),this.type=uh(e),this.emit("stat",e),this[on]()}[on](){switch(this.type){case"File":return this[an]();case"Directory":return this[hn]();case"SymbolicLink":return this[Gs]();default:return this.end()}}[Ri](e){return(0,dn.modeFix)(e,this.type==="Directory",this.portable)}[ae](e){return yn(e,this.prefix)}[Rt](){if(!this.stat)throw new Error("cannot write header before stat");this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.onWriteEntry?.(this),this.header=new fn.Header({path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,mode:this[Ri](this.stat.mode),uid:this.portable?void 0:this.stat.uid,gid:this.portable?void 0:this.stat.gid,size:this.stat.size,mtime:this.noMtime?void 0:this.mtime||this.stat.mtime,type:this.type==="Unsupported"?void 0:this.type,uname:this.portable?void 0:this.stat.uid===this.myuid?this.myuser:"",atime:this.portable?void 0:this.stat.atime,ctime:this.portable?void 0:this.stat.ctime}),this.header.encode()&&!this.noPax&&super.write(new pn.Pax({atime:this.portable?void 0:this.header.atime,ctime:this.portable?void 0:this.header.ctime,gid:this.portable?void 0:this.header.gid,mtime:this.noMtime?void 0:this.mtime||this.header.mtime,path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,size:this.header.size,uid:this.portable?void 0:this.header.uid,uname:this.portable?void 0:this.header.uname,dev:this.portable?void 0:this.stat.dev,ino:this.portable?void 0:this.stat.ino,nlink:this.portable?void 0:this.stat.nlink}).encode());let e=this.header?.block;if(!e)throw new Error("failed to encode header");super.write(e)}[hn](){if(!this.stat)throw new Error("cannot create directory entry without stat");this.path.slice(-1)!=="/"&&(this.path+="/"),this.stat.size=0,this[Rt](),this.end()}[Gs](){oe.default.readlink(this.absolute,(e,t)=>{if(e)return this.emit("error",e);this[Vs](t)})}[Vs](e){this.linkpath=(0,ne.normalizeWindowsPath)(e),this[Rt](),this.end()}[ln](e){if(!this.stat)throw new Error("cannot create link entry without stat");this.type="Link",this.linkpath=(0,ne.normalizeWindowsPath)(nn.default.relative(this.cwd,e)),this.stat.size=0,this[Rt](),this.end()}[an](){if(!this.stat)throw new Error("cannot create file entry without stat");if(this.stat.nlink>1){let e=`${this.stat.dev}:${this.stat.ino}`,t=this.linkCache.get(e);if(t?.indexOf(this.cwd)===0)return this[ln](t);this.linkCache.set(e,this.absolute)}if(this[Rt](),this.stat.size===0)return this.end();this[$s]()}[$s](){oe.default.open(this.absolute,"r",(e,t)=>{if(e)return this.emit("error",e);this[Xs](t)})}[Xs](e){if(this.fd=e,this.#e)return this[ve]();if(!this.stat)throw new Error("should stat before calling onopenfile");this.blockLen=512*Math.ceil(this.stat.size/512),this.blockRemain=this.blockLen;let t=Math.min(this.blockLen,this.maxReadSize);this.buf=Buffer.allocUnsafe(t),this.offset=0,this.pos=0,this.remain=this.stat.size,this.length=this.buf.length,this[gi]()}[gi](){let{fd:e,buf:t,offset:i,length:r,pos:n}=this;if(e===void 0||t===void 0)throw new Error("cannot read file without first opening");oe.default.read(e,t,i,r,n,(o,a)=>{if(o)return this[ve](()=>this.emit("error",o));this[Ks](a)})}[ve](e=()=>{}){this.fd!==void 0&&oe.default.close(this.fd,e)}[Ks](e){if(e<=0&&this.remain>0){let r=Object.assign(new Error("encountered unexpected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[ve](()=>this.emit("error",r))}if(e>this.remain){let r=Object.assign(new Error("did not encounter expected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[ve](()=>this.emit("error",r))}if(!this.buf)throw new Error("should have created buffer prior to reading");if(e===this.remain)for(let r=e;r<this.length&&e<this.blockRemain;r++)this.buf[r+this.offset]=0,e++,this.remain++;let t=this.offset===0&&e===this.buf.length?this.buf:this.buf.subarray(this.offset,this.offset+e);this.write(t)?this[Zs]():this[Qs](()=>this[Zs]())}[Qs](e){this.once("drain",e)}write(e,t,i){if(typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8")),this.blockRemain<e.length){let r=Object.assign(new Error("writing more data than expected"),{path:this.absolute});return this.emit("error",r)}return this.remain-=e.length,this.blockRemain-=e.length,this.pos+=e.length,this.offset+=e.length,super.write(e,null,i)}[Zs](){if(!this.remain)return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),this[ve](e=>e?this.emit("error",e):this.end());if(!this.buf)throw new Error("buffer lost somehow in ONDRAIN");this.offset>=this.length&&(this.buf=Buffer.allocUnsafe(Math.min(this.blockRemain,this.buf.length)),this.offset=0),this.length=this.buf.length-this.offset,this[gi]()}};M.WriteEntry=vi;var Js=class extends vi{sync=!0;[Ys](){this[Oi](oe.default.lstatSync(this.absolute))}[Gs](){this[Vs](oe.default.readlinkSync(this.absolute))}[$s](){this[Xs](oe.default.openSync(this.absolute,"r"))}[gi](){let e=!0;try{let{fd:t,buf:i,offset:r,length:n,pos:o}=this;if(t===void 0||i===void 0)throw new Error("fd and buf must be set in READ method");let a=oe.default.readSync(t,i,r,n,o);this[Ks](a),e=!1}finally{if(e)try{this[ve](()=>{})}catch{}}}[Qs](e){e()}[ve](e=()=>{}){this.fd!==void 0&&oe.default.closeSync(this.fd),e()}};M.WriteEntrySync=Js;var er=class extends cn.Minipass{blockLen=0;blockRemain=0;buf=0;pos=0;remain=0;length=0;preservePaths;portable;strict;noPax;noMtime;readEntry;type;prefix;path;mode;uid;gid;uname;gname;header;mtime;atime;ctime;linkpath;size;onWriteEntry;warn(e,t,i={}){return(0,wn.warnMethod)(this,e,t,i)}constructor(e,t={}){let i=(0,mn.dealias)(t);super(),this.preservePaths=!!i.preservePaths,this.portable=!!i.portable,this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.onWriteEntry=i.onWriteEntry,this.readEntry=e;let{type:r}=e;if(r==="Unsupported")throw new Error("writing entry that should be ignored");this.type=r,this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.prefix=i.prefix,this.path=(0,ne.normalizeWindowsPath)(e.path),this.mode=e.mode!==void 0?this[Ri](e.mode):void 0,this.uid=this.portable?void 0:e.uid,this.gid=this.portable?void 0:e.gid,this.uname=this.portable?void 0:e.uname,this.gname=this.portable?void 0:e.gname,this.size=e.size,this.mtime=this.noMtime?void 0:i.mtime||e.mtime,this.atime=this.portable?void 0:e.atime,this.ctime=this.portable?void 0:e.ctime,this.linkpath=e.linkpath!==void 0?(0,ne.normalizeWindowsPath)(e.linkpath):void 0,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let n=!1;if(!this.preservePaths){let[a,h]=(0,_n.stripAbsolutePath)(this.path);a&&typeof h=="string"&&(this.path=h,n=a)}this.remain=e.size,this.blockRemain=e.startBlockSize,this.onWriteEntry?.(this),this.header=new fn.Header({path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,mode:this.mode,uid:this.portable?void 0:this.uid,gid:this.portable?void 0:this.gid,size:this.size,mtime:this.noMtime?void 0:this.mtime,type:this.type,uname:this.portable?void 0:this.uname,atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime}),n&&this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute path`,{entry:this,path:n+this.path}),this.header.encode()&&!this.noPax&&super.write(new pn.Pax({atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime,gid:this.portable?void 0:this.gid,mtime:this.noMtime?void 0:this.mtime,path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,size:this.size,uid:this.portable?void 0:this.uid,uname:this.portable?void 0:this.uname,dev:this.portable?void 0:this.readEntry.dev,ino:this.portable?void 0:this.readEntry.ino,nlink:this.portable?void 0:this.readEntry.nlink}).encode());let o=this.header?.block;if(!o)throw new Error("failed to encode header");super.write(o),e.pipe(this)}[ae](e){return yn(e,this.prefix)}[Ri](e){return(0,dn.modeFix)(e,this.type==="Directory",this.portable)}write(e,t,i){typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8"));let r=e.length;if(r>this.blockRemain)throw new Error("writing more to entry than is appropriate");return this.blockRemain-=r,super.write(e,i)}end(e,t,i){return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,t??"utf8")),i&&this.once("finish",i),e?super.end(e,i):super.end(i),this}};M.WriteEntryTar=er;var uh=s=>s.isFile()?"File":s.isDirectory()?"Directory":s.isSymbolicLink()?"SymbolicLink":"Unsupported"});var En=d(ot=>{"use strict";Object.defineProperty(ot,"__esModule",{value:!0});ot.Node=ot.Yallist=void 0;var ir=class s{tail;head;length=0;static create(e=[]){return new s(e)}constructor(e=[]){for(let t of e)this.push(t)}*[Symbol.iterator](){for(let e=this.head;e;e=e.next)yield e.value}removeNode(e){if(e.list!==this)throw new Error("removing node which does not belong to this list");let t=e.next,i=e.prev;return t&&(t.prev=i),i&&(i.next=t),e===this.head&&(this.head=t),e===this.tail&&(this.tail=i),this.length--,e.next=void 0,e.prev=void 0,e.list=void 0,t}unshiftNode(e){if(e===this.head)return;e.list&&e.list.removeNode(e);let t=this.head;e.list=this,e.next=t,t&&(t.prev=e),this.head=e,this.tail||(this.tail=e),this.length++}pushNode(e){if(e===this.tail)return;e.list&&e.list.removeNode(e);let t=this.tail;e.list=this,e.prev=t,t&&(t.next=e),this.tail=e,this.head||(this.head=e),this.length++}push(...e){for(let t=0,i=e.length;t<i;t++)fh(this,e[t]);return this.length}unshift(...e){for(var t=0,i=e.length;t<i;t++)dh(this,e[t]);return this.length}pop(){if(!this.tail)return;let e=this.tail.value,t=this.tail;return this.tail=this.tail.prev,this.tail?this.tail.next=void 0:this.head=void 0,t.list=void 0,this.length--,e}shift(){if(!this.head)return;let e=this.head.value,t=this.head;return this.head=this.head.next,this.head?this.head.prev=void 0:this.tail=void 0,t.list=void 0,this.length--,e}forEach(e,t){t=t||this;for(let i=this.head,r=0;i;r++)e.call(t,i.value,r,this),i=i.next}forEachReverse(e,t){t=t||this;for(let i=this.tail,r=this.length-1;i;r--)e.call(t,i.value,r,this),i=i.prev}get(e){let t=0,i=this.head;for(;i&&t<e;t++)i=i.next;if(t===e&&i)return i.value}getReverse(e){let t=0,i=this.tail;for(;i&&t<e;t++)i=i.prev;if(t===e&&i)return i.value}map(e,t){t=t||this;let i=new s;for(let r=this.head;r;)i.push(e.call(t,r.value,this)),r=r.next;return i}mapReverse(e,t){t=t||this;var i=new s;for(let r=this.tail;r;)i.push(e.call(t,r.value,this)),r=r.prev;return i}reduce(e,t){let i,r=this.head;if(arguments.length>1)i=t;else if(this.head)r=this.head.next,i=this.head.value;else throw new TypeError("Reduce of empty list with no initial value");for(var n=0;r;n++)i=e(i,r.value,n),r=r.next;return i}reduceReverse(e,t){let i,r=this.tail;if(arguments.length>1)i=t;else if(this.tail)r=this.tail.prev,i=this.tail.value;else throw new TypeError("Reduce of empty list with no initial value");for(let n=this.length-1;r;n--)i=e(i,r.value,n),r=r.prev;return i}toArray(){let e=new Array(this.length);for(let t=0,i=this.head;i;t++)e[t]=i.value,i=i.next;return e}toArrayReverse(){let e=new Array(this.length);for(let t=0,i=this.tail;i;t++)e[t]=i.value,i=i.prev;return e}slice(e=0,t=this.length){t<0&&(t+=this.length),e<0&&(e+=this.length);let i=new s;if(t<e||t<0)return i;e<0&&(e=0),t>this.length&&(t=this.length);let r=this.head,n=0;for(n=0;r&&n<e;n++)r=r.next;for(;r&&n<t;n++,r=r.next)i.push(r.value);return i}sliceReverse(e=0,t=this.length){t<0&&(t+=this.length),e<0&&(e+=this.length);let i=new s;if(t<e||t<0)return i;e<0&&(e=0),t>this.length&&(t=this.length);let r=this.length,n=this.tail;for(;n&&r>t;r--)n=n.prev;for(;n&&r>e;r--,n=n.prev)i.push(n.value);return i}splice(e,t=0,...i){e>this.length&&(e=this.length-1),e<0&&(e=this.length+e);let r=this.head;for(let o=0;r&&o<e;o++)r=r.next;let n=[];for(let o=0;r&&o<t;o++)n.push(r.value),r=this.removeNode(r);r?r!==this.tail&&(r=r.prev):r=this.tail;for(let o of i)r=ch(this,r,o);return n}reverse(){let e=this.head,t=this.tail;for(let i=e;i;i=i.prev){let r=i.prev;i.prev=i.next,i.next=r}return this.head=t,this.tail=e,this}};ot.Yallist=ir;function ch(s,e,t){let i=e,r=e?e.next:s.head,n=new nt(t,i,r,s);return n.next===void 0&&(s.tail=n),n.prev===void 0&&(s.head=n),s.length++,n}function fh(s,e){s.tail=new nt(e,s.tail,void 0,s),s.head||(s.head=s.tail),s.length++}function dh(s,e){s.head=new nt(e,void 0,s.head,s),s.tail||(s.tail=s.head),s.length++}var nt=class{list;next;prev;value;constructor(e,t,i,r){this.list=r,this.value=e,t?(t.next=this,this.prev=t):this.prev=void 0,i?(i.prev=this,this.next=i):this.next=void 0}};ot.Node=nt});var Ii=d(L=>{"use strict";var mh=L&&L.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),ph=L&&L.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),_h=L&&L.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&mh(t,e,i[r]);return ph(t,e),t}})(),Rn=L&&L.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(L,"__esModule",{value:!0});L.PackSync=L.Pack=L.PackJob=void 0;var Li=Rn(require("fs")),lr=tr(),Dt=class{path;absolute;entry;stat;readdir;pending=!1;ignore=!1;piped=!1;constructor(e,t){this.path=e||"./",this.absolute=t}};L.PackJob=Dt;var wh=We(),sr=_h(Ts()),yh=En(),Eh=ni(),bh=ai(),bn=Buffer.alloc(1024),Ti=Symbol("onStat"),vt=Symbol("ended"),X=Symbol("queue"),je=Symbol("current"),xe=Symbol("process"),Tt=Symbol("processing"),rr=Symbol("processJob"),Q=Symbol("jobs"),nr=Symbol("jobDone"),Di=Symbol("addFSEntry"),Sn=Symbol("addTarEntry"),ur=Symbol("stat"),cr=Symbol("readdir"),Pi=Symbol("onreaddir"),Ni=Symbol("pipe"),gn=Symbol("entry"),or=Symbol("entryOpt"),Mi=Symbol("writeEntryClass"),vn=Symbol("write"),ar=Symbol("ondrain"),On=Rn(require("path")),hr=et(),Ai=class extends wh.Minipass{sync=!1;opt;cwd;maxReadSize;preservePaths;strict;noPax;prefix;linkCache;statCache;file;portable;zip;readdirCache;noDirRecurse;follow;noMtime;mtime;filter;jobs;[Mi];onWriteEntry;[X];[Q]=0;[Tt]=!1;[vt]=!1;constructor(e={}){if(super(),this.opt=e,this.file=e.file||"",this.cwd=e.cwd||process.cwd(),this.maxReadSize=e.maxReadSize,this.preservePaths=!!e.preservePaths,this.strict=!!e.strict,this.noPax=!!e.noPax,this.prefix=(0,hr.normalizeWindowsPath)(e.prefix||""),this.linkCache=e.linkCache||new Map,this.statCache=e.statCache||new Map,this.readdirCache=e.readdirCache||new Map,this.onWriteEntry=e.onWriteEntry,this[Mi]=lr.WriteEntry,typeof e.onwarn=="function"&&this.on("warn",e.onwarn),this.portable=!!e.portable,e.gzip||e.brotli||e.zstd){if((e.gzip?1:0)+(e.brotli?1:0)+(e.zstd?1:0)>1)throw new TypeError("gzip, brotli, zstd are mutually exclusive");if(e.gzip&&(typeof e.gzip!="object"&&(e.gzip={}),this.portable&&(e.gzip.portable=!0),this.zip=new sr.Gzip(e.gzip)),e.brotli&&(typeof e.brotli!="object"&&(e.brotli={}),this.zip=new sr.BrotliCompress(e.brotli)),e.zstd&&(typeof e.zstd!="object"&&(e.zstd={}),this.zip=new sr.ZstdCompress(e.zstd)),!this.zip)throw new Error("impossible");let t=this.zip;t.on("data",i=>super.write(i)),t.on("end",()=>super.end()),t.on("drain",()=>this[ar]()),this.on("resume",()=>t.resume())}else this.on("drain",this[ar]);this.noDirRecurse=!!e.noDirRecurse,this.follow=!!e.follow,this.noMtime=!!e.noMtime,e.mtime&&(this.mtime=e.mtime),this.filter=typeof e.filter=="function"?e.filter:()=>!0,this[X]=new yh.Yallist,this[Q]=0,this.jobs=Number(e.jobs)||4,this[Tt]=!1,this[vt]=!1}[vn](e){return super.write(e)}add(e){return this.write(e),this}end(e,t,i){return typeof e=="function"&&(i=e,e=void 0),typeof t=="function"&&(i=t,t=void 0),e&&this.add(e),this[vt]=!0,this[xe](),i&&i(),this}write(e){if(this[vt])throw new Error("write after end");return e instanceof Eh.ReadEntry?this[Sn](e):this[Di](e),this.flowing}[Sn](e){let t=(0,hr.normalizeWindowsPath)(On.default.resolve(this.cwd,e.path));if(!this.filter(e.path,e))e.resume();else{let i=new Dt(e.path,t);i.entry=new lr.WriteEntryTar(e,this[or](i)),i.entry.on("end",()=>this[nr](i)),this[Q]+=1,this[X].push(i)}this[xe]()}[Di](e){let t=(0,hr.normalizeWindowsPath)(On.default.resolve(this.cwd,e));this[X].push(new Dt(e,t)),this[xe]()}[ur](e){e.pending=!0,this[Q]+=1;let t=this.follow?"stat":"lstat";Li.default[t](e.absolute,(i,r)=>{e.pending=!1,this[Q]-=1,i?this.emit("error",i):this[Ti](e,r)})}[Ti](e,t){this.statCache.set(e.absolute,t),e.stat=t,this.filter(e.path,t)?t.isFile()&&t.nlink>1&&e===this[je]&&!this.linkCache.get(`${t.dev}:${t.ino}`)&&!this.sync&&this[rr](e):e.ignore=!0,this[xe]()}[cr](e){e.pending=!0,this[Q]+=1,Li.default.readdir(e.absolute,(t,i)=>{if(e.pending=!1,this[Q]-=1,t)return this.emit("error",t);this[Pi](e,i)})}[Pi](e,t){this.readdirCache.set(e.absolute,t),e.readdir=t,this[xe]()}[xe](){if(!this[Tt]){this[Tt]=!0;for(let e=this[X].head;e&&this[Q]<this.jobs;e=e.next)if(this[rr](e.value),e.value.ignore){let t=e.next;this[X].removeNode(e),e.next=t}this[Tt]=!1,this[vt]&&this[X].length===0&&this[Q]===0&&(this.zip?this.zip.end(bn):(super.write(bn),super.end()))}}get[je](){return this[X]&&this[X].head&&this[X].head.value}[nr](e){this[X].shift(),this[Q]-=1,this[xe]()}[rr](e){if(!e.pending){if(e.entry){e===this[je]&&!e.piped&&this[Ni](e);return}if(!e.stat){let t=this.statCache.get(e.absolute);t?this[Ti](e,t):this[ur](e)}if(e.stat&&!e.ignore){if(!this.noDirRecurse&&e.stat.isDirectory()&&!e.readdir){let t=this.readdirCache.get(e.absolute);if(t?this[Pi](e,t):this[cr](e),!e.readdir)return}if(e.entry=this[gn](e),!e.entry){e.ignore=!0;return}e===this[je]&&!e.piped&&this[Ni](e)}}}[or](e){return{onwarn:(t,i,r)=>this.warn(t,i,r),noPax:this.noPax,cwd:this.cwd,absolute:e.absolute,preservePaths:this.preservePaths,maxReadSize:this.maxReadSize,strict:this.strict,portable:this.portable,linkCache:this.linkCache,statCache:this.statCache,noMtime:this.noMtime,mtime:this.mtime,prefix:this.prefix,onWriteEntry:this.onWriteEntry}}[gn](e){this[Q]+=1;try{return new this[Mi](e.path,this[or](e)).on("end",()=>this[nr](e)).on("error",i=>this.emit("error",i))}catch(t){this.emit("error",t)}}[ar](){this[je]&&this[je].entry&&this[je].entry.resume()}[Ni](e){e.piped=!0,e.readdir&&e.readdir.forEach(r=>{let n=e.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[Di](o+r)});let t=e.entry,i=this.zip;if(!t)throw new Error("cannot pipe without source");i?t.on("data",r=>{i.write(r)||t.pause()}):t.on("data",r=>{super.write(r)||t.pause()})}pause(){return this.zip&&this.zip.pause(),super.pause()}warn(e,t,i={}){(0,bh.warnMethod)(this,e,t,i)}};L.Pack=Ai;var fr=class extends Ai{sync=!0;constructor(e){super(e),this[Mi]=lr.WriteEntrySync}pause(){}resume(){}[ur](e){let t=this.follow?"statSync":"lstatSync";this[Ti](e,Li.default[t](e.absolute))}[cr](e){this[Pi](e,Li.default.readdirSync(e.absolute))}[Ni](e){let t=e.entry,i=this.zip;if(e.readdir&&e.readdir.forEach(r=>{let n=e.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[Di](o+r)}),!t)throw new Error("Cannot pipe without source");i?t.on("data",r=>{i.write(r)}):t.on("data",r=>{super[vn](r)})}};L.PackSync=fr});var dr=d(at=>{"use strict";var Sh=at&&at.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(at,"__esModule",{value:!0});at.create=void 0;var Tn=Ke(),Dn=Sh(require("node:path")),Pn=st(),gh=Ve(),Fi=Ii(),Oh=(s,e)=>{let t=new Fi.PackSync(s),i=new Tn.WriteStreamSync(s.file,{mode:s.mode||438});t.pipe(i),Nn(t,e)},Rh=(s,e)=>{let t=new Fi.Pack(s),i=new Tn.WriteStream(s.file,{mode:s.mode||438});t.pipe(i);let r=new Promise((n,o)=>{i.on("error",o),i.on("close",n),t.on("error",o)});return Mn(t,e).catch(n=>t.emit("error",n)),r},Nn=(s,e)=>{e.forEach(t=>{t.charAt(0)==="@"?(0,Pn.list)({file:Dn.default.resolve(s.cwd,t.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t)}),s.end()},Mn=async(s,e)=>{for(let t of e)t.charAt(0)==="@"?await(0,Pn.list)({file:Dn.default.resolve(String(s.cwd),t.slice(1)),noResume:!0,onReadEntry:i=>{s.add(i)}}):s.add(t);s.end()},vh=(s,e)=>{let t=new Fi.PackSync(s);return Nn(t,e),t},Th=(s,e)=>{let t=new Fi.Pack(s);return Mn(t,e).catch(i=>t.emit("error",i)),t};at.create=(0,gh.makeCommand)(Oh,Rh,vh,Th,(s,e)=>{if(!e?.length)throw new TypeError("no paths specified to add to archive")})});var jn=d(ht=>{"use strict";var Dh=ht&&ht.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(ht,"__esModule",{value:!0});ht.getWriteFlag=void 0;var In=Dh(require("fs")),Ph=process.env.__FAKE_PLATFORM__||process.platform,Fn=Ph==="win32",{O_CREAT:Cn,O_NOFOLLOW:Ln,O_TRUNC:Bn,O_WRONLY:zn}=In.default.constants,kn=Number(process.env.__FAKE_FS_O_FILENAME__)||In.default.constants.UV_FS_O_FILEMAP||0,Nh=Fn&&!!kn,Mh=512*1024,Lh=kn|Bn|Cn|zn,An=!Fn&&typeof Ln=="number"?Ln|Bn|Cn|zn:null;ht.getWriteFlag=An!==null?()=>An:Nh?s=>s<Mh?Lh:"w":()=>"w"});var Un=d(he=>{"use strict";var xn=he&&he.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(he,"__esModule",{value:!0});he.chownrSync=he.chownr=void 0;var Bi=xn(require("node:fs")),Pt=xn(require("node:path")),mr=(s,e,t)=>{try{return Bi.default.lchownSync(s,e,t)}catch(i){if(i?.code!=="ENOENT")throw i}},Ci=(s,e,t,i)=>{Bi.default.lchown(s,e,t,r=>{i(r&&r?.code!=="ENOENT"?r:null)})},Ah=(s,e,t,i,r)=>{if(e.isDirectory())(0,he.chownr)(Pt.default.resolve(s,e.name),t,i,n=>{if(n)return r(n);let o=Pt.default.resolve(s,e.name);Ci(o,t,i,r)});else{let n=Pt.default.resolve(s,e.name);Ci(n,t,i,r)}},Ih=(s,e,t,i)=>{Bi.default.readdir(s,{withFileTypes:!0},(r,n)=>{if(r){if(r.code==="ENOENT")return i();if(r.code!=="ENOTDIR"&&r.code!=="ENOTSUP")return i(r)}if(r||!n.length)return Ci(s,e,t,i);let o=n.length,a=null,h=l=>{if(!a){if(l)return i(a=l);if(--o===0)return Ci(s,e,t,i)}};for(let l of n)Ah(s,l,e,t,h)})};he.chownr=Ih;var Fh=(s,e,t,i)=>{e.isDirectory()&&(0,he.chownrSync)(Pt.default.resolve(s,e.name),t,i),mr(Pt.default.resolve(s,e.name),t,i)},Ch=(s,e,t)=>{let i;try{i=Bi.default.readdirSync(s,{withFileTypes:!0})}catch(r){let n=r;if(n?.code==="ENOENT")return;if(n?.code==="ENOTDIR"||n?.code==="ENOTSUP")return mr(s,e,t);throw n}for(let r of i)Fh(s,r,e,t);return mr(s,e,t)};he.chownrSync=Ch});var qn=d(zi=>{"use strict";Object.defineProperty(zi,"__esModule",{value:!0});zi.CwdError=void 0;var pr=class extends Error{path;code;syscall="chdir";constructor(e,t){super(`${t}: Cannot cd into '${e}'`),this.path=e,this.code=t}get name(){return"CwdError"}};zi.CwdError=pr});var wr=d(ki=>{"use strict";Object.defineProperty(ki,"__esModule",{value:!0});ki.SymlinkError=void 0;var _r=class extends Error{path;symlink;syscall="symlink";code="TAR_SYMLINK_ERROR";constructor(e,t){super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"),this.symlink=e,this.path=t}get name(){return"SymlinkError"}};ki.SymlinkError=_r});var Yn=d(Te=>{"use strict";var Er=Te&&Te.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(Te,"__esModule",{value:!0});Te.mkdirSync=Te.mkdir=void 0;var Wn=Un(),x=Er(require("node:fs")),Bh=Er(require("node:fs/promises")),ji=Er(require("node:path")),Hn=qn(),pe=et(),Zn=wr(),zh=(s,e)=>{x.default.stat(s,(t,i)=>{(t||!i.isDirectory())&&(t=new Hn.CwdError(s,t?.code||"ENOTDIR")),e(t)})},kh=(s,e,t)=>{s=(0,pe.normalizeWindowsPath)(s);let i=e.umask??18,r=e.mode|448,n=(r&i)!==0,o=e.uid,a=e.gid,h=typeof o=="number"&&typeof a=="number"&&(o!==e.processUid||a!==e.processGid),l=e.preserve,u=e.unlink,c=(0,pe.normalizeWindowsPath)(e.cwd),E=(w,P)=>{w?t(w):P&&h?(0,Wn.chownr)(P,o,a,zt=>E(zt)):n?x.default.chmod(s,r,t):t()};if(s===c)return zh(s,E);if(l)return Bh.default.mkdir(s,{mode:r,recursive:!0}).then(w=>E(null,w??void 0),E);let A=(0,pe.normalizeWindowsPath)(ji.default.relative(c,s)).split("/");yr(c,A,r,u,c,void 0,E)};Te.mkdir=kh;var yr=(s,e,t,i,r,n,o)=>{if(e.length===0)return o(null,n);let a=e.shift(),h=(0,pe.normalizeWindowsPath)(ji.default.resolve(s+"/"+a));x.default.mkdir(h,t,Gn(h,e,t,i,r,n,o))},Gn=(s,e,t,i,r,n,o)=>a=>{a?x.default.lstat(s,(h,l)=>{if(h)h.path=h.path&&(0,pe.normalizeWindowsPath)(h.path),o(h);else if(l.isDirectory())yr(s,e,t,i,r,n,o);else if(i)x.default.unlink(s,u=>{if(u)return o(u);x.default.mkdir(s,t,Gn(s,e,t,i,r,n,o))});else{if(l.isSymbolicLink())return o(new Zn.SymlinkError(s,s+"/"+e.join("/")));o(a)}}):(n=n||s,yr(s,e,t,i,r,n,o))},jh=s=>{let e=!1,t;try{e=x.default.statSync(s).isDirectory()}catch(i){t=i?.code}finally{if(!e)throw new Hn.CwdError(s,t??"ENOTDIR")}},xh=(s,e)=>{s=(0,pe.normalizeWindowsPath)(s);let t=e.umask??18,i=e.mode|448,r=(i&t)!==0,n=e.uid,o=e.gid,a=typeof n=="number"&&typeof o=="number"&&(n!==e.processUid||o!==e.processGid),h=e.preserve,l=e.unlink,u=(0,pe.normalizeWindowsPath)(e.cwd),c=w=>{w&&a&&(0,Wn.chownrSync)(w,n,o),r&&x.default.chmodSync(s,i)};if(s===u)return jh(u),c();if(h)return c(x.default.mkdirSync(s,{mode:i,recursive:!0})??void 0);let D=(0,pe.normalizeWindowsPath)(ji.default.relative(u,s)).split("/"),A;for(let w=D.shift(),P=u;w&&(P+="/"+w);w=D.shift()){P=(0,pe.normalizeWindowsPath)(ji.default.resolve(P));try{x.default.mkdirSync(P,i),A=A||P}catch{let zt=x.default.lstatSync(P);if(zt.isDirectory())continue;if(l){x.default.unlinkSync(P),x.default.mkdirSync(P,i),A=A||P;continue}else if(zt.isSymbolicLink())return new Zn.SymlinkError(P,P+"/"+D.join("/"))}}return c(A)};Te.mkdirSync=xh});var Vn=d(xi=>{"use strict";Object.defineProperty(xi,"__esModule",{value:!0});xi.normalizeUnicode=void 0;var br=Object.create(null),Kn=1e4,lt=new Set,Uh=s=>{lt.has(s)?lt.delete(s):br[s]=s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"),lt.add(s);let e=br[s],t=lt.size-Kn;if(t>Kn/10){for(let i of lt)if(lt.delete(i),delete br[i],--t<=0)break}return e};xi.normalizeUnicode=Uh});var Xn=d(Ui=>{"use strict";Object.defineProperty(Ui,"__esModule",{value:!0});Ui.PathReservations=void 0;var $n=require("node:path"),qh=Vn(),Wh=wi(),Hh=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Zh=Hh==="win32",Gh=s=>s.split("/").slice(0,-1).reduce((t,i)=>{let r=t.at(-1);return r!==void 0&&(i=(0,$n.join)(r,i)),t.push(i||"/"),t},[]),Sr=class{#e=new Map;#i=new Map;#s=new Set;reserve(e,t){e=Zh?["win32 parallelization disabled"]:e.map(r=>(0,Wh.stripTrailingSlashes)((0,$n.join)((0,qh.normalizeUnicode)(r))));let i=new Set(e.map(r=>Gh(r)).reduce((r,n)=>r.concat(n)));this.#i.set(t,{dirs:i,paths:e});for(let r of e){let n=this.#e.get(r);n?n.push(t):this.#e.set(r,[t])}for(let r of i){let n=this.#e.get(r);if(!n)this.#e.set(r,[new Set([t])]);else{let o=n.at(-1);o instanceof Set?o.add(t):n.push(new Set([t]))}}return this.#r(t)}#n(e){let t=this.#i.get(e);if(!t)throw new Error("function does not have any path reservations");return{paths:t.paths.map(i=>this.#e.get(i)),dirs:[...t.dirs].map(i=>this.#e.get(i))}}check(e){let{paths:t,dirs:i}=this.#n(e);return t.every(r=>r&&r[0]===e)&&i.every(r=>r&&r[0]instanceof Set&&r[0].has(e))}#r(e){return this.#s.has(e)||!this.check(e)?!1:(this.#s.add(e),e(()=>this.#t(e)),!0)}#t(e){if(!this.#s.has(e))return!1;let t=this.#i.get(e);if(!t)throw new Error("invalid reservation");let{paths:i,dirs:r}=t,n=new Set;for(let o of i){let a=this.#e.get(o);if(!a||a?.[0]!==e)continue;let h=a[1];if(!h){this.#e.delete(o);continue}if(a.shift(),typeof h=="function")n.add(h);else for(let l of h)n.add(l)}for(let o of r){let a=this.#e.get(o),h=a?.[0];if(!(!a||!(h instanceof Set)))if(h.size===1&&a.length===1){this.#e.delete(o);continue}else if(h.size===1){a.shift();let l=a[0];typeof l=="function"&&n.add(l)}else h.delete(e)}return this.#s.delete(e),n.forEach(o=>this.#r(o)),!0}};Ui.PathReservations=Sr});var Qn=d(qi=>{"use strict";Object.defineProperty(qi,"__esModule",{value:!0});qi.umask=void 0;var Yh=()=>process.umask();qi.umask=Yh});var Ar=d(z=>{"use strict";var Kh=z&&z.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),Vh=z&&z.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),ho=z&&z.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Kh(t,e,i[r]);return Vh(t,e),t}})(),Lr=z&&z.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(z,"__esModule",{value:!0});z.UnpackSync=z.Unpack=void 0;var $h=ho(Ke()),Xh=Lr(require("node:assert")),lo=require("node:crypto"),m=Lr(require("node:fs")),g=Lr(require("node:path")),uo=jn(),co=Yn(),U=et(),Qh=pi(),Jh=qs(),Jn=ho(Hs()),el=Xn(),fo=wr(),tl=Qn(),eo=Symbol("onEntry"),vr=Symbol("checkFs"),to=Symbol("checkFs2"),Tr=Symbol("isReusable"),Z=Symbol("makeFs"),Dr=Symbol("file"),Pr=Symbol("directory"),Hi=Symbol("link"),io=Symbol("symlink"),so=Symbol("hardlink"),Mt=Symbol("ensureNoSymlink"),ro=Symbol("unsupported"),no=Symbol("checkPath"),gr=Symbol("stripAbsolutePath"),De=Symbol("mkdir"),T=Symbol("onError"),Wi=Symbol("pending"),oo=Symbol("pend"),ut=Symbol("unpend"),Or=Symbol("ended"),Rr=Symbol("maybeClose"),Nr=Symbol("skip"),Lt=Symbol("doChown"),At=Symbol("uid"),It=Symbol("gid"),Ft=Symbol("checkedCwd"),il=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Ct=il==="win32",sl=1024,rl=(s,e)=>{if(!Ct)return m.default.unlink(s,e);let t=s+".DELETE."+(0,lo.randomBytes)(16).toString("hex");m.default.rename(s,t,i=>{if(i)return e(i);m.default.unlink(t,e)})},nl=s=>{if(!Ct)return m.default.unlinkSync(s);let e=s+".DELETE."+(0,lo.randomBytes)(16).toString("hex");m.default.renameSync(s,e),m.default.unlinkSync(e)},ao=(s,e,t)=>s!==void 0&&s===s>>>0?s:e!==void 0&&e===e>>>0?e:t,Zi=class extends Qh.Parser{[Or]=!1;[Ft]=!1;[Wi]=0;reservations=new el.PathReservations;transform;writable=!0;readable=!1;uid;gid;setOwner;preserveOwner;processGid;processUid;maxDepth;forceChown;win32;newer;keep;noMtime;preservePaths;unlink;cwd;strip;processUmask;umask;dmode;fmode;chmod;constructor(e={}){if(e.ondone=()=>{this[Or]=!0,this[Rr]()},super(e),this.transform=e.transform,this.chmod=!!e.chmod,typeof e.uid=="number"||typeof e.gid=="number"){if(typeof e.uid!="number"||typeof e.gid!="number")throw new TypeError("cannot set owner without number uid and gid");if(e.preserveOwner)throw new TypeError("cannot preserve owner in archive and also set owner explicitly");this.uid=e.uid,this.gid=e.gid,this.setOwner=!0}else this.uid=void 0,this.gid=void 0,this.setOwner=!1;this.preserveOwner=e.preserveOwner===void 0&&typeof e.uid!="number"?!!(process.getuid&&process.getuid()===0):!!e.preserveOwner,this.processUid=(this.preserveOwner||this.setOwner)&&process.getuid?process.getuid():void 0,this.processGid=(this.preserveOwner||this.setOwner)&&process.getgid?process.getgid():void 0,this.maxDepth=typeof e.maxDepth=="number"?e.maxDepth:sl,this.forceChown=e.forceChown===!0,this.win32=!!e.win32||Ct,this.newer=!!e.newer,this.keep=!!e.keep,this.noMtime=!!e.noMtime,this.preservePaths=!!e.preservePaths,this.unlink=!!e.unlink,this.cwd=(0,U.normalizeWindowsPath)(g.default.resolve(e.cwd||process.cwd())),this.strip=Number(e.strip)||0,this.processUmask=this.chmod?typeof e.processUmask=="number"?e.processUmask:(0,tl.umask)():0,this.umask=typeof e.umask=="number"?e.umask:this.processUmask,this.dmode=e.dmode||511&~this.umask,this.fmode=e.fmode||438&~this.umask,this.on("entry",t=>this[eo](t))}warn(e,t,i={}){return(e==="TAR_BAD_ARCHIVE"||e==="TAR_ABORT")&&(i.recoverable=!1),super.warn(e,t,i)}[Rr](){this[Or]&&this[Wi]===0&&(this.emit("prefinish"),this.emit("finish"),this.emit("end"))}[gr](e,t){let i=e[t],{type:r}=e;if(!i||this.preservePaths)return!0;let[n,o]=(0,Jh.stripAbsolutePath)(i),a=o.replaceAll(/\\/g,"/").split("/");if(a.includes("..")||Ct&&/^[a-z]:\.\.$/i.test(a[0]??"")){if(t==="path"||r==="Link")return this.warn("TAR_ENTRY_ERROR",`${t} contains '..'`,{entry:e,[t]:i}),!1;let h=g.default.posix.dirname(e.path),l=g.default.posix.normalize(g.default.posix.join(h,a.join("/")));if(l.startsWith("../")||l==="..")return this.warn("TAR_ENTRY_ERROR",`${t} escapes extraction directory`,{entry:e,[t]:i}),!1}return n&&(e[t]=String(o),this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute ${t}`,{entry:e,[t]:i})),!0}[no](e){let t=(0,U.normalizeWindowsPath)(e.path),i=t.split("/");if(this.strip){if(i.length<this.strip)return!1;if(e.type==="Link"){let r=(0,U.normalizeWindowsPath)(String(e.linkpath)).split("/");if(r.length>=this.strip)e.linkpath=r.slice(this.strip).join("/");else return!1}i.splice(0,this.strip),e.path=i.join("/")}if(isFinite(this.maxDepth)&&i.length>this.maxDepth)return this.warn("TAR_ENTRY_ERROR","path excessively deep",{entry:e,path:t,depth:i.length,maxDepth:this.maxDepth}),!1;if(!this[gr](e,"path")||!this[gr](e,"linkpath"))return!1;if(e.absolute=g.default.isAbsolute(e.path)?(0,U.normalizeWindowsPath)(g.default.resolve(e.path)):(0,U.normalizeWindowsPath)(g.default.resolve(this.cwd,e.path)),!this.preservePaths&&typeof e.absolute=="string"&&e.absolute.indexOf(this.cwd+"/")!==0&&e.absolute!==this.cwd)return this.warn("TAR_ENTRY_ERROR","path escaped extraction target",{entry:e,path:(0,U.normalizeWindowsPath)(e.path),resolvedPath:e.absolute,cwd:this.cwd}),!1;if(e.absolute===this.cwd&&e.type!=="Directory"&&e.type!=="GNUDumpDir")return!1;if(this.win32){let{root:r}=g.default.win32.parse(String(e.absolute));e.absolute=r+Jn.encode(String(e.absolute).slice(r.length));let{root:n}=g.default.win32.parse(e.path);e.path=n+Jn.encode(e.path.slice(n.length))}return!0}[eo](e){if(!this[no](e))return e.resume();switch(Xh.default.equal(typeof e.absolute,"string"),e.type){case"Directory":case"GNUDumpDir":e.mode&&(e.mode=e.mode|448);case"File":case"OldFile":case"ContiguousFile":case"Link":case"SymbolicLink":return this[vr](e);default:return this[ro](e)}}[T](e,t){e.name==="CwdError"?this.emit("error",e):(this.warn("TAR_ENTRY_ERROR",e,{entry:t}),this[ut](),t.resume())}[De](e,t,i){(0,co.mkdir)((0,U.normalizeWindowsPath)(e),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:t},i)}[Lt](e){return this.forceChown||this.preserveOwner&&(typeof e.uid=="number"&&e.uid!==this.processUid||typeof e.gid=="number"&&e.gid!==this.processGid)||typeof this.uid=="number"&&this.uid!==this.processUid||typeof this.gid=="number"&&this.gid!==this.processGid}[At](e){return ao(this.uid,e.uid,this.processUid)}[It](e){return ao(this.gid,e.gid,this.processGid)}[Dr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.fmode,r=new $h.WriteStream(String(e.absolute),{flags:(0,uo.getWriteFlag)(e.size),mode:i,autoClose:!1});r.on("error",h=>{r.fd&&m.default.close(r.fd,()=>{}),r.write=()=>!0,this[T](h,e),t()});let n=1,o=h=>{if(h){r.fd&&m.default.close(r.fd,()=>{}),this[T](h,e),t();return}--n===0&&r.fd!==void 0&&m.default.close(r.fd,l=>{l?this[T](l,e):this[ut](),t()})};r.on("finish",()=>{let h=String(e.absolute),l=r.fd;if(typeof l=="number"&&e.mtime&&!this.noMtime){n++;let u=e.atime||new Date,c=e.mtime;m.default.futimes(l,u,c,E=>E?m.default.utimes(h,u,c,D=>o(D&&E)):o())}if(typeof l=="number"&&this[Lt](e)){n++;let u=this[At](e),c=this[It](e);typeof u=="number"&&typeof c=="number"&&m.default.fchown(l,u,c,E=>E?m.default.chown(h,u,c,D=>o(D&&E)):o())}o()});let a=this.transform&&this.transform(e)||e;a!==e&&(a.on("error",h=>{this[T](h,e),t()}),e.pipe(a)),a.pipe(r)}[Pr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.dmode;this[De](String(e.absolute),i,r=>{if(r){this[T](r,e),t();return}let n=1,o=()=>{--n===0&&(t(),this[ut](),e.resume())};e.mtime&&!this.noMtime&&(n++,m.default.utimes(String(e.absolute),e.atime||new Date,e.mtime,o)),this[Lt](e)&&(n++,m.default.chown(String(e.absolute),Number(this[At](e)),Number(this[It](e)),o)),o()})}[ro](e){e.unsupported=!0,this.warn("TAR_ENTRY_UNSUPPORTED",`unsupported entry type: ${e.type}`,{entry:e}),e.resume()}[io](e,t){let i=(0,U.normalizeWindowsPath)(g.default.relative(this.cwd,g.default.resolve(g.default.dirname(String(e.absolute)),String(e.linkpath)))).split("/");this[Mt](e,this.cwd,i,()=>this[Hi](e,String(e.linkpath),"symlink",t),r=>{this[T](r,e),t()})}[so](e,t){let i=(0,U.normalizeWindowsPath)(g.default.resolve(this.cwd,String(e.linkpath))),r=(0,U.normalizeWindowsPath)(String(e.linkpath)).split("/");this[Mt](e,this.cwd,r,()=>this[Hi](e,i,"link",t),n=>{this[T](n,e),t()})}[Mt](e,t,i,r,n){let o=i.shift();if(this.preservePaths||o===void 0)return r();let a=g.default.resolve(t,o);m.default.lstat(a,(h,l)=>{if(h)return r();if(l?.isSymbolicLink())return n(new fo.SymlinkError(a,g.default.resolve(a,i.join("/"))));this[Mt](e,a,i,r,n)})}[oo](){this[Wi]++}[ut](){this[Wi]--,this[Rr]()}[Nr](e){this[ut](),e.resume()}[Tr](e,t){return e.type==="File"&&!this.unlink&&t.isFile()&&t.nlink<=1&&!Ct}[vr](e){this[oo]();let t=[e.path];e.linkpath&&t.push(e.linkpath),this.reservations.reserve(t,i=>this[to](e,i))}[to](e,t){let i=a=>{t(a)},r=()=>{this[De](this.cwd,this.dmode,a=>{if(a){this[T](a,e),i();return}this[Ft]=!0,n()})},n=()=>{if(e.absolute!==this.cwd){let a=(0,U.normalizeWindowsPath)(g.default.dirname(String(e.absolute)));if(a!==this.cwd)return this[De](a,this.dmode,h=>{if(h){this[T](h,e),i();return}o()})}o()},o=()=>{m.default.lstat(String(e.absolute),(a,h)=>{if(h&&(this.keep||this.newer&&h.mtime>(e.mtime??h.mtime))){this[Nr](e),i();return}if(a||this[Tr](e,h))return this[Z](null,e,i);if(h.isDirectory()){if(e.type==="Directory"){let l=this.chmod&&e.mode&&(h.mode&4095)!==e.mode,u=c=>this[Z](c??null,e,i);return l?m.default.chmod(String(e.absolute),Number(e.mode),u):u()}if(e.absolute!==this.cwd)return m.default.rmdir(String(e.absolute),l=>this[Z](l??null,e,i))}if(e.absolute===this.cwd)return this[Z](null,e,i);rl(String(e.absolute),l=>this[Z](l??null,e,i))})};this[Ft]?n():r()}[Z](e,t,i){if(e){this[T](e,t),i();return}switch(t.type){case"File":case"OldFile":case"ContiguousFile":return this[Dr](t,i);case"Link":return this[so](t,i);case"SymbolicLink":return this[io](t,i);case"Directory":case"GNUDumpDir":return this[Pr](t,i)}}[Hi](e,t,i,r){m.default[i](t,String(e.absolute),n=>{n?this[T](n,e):(this[ut](),e.resume()),r()})}};z.Unpack=Zi;var Nt=s=>{try{return[null,s()]}catch(e){return[e,null]}},Mr=class extends Zi{sync=!0;[Z](e,t){return super[Z](e,t,()=>{})}[vr](e){if(!this[Ft]){let n=this[De](this.cwd,this.dmode);if(n)return this[T](n,e);this[Ft]=!0}if(e.absolute!==this.cwd){let n=(0,U.normalizeWindowsPath)(g.default.dirname(String(e.absolute)));if(n!==this.cwd){let o=this[De](n,this.dmode);if(o)return this[T](o,e)}}let[t,i]=Nt(()=>m.default.lstatSync(String(e.absolute)));if(i&&(this.keep||this.newer&&i.mtime>(e.mtime??i.mtime)))return this[Nr](e);if(t||this[Tr](e,i))return this[Z](null,e);if(i.isDirectory()){if(e.type==="Directory"){let o=this.chmod&&e.mode&&(i.mode&4095)!==e.mode,[a]=o?Nt(()=>{m.default.chmodSync(String(e.absolute),Number(e.mode))}):[];return this[Z](a,e)}let[n]=Nt(()=>m.default.rmdirSync(String(e.absolute)));this[Z](n,e)}let[r]=e.absolute===this.cwd?[]:Nt(()=>nl(String(e.absolute)));this[Z](r,e)}[Dr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.fmode,r=a=>{let h;try{m.default.closeSync(n)}catch(l){h=l}(a||h)&&this[T](a||h,e),t()},n;try{n=m.default.openSync(String(e.absolute),(0,uo.getWriteFlag)(e.size),i)}catch(a){return r(a)}let o=this.transform&&this.transform(e)||e;o!==e&&(o.on("error",a=>this[T](a,e)),e.pipe(o)),o.on("data",a=>{try{m.default.writeSync(n,a,0,a.length)}catch(h){r(h)}}),o.on("end",()=>{let a=null;if(e.mtime&&!this.noMtime){let h=e.atime||new Date,l=e.mtime;try{m.default.futimesSync(n,h,l)}catch(u){try{m.default.utimesSync(String(e.absolute),h,l)}catch{a=u}}}if(this[Lt](e)){let h=this[At](e),l=this[It](e);try{m.default.fchownSync(n,Number(h),Number(l))}catch(u){try{m.default.chownSync(String(e.absolute),Number(h),Number(l))}catch{a=a||u}}}r(a)})}[Pr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.dmode,r=this[De](String(e.absolute),i);if(r){this[T](r,e),t();return}if(e.mtime&&!this.noMtime)try{m.default.utimesSync(String(e.absolute),e.atime||new Date,e.mtime)}catch{}if(this[Lt](e))try{m.default.chownSync(String(e.absolute),Number(this[At](e)),Number(this[It](e)))}catch{}t(),e.resume()}[De](e,t){try{return(0,co.mkdirSync)((0,U.normalizeWindowsPath)(e),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:t})}catch(i){return i}}[Mt](e,t,i,r,n){if(this.preservePaths||i.length===0)return r();let o=t;for(let a of i){o=g.default.resolve(o,a);let[h,l]=Nt(()=>m.default.lstatSync(o));if(h)return r();if(l.isSymbolicLink())return n(new fo.SymlinkError(o,g.default.resolve(t,i.join("/"))))}r()}[Hi](e,t,i,r){let n=`${i}Sync`;try{m.default[n](t,String(e.absolute)),r(),e.resume()}catch(o){return this[T](o,e)}}};z.UnpackSync=Mr});var Ir=d(G=>{"use strict";var ol=G&&G.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),al=G&&G.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),hl=G&&G.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&ol(t,e,i[r]);return al(t,e),t}})(),ll=G&&G.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(G,"__esModule",{value:!0});G.extract=void 0;var mo=hl(Ke()),po=ll(require("node:fs")),ul=st(),cl=Ve(),Gi=Ar(),fl=s=>{let e=new Gi.UnpackSync(s),t=s.file,i=po.default.statSync(t),r=s.maxReadSize||16*1024*1024;new mo.ReadStreamSync(t,{readSize:r,size:i.size}).pipe(e)},dl=(s,e)=>{let t=new Gi.Unpack(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,a)=>{t.on("error",a),t.on("close",o),po.default.stat(r,(h,l)=>{if(h)a(h);else{let u=new mo.ReadStream(r,{readSize:i,size:l.size});u.on("error",a),u.pipe(t)}})})};G.extract=(0,cl.makeCommand)(fl,dl,s=>new Gi.UnpackSync(s),s=>new Gi.Unpack(s),(s,e)=>{e?.length&&(0,ul.filesFilter)(s,e)})});var Yi=d(ct=>{"use strict";var _o=ct&&ct.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(ct,"__esModule",{value:!0});ct.replace=void 0;var wo=Ke(),q=_o(require("node:fs")),yo=_o(require("node:path")),Eo=Je(),bo=st(),ml=Ve(),pl=$t(),So=Ii(),_l=(s,e)=>{let t=new So.PackSync(s),i=!0,r,n;try{try{r=q.default.openSync(s.file,"r+")}catch(h){if(h?.code==="ENOENT")r=q.default.openSync(s.file,"w+");else throw h}let o=q.default.fstatSync(r),a=Buffer.alloc(512);e:for(n=0;n<o.size;n+=512){for(let u=0,c=0;u<512;u+=c){if(c=q.default.readSync(r,a,u,a.length-u,n+u),n===0&&a[0]===31&&a[1]===139)throw new Error("cannot append to compressed archives");if(!c)break e}let h=new Eo.Header(a);if(!h.cksumValid)break;let l=512*Math.ceil((h.size||0)/512);if(n+l+512>o.size)break;n+=l,s.mtimeCache&&h.mtime&&s.mtimeCache.set(String(h.path),h.mtime)}i=!1,wl(s,t,n,r,e)}finally{if(i)try{q.default.closeSync(r)}catch{}}},wl=(s,e,t,i,r)=>{let n=new wo.WriteStreamSync(s.file,{fd:i,start:t});e.pipe(n),El(e,r)},yl=(s,e)=>{e=Array.from(e);let t=new So.Pack(s),i=(n,o,a)=>{let h=(D,A)=>{D?q.default.close(n,w=>a(D)):a(null,A)},l=0;if(o===0)return h(null,0);let u=0,c=Buffer.alloc(512),E=(D,A)=>{if(D||A===void 0)return h(D);if(u+=A,u<512&&A)return q.default.read(n,c,u,c.length-u,l+u,E);if(l===0&&c[0]===31&&c[1]===139)return h(new Error("cannot append to compressed archives"));if(u<512)return h(null,l);let w=new Eo.Header(c);if(!w.cksumValid)return h(null,l);let P=512*Math.ceil((w.size??0)/512);if(l+P+512>o||(l+=P+512,l>=o))return h(null,l);s.mtimeCache&&w.mtime&&s.mtimeCache.set(String(w.path),w.mtime),u=0,q.default.read(n,c,0,512,l,E)};q.default.read(n,c,0,512,l,E)};return new Promise((n,o)=>{t.on("error",o);let a="r+",h=(l,u)=>{if(l&&l.code==="ENOENT"&&a==="r+")return a="w+",q.default.open(s.file,a,h);if(l||!u)return o(l);q.default.fstat(u,(c,E)=>{if(c)return q.default.close(u,()=>o(c));i(u,E.size,(D,A)=>{if(D)return o(D);let w=new wo.WriteStream(s.file,{fd:u,start:A});t.pipe(w),w.on("error",o),w.on("close",n),bl(t,e)})})};q.default.open(s.file,a,h)})},El=(s,e)=>{e.forEach(t=>{t.charAt(0)==="@"?(0,bo.list)({file:yo.default.resolve(s.cwd,t.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t)}),s.end()},bl=async(s,e)=>{for(let t of e)t.charAt(0)==="@"?await(0,bo.list)({file:yo.default.resolve(String(s.cwd),t.slice(1)),noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t);s.end()};ct.replace=(0,ml.makeCommand)(_l,yl,()=>{throw new TypeError("file is required")},()=>{throw new TypeError("file is required")},(s,e)=>{if(!(0,pl.isFile)(s))throw new TypeError("file is required");if(s.gzip||s.brotli||s.zstd||s.file.endsWith(".br")||s.file.endsWith(".tbr"))throw new TypeError("cannot append to compressed archives");if(!e?.length)throw new TypeError("no paths specified to add/replace")})});var Fr=d(Ki=>{"use strict";Object.defineProperty(Ki,"__esModule",{value:!0});Ki.update=void 0;var Sl=Ve(),Bt=Yi();Ki.update=(0,Sl.makeCommand)(Bt.replace.syncFile,Bt.replace.asyncFile,Bt.replace.syncNoFile,Bt.replace.asyncNoFile,(s,e=[])=>{Bt.replace.validate?.(s,e),gl(s)});var gl=s=>{let e=s.filter;s.mtimeCache||(s.mtimeCache=new Map),s.filter=e?(t,i)=>e(t,i)&&!((s.mtimeCache?.get(t)??i.mtime??0)>(i.mtime??0)):(t,i)=>!((s.mtimeCache?.get(t)??i.mtime??0)>(i.mtime??0))}});var go=exports&&exports.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),Ol=exports&&exports.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),Y=exports&&exports.__exportStar||function(s,e){for(var t in s)t!=="default"&&!Object.prototype.hasOwnProperty.call(e,t)&&go(e,s,t)},Rl=exports&&exports.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&go(t,e,i[r]);return Ol(t,e),t}})();Object.defineProperty(exports,"__esModule",{value:!0});exports.u=exports.types=exports.r=exports.t=exports.x=exports.c=void 0;Y(dr(),exports);var vl=dr();Object.defineProperty(exports,"c",{enumerable:!0,get:function(){return vl.create}});Y(Ir(),exports);var Tl=Ir();Object.defineProperty(exports,"x",{enumerable:!0,get:function(){return Tl.extract}});Y(Je(),exports);Y(st(),exports);var Dl=st();Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return Dl.list}});Y(Ii(),exports);Y(pi(),exports);Y(ti(),exports);Y(ni(),exports);Y(Yi(),exports);var Pl=Yi();Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return Pl.replace}});exports.types=Rl(Ds());Y(Ar(),exports);Y(Fr(),exports);var Nl=Fr();Object.defineProperty(exports,"u",{enumerable:!0,get:function(){return Nl.update}});Y(tr(),exports);
+"use strict";var d=(s,e)=>()=>(e||s((e={exports:{}}).exports,e),e.exports);var We=d(F=>{"use strict";var Ro=F&&F.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(F,"__esModule",{value:!0});F.Minipass=F.isWritable=F.isReadable=F.isStream=void 0;var Br=typeof process=="object"&&process?process:{stdout:null,stderr:null},ss=require("node:events"),jr=Ro(require("node:stream")),vo=require("node:string_decoder"),To=s=>!!s&&typeof s=="object"&&(s instanceof Zt||s instanceof jr.default||(0,F.isReadable)(s)||(0,F.isWritable)(s));F.isStream=To;var Do=s=>!!s&&typeof s=="object"&&s instanceof ss.EventEmitter&&typeof s.pipe=="function"&&s.pipe!==jr.default.Writable.prototype.pipe;F.isReadable=Do;var Po=s=>!!s&&typeof s=="object"&&s instanceof ss.EventEmitter&&typeof s.write=="function"&&typeof s.end=="function";F.isWritable=Po;var le=Symbol("EOF"),ue=Symbol("maybeEmitEnd"),_e=Symbol("emittedEnd"),xt=Symbol("emittingEnd"),ft=Symbol("emittedError"),jt=Symbol("closed"),zr=Symbol("read"),Ut=Symbol("flush"),kr=Symbol("flushChunk"),K=Symbol("encoding"),Ue=Symbol("decoder"),O=Symbol("flowing"),dt=Symbol("paused"),qe=Symbol("resume"),R=Symbol("buffer"),I=Symbol("pipes"),v=Symbol("bufferLength"),Xi=Symbol("bufferPush"),qt=Symbol("bufferShift"),N=Symbol("objectMode"),y=Symbol("destroyed"),Qi=Symbol("error"),Ji=Symbol("emitData"),xr=Symbol("emitEnd"),es=Symbol("emitEnd2"),J=Symbol("async"),ts=Symbol("abort"),Wt=Symbol("aborted"),mt=Symbol("signal"),Ne=Symbol("dataListeners"),k=Symbol("discarded"),pt=s=>Promise.resolve().then(s),No=s=>s(),Mo=s=>s==="end"||s==="finish"||s==="prefinish",Lo=s=>s instanceof ArrayBuffer||!!s&&typeof s=="object"&&s.constructor&&s.constructor.name==="ArrayBuffer"&&s.byteLength>=0,Ao=s=>!Buffer.isBuffer(s)&&ArrayBuffer.isView(s),Ht=class{src;dest;opts;ondrain;constructor(e,t,i){this.src=e,this.dest=t,this.opts=i,this.ondrain=()=>e[qe](),this.dest.on("drain",this.ondrain)}unpipe(){this.dest.removeListener("drain",this.ondrain)}proxyErrors(e){}end(){this.unpipe(),this.opts.end&&this.dest.end()}},is=class extends Ht{unpipe(){this.src.removeListener("error",this.proxyErrors),super.unpipe()}constructor(e,t,i){super(e,t,i),this.proxyErrors=r=>this.dest.emit("error",r),e.on("error",this.proxyErrors)}},Io=s=>!!s.objectMode,Fo=s=>!s.objectMode&&!!s.encoding&&s.encoding!=="buffer",Zt=class extends ss.EventEmitter{[O]=!1;[dt]=!1;[I]=[];[R]=[];[N];[K];[J];[Ue];[le]=!1;[_e]=!1;[xt]=!1;[jt]=!1;[ft]=null;[v]=0;[y]=!1;[mt];[Wt]=!1;[Ne]=0;[k]=!1;writable=!0;readable=!0;constructor(...e){let t=e[0]||{};if(super(),t.objectMode&&typeof t.encoding=="string")throw new TypeError("Encoding and objectMode may not be used together");Io(t)?(this[N]=!0,this[K]=null):Fo(t)?(this[K]=t.encoding,this[N]=!1):(this[N]=!1,this[K]=null),this[J]=!!t.async,this[Ue]=this[K]?new vo.StringDecoder(this[K]):null,t&&t.debugExposeBuffer===!0&&Object.defineProperty(this,"buffer",{get:()=>this[R]}),t&&t.debugExposePipes===!0&&Object.defineProperty(this,"pipes",{get:()=>this[I]});let{signal:i}=t;i&&(this[mt]=i,i.aborted?this[ts]():i.addEventListener("abort",()=>this[ts]()))}get bufferLength(){return this[v]}get encoding(){return this[K]}set encoding(e){throw new Error("Encoding must be set at instantiation time")}setEncoding(e){throw new Error("Encoding must be set at instantiation time")}get objectMode(){return this[N]}set objectMode(e){throw new Error("objectMode must be set at instantiation time")}get async(){return this[J]}set async(e){this[J]=this[J]||!!e}[ts](){this[Wt]=!0,this.emit("abort",this[mt]?.reason),this.destroy(this[mt]?.reason)}get aborted(){return this[Wt]}set aborted(e){}write(e,t,i){if(this[Wt])return!1;if(this[le])throw new Error("write after end");if(this[y])return this.emit("error",Object.assign(new Error("Cannot call write after a stream was destroyed"),{code:"ERR_STREAM_DESTROYED"})),!0;typeof t=="function"&&(i=t,t="utf8"),t||(t="utf8");let r=this[J]?pt:No;if(!this[N]&&!Buffer.isBuffer(e)){if(Ao(e))e=Buffer.from(e.buffer,e.byteOffset,e.byteLength);else if(Lo(e))e=Buffer.from(e);else if(typeof e!="string")throw new Error("Non-contiguous data written to non-objectMode stream")}return this[N]?(this[O]&&this[v]!==0&&this[Ut](!0),this[O]?this.emit("data",e):this[Xi](e),this[v]!==0&&this.emit("readable"),i&&r(i),this[O]):e.length?(typeof e=="string"&&!(t===this[K]&&!this[Ue]?.lastNeed)&&(e=Buffer.from(e,t)),Buffer.isBuffer(e)&&this[K]&&(e=this[Ue].write(e)),this[O]&&this[v]!==0&&this[Ut](!0),this[O]?this.emit("data",e):this[Xi](e),this[v]!==0&&this.emit("readable"),i&&r(i),this[O]):(this[v]!==0&&this.emit("readable"),i&&r(i),this[O])}read(e){if(this[y])return null;if(this[k]=!1,this[v]===0||e===0||e&&e>this[v])return this[ue](),null;this[N]&&(e=null),this[R].length>1&&!this[N]&&(this[R]=[this[K]?this[R].join(""):Buffer.concat(this[R],this[v])]);let t=this[zr](e||null,this[R][0]);return this[ue](),t}[zr](e,t){if(this[N])this[qt]();else{let i=t;e===i.length||e===null?this[qt]():typeof i=="string"?(this[R][0]=i.slice(e),t=i.slice(0,e),this[v]-=e):(this[R][0]=i.subarray(e),t=i.subarray(0,e),this[v]-=e)}return this.emit("data",t),!this[R].length&&!this[le]&&this.emit("drain"),t}end(e,t,i){return typeof e=="function"&&(i=e,e=void 0),typeof t=="function"&&(i=t,t="utf8"),e!==void 0&&this.write(e,t),i&&this.once("end",i),this[le]=!0,this.writable=!1,(this[O]||!this[dt])&&this[ue](),this}[qe](){this[y]||(!this[Ne]&&!this[I].length&&(this[k]=!0),this[dt]=!1,this[O]=!0,this.emit("resume"),this[R].length?this[Ut]():this[le]?this[ue]():this.emit("drain"))}resume(){return this[qe]()}pause(){this[O]=!1,this[dt]=!0,this[k]=!1}get destroyed(){return this[y]}get flowing(){return this[O]}get paused(){return this[dt]}[Xi](e){this[N]?this[v]+=1:this[v]+=e.length,this[R].push(e)}[qt](){return this[N]?this[v]-=1:this[v]-=this[R][0].length,this[R].shift()}[Ut](e=!1){do;while(this[kr](this[qt]())&&this[R].length);!e&&!this[R].length&&!this[le]&&this.emit("drain")}[kr](e){return this.emit("data",e),this[O]}pipe(e,t){if(this[y])return e;this[k]=!1;let i=this[_e];return t=t||{},e===Br.stdout||e===Br.stderr?t.end=!1:t.end=t.end!==!1,t.proxyErrors=!!t.proxyErrors,i?t.end&&e.end():(this[I].push(t.proxyErrors?new is(this,e,t):new Ht(this,e,t)),this[J]?pt(()=>this[qe]()):this[qe]()),e}unpipe(e){let t=this[I].find(i=>i.dest===e);t&&(this[I].length===1?(this[O]&&this[Ne]===0&&(this[O]=!1),this[I]=[]):this[I].splice(this[I].indexOf(t),1),t.unpipe())}addListener(e,t){return this.on(e,t)}on(e,t){let i=super.on(e,t);if(e==="data")this[k]=!1,this[Ne]++,!this[I].length&&!this[O]&&this[qe]();else if(e==="readable"&&this[v]!==0)super.emit("readable");else if(Mo(e)&&this[_e])super.emit(e),this.removeAllListeners(e);else if(e==="error"&&this[ft]){let r=t;this[J]?pt(()=>r.call(this,this[ft])):r.call(this,this[ft])}return i}removeListener(e,t){return this.off(e,t)}off(e,t){let i=super.off(e,t);return e==="data"&&(this[Ne]=this.listeners("data").length,this[Ne]===0&&!this[k]&&!this[I].length&&(this[O]=!1)),i}removeAllListeners(e){let t=super.removeAllListeners(e);return(e==="data"||e===void 0)&&(this[Ne]=0,!this[k]&&!this[I].length&&(this[O]=!1)),t}get emittedEnd(){return this[_e]}[ue](){!this[xt]&&!this[_e]&&!this[y]&&this[R].length===0&&this[le]&&(this[xt]=!0,this.emit("end"),this.emit("prefinish"),this.emit("finish"),this[jt]&&this.emit("close"),this[xt]=!1)}emit(e,...t){let i=t[0];if(e!=="error"&&e!=="close"&&e!==y&&this[y])return!1;if(e==="data")return!this[N]&&!i?!1:this[J]?(pt(()=>this[Ji](i)),!0):this[Ji](i);if(e==="end")return this[xr]();if(e==="close"){if(this[jt]=!0,!this[_e]&&!this[y])return!1;let n=super.emit("close");return this.removeAllListeners("close"),n}else if(e==="error"){this[ft]=i,super.emit(Qi,i);let n=!this[mt]||this.listeners("error").length?super.emit("error",i):!1;return this[ue](),n}else if(e==="resume"){let n=super.emit("resume");return this[ue](),n}else if(e==="finish"||e==="prefinish"){let n=super.emit(e);return this.removeAllListeners(e),n}let r=super.emit(e,...t);return this[ue](),r}[Ji](e){for(let i of this[I])i.dest.write(e)===!1&&this.pause();let t=this[k]?!1:super.emit("data",e);return this[ue](),t}[xr](){return this[_e]?!1:(this[_e]=!0,this.readable=!1,this[J]?(pt(()=>this[es]()),!0):this[es]())}[es](){if(this[Ue]){let t=this[Ue].end();if(t){for(let i of this[I])i.dest.write(t);this[k]||super.emit("data",t)}}for(let t of this[I])t.end();let e=super.emit("end");return this.removeAllListeners("end"),e}async collect(){let e=Object.assign([],{dataLength:0});this[N]||(e.dataLength=0);let t=this.promise();return this.on("data",i=>{e.push(i),this[N]||(e.dataLength+=i.length)}),await t,e}async concat(){if(this[N])throw new Error("cannot concat in objectMode");let e=await this.collect();return this[K]?e.join(""):Buffer.concat(e,e.dataLength)}async promise(){return new Promise((e,t)=>{this.on(y,()=>t(new Error("stream destroyed"))),this.on("error",i=>t(i)),this.on("end",()=>e())})}[Symbol.asyncIterator](){this[k]=!1;let e=!1,t=async()=>(this.pause(),e=!0,{value:void 0,done:!0});return{next:()=>{if(e)return t();let r=this.read();if(r!==null)return Promise.resolve({done:!1,value:r});if(this[le])return t();let n,o,a=c=>{this.off("data",h),this.off("end",l),this.off(y,u),t(),o(c)},h=c=>{this.off("error",a),this.off("end",l),this.off(y,u),this.pause(),n({value:c,done:!!this[le]})},l=()=>{this.off("error",a),this.off("data",h),this.off(y,u),t(),n({done:!0,value:void 0})},u=()=>a(new Error("stream destroyed"));return new Promise((c,E)=>{o=E,n=c,this.once(y,u),this.once("error",a),this.once("end",l),this.once("data",h)})},throw:t,return:t,[Symbol.asyncIterator](){return this},[Symbol.asyncDispose]:async()=>{}}}[Symbol.iterator](){this[k]=!1;let e=!1,t=()=>(this.pause(),this.off(Qi,t),this.off(y,t),this.off("end",t),e=!0,{done:!0,value:void 0}),i=()=>{if(e)return t();let r=this.read();return r===null?t():{done:!1,value:r}};return this.once("end",t),this.once(Qi,t),this.once(y,t),{next:i,throw:t,return:t,[Symbol.iterator](){return this},[Symbol.dispose]:()=>{}}}destroy(e){if(this[y])return e?this.emit("error",e):this.emit(y),this;this[y]=!0,this[k]=!0,this[R].length=0,this[v]=0;let t=this;return typeof t.close=="function"&&!this[jt]&&t.close(),e?this.emit("error",e):this.emit(y),this}static get isStream(){return F.isStream}};F.Minipass=Zt});var Ke=d(W=>{"use strict";var Ur=W&&W.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(W,"__esModule",{value:!0});W.WriteStreamSync=W.WriteStream=W.ReadStreamSync=W.ReadStream=void 0;var Co=Ur(require("events")),B=Ur(require("fs")),Bo=We(),zo=B.default.writev,ye=Symbol("_autoClose"),$=Symbol("_close"),_t=Symbol("_ended"),p=Symbol("_fd"),rs=Symbol("_finished"),fe=Symbol("_flags"),ns=Symbol("_flush"),ls=Symbol("_handleChunk"),us=Symbol("_makeBuf"),yt=Symbol("_mode"),Gt=Symbol("_needDrain"),Ge=Symbol("_onerror"),Ye=Symbol("_onopen"),os=Symbol("_onread"),He=Symbol("_onwrite"),Ee=Symbol("_open"),V=Symbol("_path"),we=Symbol("_pos"),ee=Symbol("_queue"),Ze=Symbol("_read"),as=Symbol("_readSize"),ce=Symbol("_reading"),wt=Symbol("_remain"),hs=Symbol("_size"),Yt=Symbol("_write"),Me=Symbol("_writing"),Kt=Symbol("_defaultFlag"),Le=Symbol("_errored"),Vt=class extends Bo.Minipass{[Le]=!1;[p];[V];[as];[ce]=!1;[hs];[wt];[ye];constructor(e,t){if(t=t||{},super(t),this.readable=!0,this.writable=!1,typeof e!="string")throw new TypeError("path must be a string");this[Le]=!1,this[p]=typeof t.fd=="number"?t.fd:void 0,this[V]=e,this[as]=t.readSize||16*1024*1024,this[ce]=!1,this[hs]=typeof t.size=="number"?t.size:1/0,this[wt]=this[hs],this[ye]=typeof t.autoClose=="boolean"?t.autoClose:!0,typeof this[p]=="number"?this[Ze]():this[Ee]()}get fd(){return this[p]}get path(){return this[V]}write(){throw new TypeError("this is a readable stream")}end(){throw new TypeError("this is a readable stream")}[Ee](){B.default.open(this[V],"r",(e,t)=>this[Ye](e,t))}[Ye](e,t){e?this[Ge](e):(this[p]=t,this.emit("open",t),this[Ze]())}[us](){return Buffer.allocUnsafe(Math.min(this[as],this[wt]))}[Ze](){if(!this[ce]){this[ce]=!0;let e=this[us]();if(e.length===0)return process.nextTick(()=>this[os](null,0,e));B.default.read(this[p],e,0,e.length,null,(t,i,r)=>this[os](t,i,r))}}[os](e,t,i){this[ce]=!1,e?this[Ge](e):this[ls](t,i)&&this[Ze]()}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.close(e,t=>t?this.emit("error",t):this.emit("close"))}}[Ge](e){this[ce]=!0,this[$](),this.emit("error",e)}[ls](e,t){let i=!1;return this[wt]-=e,e>0&&(i=super.write(e<t.length?t.subarray(0,e):t)),(e===0||this[wt]<=0)&&(i=!1,this[$](),super.end()),i}emit(e,...t){switch(e){case"prefinish":case"finish":return!1;case"drain":return typeof this[p]=="number"&&this[Ze](),!1;case"error":return this[Le]?!1:(this[Le]=!0,super.emit(e,...t));default:return super.emit(e,...t)}}};W.ReadStream=Vt;var cs=class extends Vt{[Ee](){let e=!0;try{this[Ye](null,B.default.openSync(this[V],"r")),e=!1}finally{e&&this[$]()}}[Ze](){let e=!0;try{if(!this[ce]){this[ce]=!0;do{let t=this[us](),i=t.length===0?0:B.default.readSync(this[p],t,0,t.length,null);if(!this[ls](i,t))break}while(!0);this[ce]=!1}e=!1}finally{e&&this[$]()}}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.closeSync(e),this.emit("close")}}};W.ReadStreamSync=cs;var $t=class extends Co.default{readable=!1;writable=!0;[Le]=!1;[Me]=!1;[_t]=!1;[ee]=[];[Gt]=!1;[V];[yt];[ye];[p];[Kt];[fe];[rs]=!1;[we];constructor(e,t){t=t||{},super(t),this[V]=e,this[p]=typeof t.fd=="number"?t.fd:void 0,this[yt]=t.mode===void 0?438:t.mode,this[we]=typeof t.start=="number"?t.start:void 0,this[ye]=typeof t.autoClose=="boolean"?t.autoClose:!0;let i=this[we]!==void 0?"r+":"w";this[Kt]=t.flags===void 0,this[fe]=t.flags===void 0?i:t.flags,this[p]===void 0&&this[Ee]()}emit(e,...t){if(e==="error"){if(this[Le])return!1;this[Le]=!0}return super.emit(e,...t)}get fd(){return this[p]}get path(){return this[V]}[Ge](e){this[$](),this[Me]=!0,this.emit("error",e)}[Ee](){B.default.open(this[V],this[fe],this[yt],(e,t)=>this[Ye](e,t))}[Ye](e,t){this[Kt]&&this[fe]==="r+"&&e&&e.code==="ENOENT"?(this[fe]="w",this[Ee]()):e?this[Ge](e):(this[p]=t,this.emit("open",t),this[Me]||this[ns]())}end(e,t){return e&&this.write(e,t),this[_t]=!0,!this[Me]&&!this[ee].length&&typeof this[p]=="number"&&this[He](null,0),this}write(e,t){return typeof e=="string"&&(e=Buffer.from(e,t)),this[_t]?(this.emit("error",new Error("write() after end()")),!1):this[p]===void 0||this[Me]||this[ee].length?(this[ee].push(e),this[Gt]=!0,!1):(this[Me]=!0,this[Yt](e),!0)}[Yt](e){B.default.write(this[p],e,0,e.length,this[we],(t,i)=>this[He](t,i))}[He](e,t){e?this[Ge](e):(this[we]!==void 0&&typeof t=="number"&&(this[we]+=t),this[ee].length?this[ns]():(this[Me]=!1,this[_t]&&!this[rs]?(this[rs]=!0,this[$](),this.emit("finish")):this[Gt]&&(this[Gt]=!1,this.emit("drain"))))}[ns](){if(this[ee].length===0)this[_t]&&this[He](null,0);else if(this[ee].length===1)this[Yt](this[ee].pop());else{let e=this[ee];this[ee]=[],zo(this[p],e,this[we],(t,i)=>this[He](t,i))}}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.close(e,t=>t?this.emit("error",t):this.emit("close"))}}};W.WriteStream=$t;var fs=class extends $t{[Ee](){let e;if(this[Kt]&&this[fe]==="r+")try{e=B.default.openSync(this[V],this[fe],this[yt])}catch(t){if(t?.code==="ENOENT")return this[fe]="w",this[Ee]();throw t}else e=B.default.openSync(this[V],this[fe],this[yt]);this[Ye](null,e)}[$](){if(this[ye]&&typeof this[p]=="number"){let e=this[p];this[p]=void 0,B.default.closeSync(e),this.emit("close")}}[Yt](e){let t=!0;try{this[He](null,B.default.writeSync(this[p],e,0,e.length,this[we])),t=!1}finally{if(t)try{this[$]()}catch{}}}};W.WriteStreamSync=fs});var Xt=d(b=>{"use strict";Object.defineProperty(b,"__esModule",{value:!0});b.dealias=b.isNoFile=b.isFile=b.isAsync=b.isSync=b.isAsyncNoFile=b.isSyncNoFile=b.isAsyncFile=b.isSyncFile=void 0;var ko=new Map([["C","cwd"],["f","file"],["z","gzip"],["P","preservePaths"],["U","unlink"],["strip-components","strip"],["stripComponents","strip"],["keep-newer","newer"],["keepNewer","newer"],["keep-newer-files","newer"],["keepNewerFiles","newer"],["k","keep"],["keep-existing","keep"],["keepExisting","keep"],["m","noMtime"],["no-mtime","noMtime"],["p","preserveOwner"],["L","follow"],["h","follow"],["onentry","onReadEntry"]]),xo=s=>!!s.sync&&!!s.file;b.isSyncFile=xo;var jo=s=>!s.sync&&!!s.file;b.isAsyncFile=jo;var Uo=s=>!!s.sync&&!s.file;b.isSyncNoFile=Uo;var qo=s=>!s.sync&&!s.file;b.isAsyncNoFile=qo;var Wo=s=>!!s.sync;b.isSync=Wo;var Ho=s=>!s.sync;b.isAsync=Ho;var Zo=s=>!!s.file;b.isFile=Zo;var Go=s=>!s.file;b.isNoFile=Go;var Yo=s=>{let e=ko.get(s);return e||s},Ko=(s={})=>{if(!s)return{};let e={};for(let[t,i]of Object.entries(s)){let r=Yo(t);e[r]=i}return e.chmod===void 0&&e.noChmod===!1&&(e.chmod=!0),delete e.noChmod,e};b.dealias=Ko});var Ve=d(Qt=>{"use strict";Object.defineProperty(Qt,"__esModule",{value:!0});Qt.makeCommand=void 0;var Et=Xt(),Vo=(s,e,t,i,r)=>Object.assign((n=[],o,a)=>{Array.isArray(n)&&(o=n,n={}),typeof o=="function"&&(a=o,o=void 0),o=o?Array.from(o):[];let h=(0,Et.dealias)(n);if(r?.(h,o),(0,Et.isSyncFile)(h)){if(typeof a=="function")throw new TypeError("callback not supported for sync tar functions");return s(h,o)}else if((0,Et.isAsyncFile)(h)){let l=e(h,o);return a?l.then(()=>a(),a):l}else if((0,Et.isSyncNoFile)(h)){if(typeof a=="function")throw new TypeError("callback not supported for sync tar functions");return t(h,o)}else if((0,Et.isAsyncNoFile)(h)){if(typeof a=="function")throw new TypeError("callback only supported with file option");return i(h,o)}throw new Error("impossible options??")},{syncFile:s,asyncFile:e,syncNoFile:t,asyncNoFile:i,validate:r});Qt.makeCommand=Vo});var ds=d($e=>{"use strict";var $o=$e&&$e.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty($e,"__esModule",{value:!0});$e.constants=void 0;var Xo=$o(require("zlib")),Qo=Xo.default.constants||{ZLIB_VERNUM:4736};$e.constants=Object.freeze(Object.assign(Object.create(null),{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_VERSION_ERROR:-6,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,DEFLATE:1,INFLATE:2,GZIP:3,GUNZIP:4,DEFLATERAW:5,INFLATERAW:6,UNZIP:7,BROTLI_DECODE:8,BROTLI_ENCODE:9,Z_MIN_WINDOWBITS:8,Z_MAX_WINDOWBITS:15,Z_DEFAULT_WINDOWBITS:15,Z_MIN_CHUNK:64,Z_MAX_CHUNK:1/0,Z_DEFAULT_CHUNK:16384,Z_MIN_MEMLEVEL:1,Z_MAX_MEMLEVEL:9,Z_DEFAULT_MEMLEVEL:8,Z_MIN_LEVEL:-1,Z_MAX_LEVEL:9,Z_DEFAULT_LEVEL:-1,BROTLI_OPERATION_PROCESS:0,BROTLI_OPERATION_FLUSH:1,BROTLI_OPERATION_FINISH:2,BROTLI_OPERATION_EMIT_METADATA:3,BROTLI_MODE_GENERIC:0,BROTLI_MODE_TEXT:1,BROTLI_MODE_FONT:2,BROTLI_DEFAULT_MODE:0,BROTLI_MIN_QUALITY:0,BROTLI_MAX_QUALITY:11,BROTLI_DEFAULT_QUALITY:11,BROTLI_MIN_WINDOW_BITS:10,BROTLI_MAX_WINDOW_BITS:24,BROTLI_LARGE_MAX_WINDOW_BITS:30,BROTLI_DEFAULT_WINDOW:22,BROTLI_MIN_INPUT_BLOCK_BITS:16,BROTLI_MAX_INPUT_BLOCK_BITS:24,BROTLI_PARAM_MODE:0,BROTLI_PARAM_QUALITY:1,BROTLI_PARAM_LGWIN:2,BROTLI_PARAM_LGBLOCK:3,BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:4,BROTLI_PARAM_SIZE_HINT:5,BROTLI_PARAM_LARGE_WINDOW:6,BROTLI_PARAM_NPOSTFIX:7,BROTLI_PARAM_NDIRECT:8,BROTLI_DECODER_RESULT_ERROR:0,BROTLI_DECODER_RESULT_SUCCESS:1,BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:2,BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:0,BROTLI_DECODER_PARAM_LARGE_WINDOW:1,BROTLI_DECODER_NO_ERROR:0,BROTLI_DECODER_SUCCESS:1,BROTLI_DECODER_NEEDS_MORE_INPUT:2,BROTLI_DECODER_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:-1,BROTLI_DECODER_ERROR_FORMAT_RESERVED:-2,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:-3,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:-4,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:-5,BROTLI_DECODER_ERROR_FORMAT_CL_SPACE:-6,BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE:-7,BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT:-8,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1:-9,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2:-10,BROTLI_DECODER_ERROR_FORMAT_TRANSFORM:-11,BROTLI_DECODER_ERROR_FORMAT_DICTIONARY:-12,BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS:-13,BROTLI_DECODER_ERROR_FORMAT_PADDING_1:-14,BROTLI_DECODER_ERROR_FORMAT_PADDING_2:-15,BROTLI_DECODER_ERROR_FORMAT_DISTANCE:-16,BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET:-19,BROTLI_DECODER_ERROR_INVALID_ARGUMENTS:-20,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES:-21,BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS:-22,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP:-25,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1:-26,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2:-27,BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES:-30,BROTLI_DECODER_ERROR_UNREACHABLE:-31},Qo))});var Ps=d(f=>{"use strict";var Jo=f&&f.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),ea=f&&f.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),ta=f&&f.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Jo(t,e,i[r]);return ea(t,e),t}})(),ia=f&&f.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(f,"__esModule",{value:!0});f.ZstdDecompress=f.ZstdCompress=f.BrotliDecompress=f.BrotliCompress=f.Unzip=f.InflateRaw=f.DeflateRaw=f.Gunzip=f.Gzip=f.Inflate=f.Deflate=f.Zlib=f.ZlibError=f.constants=void 0;var _s=ia(require("assert")),Ae=require("buffer"),sa=We(),qr=ta(require("zlib")),te=ds(),ra=ds();Object.defineProperty(f,"constants",{enumerable:!0,get:function(){return ra.constants}});var na=Ae.Buffer.concat,Wr=Object.getOwnPropertyDescriptor(Ae.Buffer,"concat"),oa=s=>s,ms=Wr?.writable===!0||Wr?.set!==void 0?s=>{Ae.Buffer.concat=s?oa:na}:s=>{},Ie=Symbol("_superWrite"),Fe=class extends Error{code;errno;constructor(e,t){super("zlib: "+e.message,{cause:e}),this.code=e.code,this.errno=e.errno,this.code||(this.code="ZLIB_ERROR"),this.message="zlib: "+e.message,Error.captureStackTrace(this,t??this.constructor)}get name(){return"ZlibError"}};f.ZlibError=Fe;var ps=Symbol("flushFlag"),bt=class extends sa.Minipass{#e=!1;#i=!1;#s;#n;#r;#t;#o;get sawError(){return this.#e}get handle(){return this.#t}get flushFlag(){return this.#s}constructor(e,t){if(!e||typeof e!="object")throw new TypeError("invalid options for ZlibBase constructor");if(super(e),this.#s=e.flush??0,this.#n=e.finishFlush??0,this.#r=e.fullFlushFlag??0,typeof qr[t]!="function")throw new TypeError("Compression method not supported: "+t);try{this.#t=new qr[t](e)}catch(i){throw new Fe(i,this.constructor)}this.#o=i=>{this.#e||(this.#e=!0,this.close(),this.emit("error",i))},this.#t?.on("error",i=>this.#o(new Fe(i))),this.once("end",()=>this.close)}close(){this.#t&&(this.#t.close(),this.#t=void 0,this.emit("close"))}reset(){if(!this.#e)return(0,_s.default)(this.#t,"zlib binding closed"),this.#t.reset?.()}flush(e){this.ended||(typeof e!="number"&&(e=this.#r),this.write(Object.assign(Ae.Buffer.alloc(0),{[ps]:e})))}end(e,t,i){return typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),e&&(t?this.write(e,t):this.write(e)),this.flush(this.#n),this.#i=!0,super.end(i)}get ended(){return this.#i}[Ie](e){return super.write(e)}write(e,t,i){if(typeof t=="function"&&(i=t,t="utf8"),typeof e=="string"&&(e=Ae.Buffer.from(e,t)),this.#e)return;(0,_s.default)(this.#t,"zlib binding closed");let r=this.#t._handle,n=r.close;r.close=()=>{};let o=this.#t.close;this.#t.close=()=>{},ms(!0);let a;try{let l=typeof e[ps]=="number"?e[ps]:this.#s;a=this.#t._processChunk(e,l),ms(!1)}catch(l){ms(!1),this.#o(new Fe(l,this.write))}finally{this.#t&&(this.#t._handle=r,r.close=n,this.#t.close=o,this.#t.removeAllListeners("error"))}this.#t&&this.#t.on("error",l=>this.#o(new Fe(l,this.write)));let h;if(a)if(Array.isArray(a)&&a.length>0){let l=a[0];h=this[Ie](Ae.Buffer.from(l));for(let u=1;u<a.length;u++)h=this[Ie](a[u])}else h=this[Ie](Ae.Buffer.from(a));return i&&i(),h}},ie=class extends bt{#e;#i;constructor(e,t){e=e||{},e.flush=e.flush||te.constants.Z_NO_FLUSH,e.finishFlush=e.finishFlush||te.constants.Z_FINISH,e.fullFlushFlag=te.constants.Z_FULL_FLUSH,super(e,t),this.#e=e.level,this.#i=e.strategy}params(e,t){if(!this.sawError){if(!this.handle)throw new Error("cannot switch params when binding is closed");if(!this.handle.params)throw new Error("not supported in this implementation");if(this.#e!==e||this.#i!==t){this.flush(te.constants.Z_SYNC_FLUSH),(0,_s.default)(this.handle,"zlib binding closed");let i=this.handle.flush;this.handle.flush=(r,n)=>{typeof r=="function"&&(n=r,r=this.flushFlag),this.flush(r),n?.()};try{this.handle.params(e,t)}finally{this.handle.flush=i}this.handle&&(this.#e=e,this.#i=t)}}}};f.Zlib=ie;var ws=class extends ie{constructor(e){super(e,"Deflate")}};f.Deflate=ws;var ys=class extends ie{constructor(e){super(e,"Inflate")}};f.Inflate=ys;var Es=class extends ie{#e;constructor(e){super(e,"Gzip"),this.#e=e&&!!e.portable}[Ie](e){return this.#e?(this.#e=!1,e[9]=255,super[Ie](e)):super[Ie](e)}};f.Gzip=Es;var bs=class extends ie{constructor(e){super(e,"Gunzip")}};f.Gunzip=bs;var Ss=class extends ie{constructor(e){super(e,"DeflateRaw")}};f.DeflateRaw=Ss;var gs=class extends ie{constructor(e){super(e,"InflateRaw")}};f.InflateRaw=gs;var Os=class extends ie{constructor(e){super(e,"Unzip")}};f.Unzip=Os;var Jt=class extends bt{constructor(e,t){e=e||{},e.flush=e.flush||te.constants.BROTLI_OPERATION_PROCESS,e.finishFlush=e.finishFlush||te.constants.BROTLI_OPERATION_FINISH,e.fullFlushFlag=te.constants.BROTLI_OPERATION_FLUSH,super(e,t)}},Rs=class extends Jt{constructor(e){super(e,"BrotliCompress")}};f.BrotliCompress=Rs;var vs=class extends Jt{constructor(e){super(e,"BrotliDecompress")}};f.BrotliDecompress=vs;var ei=class extends bt{constructor(e,t){e=e||{},e.flush=e.flush||te.constants.ZSTD_e_continue,e.finishFlush=e.finishFlush||te.constants.ZSTD_e_end,e.fullFlushFlag=te.constants.ZSTD_e_flush,super(e,t)}},Ts=class extends ei{constructor(e){super(e,"ZstdCompress")}};f.ZstdCompress=Ts;var Ds=class extends ei{constructor(e){super(e,"ZstdDecompress")}};f.ZstdDecompress=Ds});var Gr=d(Xe=>{"use strict";Object.defineProperty(Xe,"__esModule",{value:!0});Xe.parse=Xe.encode=void 0;var aa=(s,e)=>{if(Number.isSafeInteger(s))s<0?la(s,e):ha(s,e);else throw Error("cannot encode number outside of javascript safe integer range");return e};Xe.encode=aa;var ha=(s,e)=>{e[0]=128;for(var t=e.length;t>1;t--)e[t-1]=s&255,s=Math.floor(s/256)},la=(s,e)=>{e[0]=255;var t=!1;s=s*-1;for(var i=e.length;i>1;i--){var r=s&255;s=Math.floor(s/256),t?e[i-1]=Hr(r):r===0?e[i-1]=0:(t=!0,e[i-1]=Zr(r))}},ua=s=>{let e=s[0],t=e===128?fa(s.subarray(1,s.length)):e===255?ca(s):null;if(t===null)throw Error("invalid base256 encoding");if(!Number.isSafeInteger(t))throw Error("parsed number outside of javascript safe integer range");return t};Xe.parse=ua;var ca=s=>{for(var e=s.length,t=0,i=!1,r=e-1;r>-1;r--){var n=Number(s[r]),o;i?o=Hr(n):n===0?o=n:(i=!0,o=Zr(n)),o!==0&&(t-=o*Math.pow(256,e-r-1))}return t},fa=s=>{for(var e=s.length,t=0,i=e-1;i>-1;i--){var r=Number(s[i]);r!==0&&(t+=r*Math.pow(256,e-i-1))}return t},Hr=s=>(255^s)&255,Zr=s=>(255^s)+1&255});var Ns=d(x=>{"use strict";Object.defineProperty(x,"__esModule",{value:!0});x.code=x.name=x.isName=x.isCode=void 0;var da=s=>x.name.has(s);x.isCode=da;var ma=s=>x.code.has(s);x.isName=ma;x.name=new Map([["0","File"],["","OldFile"],["1","Link"],["2","SymbolicLink"],["3","CharacterDevice"],["4","BlockDevice"],["5","Directory"],["6","FIFO"],["7","ContiguousFile"],["g","GlobalExtendedHeader"],["x","ExtendedHeader"],["A","SolarisACL"],["D","GNUDumpDir"],["I","Inode"],["K","NextFileHasLongLinkpath"],["L","NextFileHasLongPath"],["M","ContinuationFile"],["N","OldGnuLongPath"],["S","SparseFile"],["V","TapeVolumeHeader"],["X","OldExtendedHeader"]]);x.code=new Map(Array.from(x.name).map(s=>[s[1],s[0]]))});var Je=d(se=>{"use strict";var pa=se&&se.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),_a=se&&se.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),Yr=se&&se.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&pa(t,e,i[r]);return _a(t,e),t}})();Object.defineProperty(se,"__esModule",{value:!0});se.Header=void 0;var Qe=require("node:path"),Kr=Yr(Gr()),St=Yr(Ns()),As=class{cksumValid=!1;needPax=!1;nullBlock=!1;block;path;mode;uid;gid;size;cksum;#e="Unsupported";linkpath;uname;gname;devmaj=0;devmin=0;atime;ctime;mtime;charset;comment;constructor(e,t=0,i,r){Buffer.isBuffer(e)?this.decode(e,t||0,i,r):e&&this.#i(e)}decode(e,t,i,r){if(t||(t=0),!e||!(e.length>=t+512))throw new Error("need 512 bytes for header");this.path=i?.path??Ce(e,t,100),this.mode=i?.mode??r?.mode??be(e,t+100,8),this.uid=i?.uid??r?.uid??be(e,t+108,8),this.gid=i?.gid??r?.gid??be(e,t+116,8),this.size=i?.size??r?.size??be(e,t+124,12),this.mtime=i?.mtime??r?.mtime??Ms(e,t+136,12),this.cksum=be(e,t+148,12),r&&this.#i(r,!0),i&&this.#i(i);let n=Ce(e,t+156,1);if(St.isCode(n)&&(this.#e=n||"0"),this.#e==="0"&&this.path.slice(-1)==="/"&&(this.#e="5"),this.#e==="5"&&(this.size=0),this.linkpath=Ce(e,t+157,100),e.subarray(t+257,t+265).toString()==="ustar\x0000")if(this.uname=i?.uname??r?.uname??Ce(e,t+265,32),this.gname=i?.gname??r?.gname??Ce(e,t+297,32),this.devmaj=i?.devmaj??r?.devmaj??be(e,t+329,8)??0,this.devmin=i?.devmin??r?.devmin??be(e,t+337,8)??0,e[t+475]!==0){let a=Ce(e,t+345,155);this.path=a+"/"+this.path}else{let a=Ce(e,t+345,130);a&&(this.path=a+"/"+this.path),this.atime=i?.atime??r?.atime??Ms(e,t+476,12),this.ctime=i?.ctime??r?.ctime??Ms(e,t+488,12)}let o=256;for(let a=t;a<t+148;a++)o+=e[a];for(let a=t+156;a<t+512;a++)o+=e[a];this.cksumValid=o===this.cksum,this.cksum===void 0&&o===256&&(this.nullBlock=!0)}#i(e,t=!1){Object.assign(this,Object.fromEntries(Object.entries(e).filter(([i,r])=>!(r==null||i==="path"&&t||i==="linkpath"&&t||i==="global"))))}encode(e,t=0){if(e||(e=this.block=Buffer.alloc(512)),this.#e==="Unsupported"&&(this.#e="0"),!(e.length>=t+512))throw new Error("need 512 bytes for header");let i=this.ctime||this.atime?130:155,r=wa(this.path||"",i),n=r[0],o=r[1];this.needPax=!!r[2],this.needPax=Be(e,t,100,n)||this.needPax,this.needPax=Se(e,t+100,8,this.mode)||this.needPax,this.needPax=Se(e,t+108,8,this.uid)||this.needPax,this.needPax=Se(e,t+116,8,this.gid)||this.needPax,this.needPax=Se(e,t+124,12,this.size)||this.needPax,this.needPax=Ls(e,t+136,12,this.mtime)||this.needPax,e[t+156]=Number(this.#e.codePointAt(0)),this.needPax=Be(e,t+157,100,this.linkpath)||this.needPax,e.write("ustar\x0000",t+257,8),this.needPax=Be(e,t+265,32,this.uname)||this.needPax,this.needPax=Be(e,t+297,32,this.gname)||this.needPax,this.needPax=Se(e,t+329,8,this.devmaj)||this.needPax,this.needPax=Se(e,t+337,8,this.devmin)||this.needPax,this.needPax=Be(e,t+345,i,o)||this.needPax,e[t+475]!==0?this.needPax=Be(e,t+345,155,o)||this.needPax:(this.needPax=Be(e,t+345,130,o)||this.needPax,this.needPax=Ls(e,t+476,12,this.atime)||this.needPax,this.needPax=Ls(e,t+488,12,this.ctime)||this.needPax);let a=256;for(let h=t;h<t+148;h++)a+=e[h];for(let h=t+156;h<t+512;h++)a+=e[h];return this.cksum=a,Se(e,t+148,8,this.cksum),this.cksumValid=!0,this.needPax}get type(){return this.#e==="Unsupported"?this.#e:St.name.get(this.#e)}get typeKey(){return this.#e}set type(e){let t=String(St.code.get(e));if(St.isCode(t)||t==="Unsupported")this.#e=t;else if(St.isCode(e))this.#e=e;else throw new TypeError("invalid entry type: "+e)}};se.Header=As;var wa=(s,e)=>{let i=s,r="",n,o=Qe.posix.parse(s).root||".";if(Buffer.byteLength(i)<100)n=[i,r,!1];else{r=Qe.posix.dirname(i),i=Qe.posix.basename(i);do Buffer.byteLength(i)<=100&&Buffer.byteLength(r)<=e?n=[i,r,!1]:Buffer.byteLength(i)>100&&Buffer.byteLength(r)<=e?n=[i.slice(0,99),r,!0]:(i=Qe.posix.join(Qe.posix.basename(r),i),r=Qe.posix.dirname(r));while(r!==o&&n===void 0);n||(n=[s.slice(0,99),"",!0])}return n},Ce=(s,e,t)=>s.subarray(e,e+t).toString("utf8").replace(/\0.*/,""),Ms=(s,e,t)=>ya(be(s,e,t)),ya=s=>s===void 0?void 0:new Date(s*1e3),be=(s,e,t)=>Number(s[e])&128?Kr.parse(s.subarray(e,e+t)):ba(s,e,t),Ea=s=>isNaN(s)?void 0:s,ba=(s,e,t)=>Ea(parseInt(s.subarray(e,e+t).toString("utf8").replace(/\0.*$/,"").trim(),8)),Sa={12:8589934591,8:2097151},Se=(s,e,t,i)=>i===void 0?!1:i>Sa[t]||i<0?(Kr.encode(i,s.subarray(e,e+t)),!0):(ga(s,e,t,i),!1),ga=(s,e,t,i)=>s.write(Oa(i,t),e,t,"ascii"),Oa=(s,e)=>Ra(Math.floor(s).toString(8),e),Ra=(s,e)=>(s.length===e-1?s:new Array(e-s.length-1).join("0")+s+" ")+"\0",Ls=(s,e,t,i)=>i===void 0?!1:Se(s,e,t,i.getTime()/1e3),va=new Array(156).join("\0"),Be=(s,e,t,i)=>i===void 0?!1:(s.write(i+va,e,t,"utf8"),i.length!==Buffer.byteLength(i)||i.length>t)});var ii=d(ti=>{"use strict";Object.defineProperty(ti,"__esModule",{value:!0});ti.Pax=void 0;var Ta=require("node:path"),Da=Je(),Is=class s{atime;mtime;ctime;charset;comment;gid;uid;gname;uname;linkpath;dev;ino;nlink;path;size;mode;global;constructor(e,t=!1){this.atime=e.atime,this.charset=e.charset,this.comment=e.comment,this.ctime=e.ctime,this.dev=e.dev,this.gid=e.gid,this.global=t,this.gname=e.gname,this.ino=e.ino,this.linkpath=e.linkpath,this.mtime=e.mtime,this.nlink=e.nlink,this.path=e.path,this.size=e.size,this.uid=e.uid,this.uname=e.uname}encode(){let e=this.encodeBody();if(e==="")return Buffer.allocUnsafe(0);let t=Buffer.byteLength(e),i=512*Math.ceil(1+t/512),r=Buffer.allocUnsafe(i);for(let n=0;n<512;n++)r[n]=0;new Da.Header({path:("PaxHeader/"+(0,Ta.basename)(this.path??"")).slice(0,99),mode:this.mode||420,uid:this.uid,gid:this.gid,size:t,mtime:this.mtime,type:this.global?"GlobalExtendedHeader":"ExtendedHeader",linkpath:"",uname:this.uname||"",gname:this.gname||"",devmaj:0,devmin:0,atime:this.atime,ctime:this.ctime}).encode(r),r.write(e,512,t,"utf8");for(let n=t+512;n<r.length;n++)r[n]=0;return r}encodeBody(){return this.encodeField("path")+this.encodeField("ctime")+this.encodeField("atime")+this.encodeField("dev")+this.encodeField("ino")+this.encodeField("nlink")+this.encodeField("charset")+this.encodeField("comment")+this.encodeField("gid")+this.encodeField("gname")+this.encodeField("linkpath")+this.encodeField("mtime")+this.encodeField("size")+this.encodeField("uid")+this.encodeField("uname")}encodeField(e){if(this[e]===void 0)return"";let t=this[e],i=t instanceof Date?t.getTime()/1e3:t,r=" "+(e==="dev"||e==="ino"||e==="nlink"?"SCHILY.":"")+e+"="+i+`
+`,n=Buffer.byteLength(r),o=Math.floor(Math.log(n)/Math.log(10))+1;return n+o>=Math.pow(10,o)&&(o+=1),o+n+r}static parse(e,t,i=!1){return new s(Pa(Na(e),t),i)}};ti.Pax=Is;var Pa=(s,e)=>e?Object.assign({},e,s):s,Na=s=>s.replace(/\n$/,"").split(`
+`).reduce(Ma,Object.create(null)),Ma=(s,e)=>{let t=parseInt(e,10);if(t!==Buffer.byteLength(e)+1)return s;e=e.slice((t+" ").length);let i=e.split("="),r=i.shift();if(!r)return s;let n=r.replace(/^SCHILY\.(dev|ino|nlink)/,"$1"),o=i.join("=");return s[n]=/^([A-Z]+\.)?([mac]|birth|creation)time$/.test(n)?new Date(Number(o)*1e3):/^[0-9]+$/.test(o)?+o:o,s}});var et=d(si=>{"use strict";Object.defineProperty(si,"__esModule",{value:!0});si.normalizeWindowsPath=void 0;var La=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform;si.normalizeWindowsPath=La!=="win32"?s=>s:s=>s&&s.replaceAll(/\\/g,"/")});var oi=d(ni=>{"use strict";Object.defineProperty(ni,"__esModule",{value:!0});ni.ReadEntry=void 0;var Aa=We(),ri=et(),Fs=class extends Aa.Minipass{extended;globalExtended;header;startBlockSize;blockRemain;remain;type;meta=!1;ignore=!1;path;mode;uid;gid;uname;gname;size=0;mtime;atime;ctime;linkpath;dev;ino;nlink;invalid=!1;absolute;unsupported=!1;constructor(e,t,i){switch(super({}),this.pause(),this.extended=t,this.globalExtended=i,this.header=e,this.remain=e.size??0,this.startBlockSize=512*Math.ceil(this.remain/512),this.blockRemain=this.startBlockSize,this.type=e.type,this.type){case"File":case"OldFile":case"Link":case"SymbolicLink":case"CharacterDevice":case"BlockDevice":case"Directory":case"FIFO":case"ContiguousFile":case"GNUDumpDir":break;case"NextFileHasLongLinkpath":case"NextFileHasLongPath":case"OldGnuLongPath":case"GlobalExtendedHeader":case"ExtendedHeader":case"OldExtendedHeader":this.meta=!0;break;default:this.ignore=!0}if(!e.path)throw new Error("no path provided for tar.ReadEntry");this.path=(0,ri.normalizeWindowsPath)(e.path),this.mode=e.mode,this.mode&&(this.mode=this.mode&4095),this.uid=e.uid,this.gid=e.gid,this.uname=e.uname,this.gname=e.gname,this.size=this.remain,this.mtime=e.mtime,this.atime=e.atime,this.ctime=e.ctime,this.linkpath=e.linkpath?(0,ri.normalizeWindowsPath)(e.linkpath):void 0,this.uname=e.uname,this.gname=e.gname,t&&this.#e(t),i&&this.#e(i,!0)}write(e){let t=e.length;if(t>this.blockRemain)throw new Error("writing more to entry than is appropriate");let i=this.remain,r=this.blockRemain;return this.remain=Math.max(0,i-t),this.blockRemain=Math.max(0,r-t),this.ignore?!0:i>=t?super.write(e):super.write(e.subarray(0,i))}#e(e,t=!1){e.path&&(e.path=(0,ri.normalizeWindowsPath)(e.path)),e.linkpath&&(e.linkpath=(0,ri.normalizeWindowsPath)(e.linkpath)),Object.assign(this,Object.fromEntries(Object.entries(e).filter(([i,r])=>!(r==null||i==="path"&&t))))}};ni.ReadEntry=Fs});var hi=d(ai=>{"use strict";Object.defineProperty(ai,"__esModule",{value:!0});ai.warnMethod=void 0;var Ia=(s,e,t,i={})=>{s.file&&(i.file=s.file),s.cwd&&(i.cwd=s.cwd),i.code=t instanceof Error&&t.code||e,i.tarCode=e,!s.strict&&i.recoverable!==!1?(t instanceof Error&&(i=Object.assign(t,i),t=t.message),s.emit("warn",e,t,i)):t instanceof Error?s.emit("error",Object.assign(t,i)):s.emit("error",Object.assign(new Error(`${e}: ${t}`),i))};ai.warnMethod=Ia});var _i=d(pi=>{"use strict";Object.defineProperty(pi,"__esModule",{value:!0});pi.Parser=void 0;var Fa=require("events"),Cs=Ps(),Vr=Je(),$r=ii(),Ca=oi(),Ba=hi(),za=1024*1024,js=Buffer.from([31,139]),Us=Buffer.from([40,181,47,253]),ka=Math.max(js.length,Us.length),H=Symbol("state"),ze=Symbol("writeEntry"),de=Symbol("readEntry"),Bs=Symbol("nextEntry"),Xr=Symbol("processEntry"),re=Symbol("extendedHeader"),gt=Symbol("globalExtendedHeader"),ge=Symbol("meta"),Qr=Symbol("emitMeta"),_=Symbol("buffer"),me=Symbol("queue"),Oe=Symbol("ended"),zs=Symbol("emittedEnd"),ke=Symbol("emit"),S=Symbol("unzip"),li=Symbol("consumeChunk"),ui=Symbol("consumeChunkSub"),ks=Symbol("consumeBody"),Jr=Symbol("consumeMeta"),en=Symbol("consumeHeader"),Ot=Symbol("consuming"),xs=Symbol("bufferConcat"),ci=Symbol("maybeEnd"),tt=Symbol("writing"),Re=Symbol("aborted"),fi=Symbol("onDone"),xe=Symbol("sawValidEntry"),di=Symbol("sawNullBlock"),mi=Symbol("sawEOF"),tn=Symbol("closeStream"),xa=()=>!0,qs=class extends Fa.EventEmitter{file;strict;maxMetaEntrySize;filter;brotli;zstd;writable=!0;readable=!1;[me]=[];[_];[de];[ze];[H]="begin";[ge]="";[re];[gt];[Oe]=!1;[S];[Re]=!1;[xe];[di]=!1;[mi]=!1;[tt]=!1;[Ot]=!1;[zs]=!1;constructor(e={}){super(),this.file=e.file||"",this.on(fi,()=>{(this[H]==="begin"||this[xe]===!1)&&this.warn("TAR_BAD_ARCHIVE","Unrecognized archive format")}),e.ondone?this.on(fi,e.ondone):this.on(fi,()=>{this.emit("prefinish"),this.emit("finish"),this.emit("end")}),this.strict=!!e.strict,this.maxMetaEntrySize=e.maxMetaEntrySize||za,this.filter=typeof e.filter=="function"?e.filter:xa;let t=e.file&&(e.file.endsWith(".tar.br")||e.file.endsWith(".tbr"));this.brotli=!(e.gzip||e.zstd)&&e.brotli!==void 0?e.brotli:t?void 0:!1;let i=e.file&&(e.file.endsWith(".tar.zst")||e.file.endsWith(".tzst"));this.zstd=!(e.gzip||e.brotli)&&e.zstd!==void 0?e.zstd:i?!0:void 0,this.on("end",()=>this[tn]()),typeof e.onwarn=="function"&&this.on("warn",e.onwarn),typeof e.onReadEntry=="function"&&this.on("entry",e.onReadEntry)}warn(e,t,i={}){(0,Ba.warnMethod)(this,e,t,i)}[en](e,t){this[xe]===void 0&&(this[xe]=!1);let i;try{i=new Vr.Header(e,t,this[re],this[gt])}catch(r){return this.warn("TAR_ENTRY_INVALID",r)}if(i.nullBlock)this[di]?(this[mi]=!0,this[H]==="begin"&&(this[H]="header"),this[ke]("eof")):(this[di]=!0,this[ke]("nullBlock"));else if(this[di]=!1,!i.cksumValid)this.warn("TAR_ENTRY_INVALID","checksum failure",{header:i});else if(!i.path)this.warn("TAR_ENTRY_INVALID","path is required",{header:i});else{let r=i.type;if(/^(Symbolic)?Link$/.test(r)&&!i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath required",{header:i});else if(!/^(Symbolic)?Link$/.test(r)&&!/^(Global)?ExtendedHeader$/.test(r)&&i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath forbidden",{header:i});else{let n=this[ze]=new Ca.ReadEntry(i,this[re],this[gt]);if(!this[xe])if(n.remain){let o=()=>{n.invalid||(this[xe]=!0)};n.on("end",o)}else this[xe]=!0;n.meta?n.size>this.maxMetaEntrySize?(n.ignore=!0,this[ke]("ignoredEntry",n),this[H]="ignore",n.resume()):n.size>0&&(this[ge]="",n.on("data",o=>this[ge]+=o),this[H]="meta"):(this[re]=void 0,n.ignore=n.ignore||!this.filter(n.path,n),n.ignore?(this[ke]("ignoredEntry",n),this[H]=n.remain?"ignore":"header",n.resume()):(n.remain?this[H]="body":(this[H]="header",n.end()),this[de]?this[me].push(n):(this[me].push(n),this[Bs]())))}}}[tn](){queueMicrotask(()=>this.emit("close"))}[Xr](e){let t=!0;if(!e)this[de]=void 0,t=!1;else if(Array.isArray(e)){let[i,...r]=e;this.emit(i,...r)}else this[de]=e,this.emit("entry",e),e.emittedEnd||(e.on("end",()=>this[Bs]()),t=!1);return t}[Bs](){do;while(this[Xr](this[me].shift()));if(this[me].length===0){let e=this[de];!e||e.flowing||e.size===e.remain?this[tt]||this.emit("drain"):e.once("drain",()=>this.emit("drain"))}}[ks](e,t){let i=this[ze];if(!i)throw new Error("attempt to consume body without entry??");let r=i.blockRemain??0,n=r>=e.length&&t===0?e:e.subarray(t,t+r);return i.write(n),i.blockRemain||(this[H]="header",this[ze]=void 0,i.end()),n.length}[Jr](e,t){let i=this[ze],r=this[ks](e,t);return!this[ze]&&i&&this[Qr](i),r}[ke](e,t,i){this[me].length===0&&!this[de]?this.emit(e,t,i):this[me].push([e,t,i])}[Qr](e){switch(this[ke]("meta",this[ge]),e.type){case"ExtendedHeader":case"OldExtendedHeader":this[re]=$r.Pax.parse(this[ge],this[re],!1);break;case"GlobalExtendedHeader":this[gt]=$r.Pax.parse(this[ge],this[gt],!0);break;case"NextFileHasLongPath":case"OldGnuLongPath":{let t=this[re]??Object.create(null);this[re]=t,t.path=this[ge].replace(/\0.*/,"");break}case"NextFileHasLongLinkpath":{let t=this[re]||Object.create(null);this[re]=t,t.linkpath=this[ge].replace(/\0.*/,"");break}default:throw new Error("unknown meta: "+e.type)}}abort(e){this[Re]=!0,this.emit("abort",e),this.warn("TAR_ABORT",e,{recoverable:!1})}write(e,t,i){if(typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8")),this[Re])return i?.(),!1;if((this[S]===void 0||this.brotli===void 0&&this[S]===!1)&&e){if(this[_]&&(e=Buffer.concat([this[_],e]),this[_]=void 0),e.length<ka)return this[_]=e,i?.(),!0;for(let h=0;this[S]===void 0&&h<js.length;h++)e[h]!==js[h]&&(this[S]=!1);let o=!1;if(this[S]===!1&&this.zstd!==!1){o=!0;for(let h=0;h<Us.length;h++)if(e[h]!==Us[h]){o=!1;break}}let a=this.brotli===void 0&&!o;if(this[S]===!1&&a)if(e.length<512)if(this[Oe])this.brotli=!0;else return this[_]=e,i?.(),!0;else try{new Vr.Header(e.subarray(0,512)),this.brotli=!1}catch{this.brotli=!0}if(this[S]===void 0||this[S]===!1&&(this.brotli||o)){let h=this[Oe];this[Oe]=!1,this[S]=this[S]===void 0?new Cs.Unzip({}):o?new Cs.ZstdDecompress({}):new Cs.BrotliDecompress({}),this[S].on("data",u=>this[li](u)),this[S].on("error",u=>this.abort(u)),this[S].on("end",()=>{this[Oe]=!0,this[li]()}),this[tt]=!0;let l=!!this[S][h?"end":"write"](e);return this[tt]=!1,i?.(),l}}this[tt]=!0,this[S]?this[S].write(e):this[li](e),this[tt]=!1;let n=this[me].length>0?!1:this[de]?this[de].flowing:!0;return!n&&this[me].length===0&&this[de]?.once("drain",()=>this.emit("drain")),i?.(),n}[xs](e){e&&!this[Re]&&(this[_]=this[_]?Buffer.concat([this[_],e]):e)}[ci](){if(this[Oe]&&!this[zs]&&!this[Re]&&!this[Ot]){this[zs]=!0;let e=this[ze];if(e&&e.blockRemain){let t=this[_]?this[_].length:0;this.warn("TAR_BAD_ARCHIVE",`Truncated input (needed ${e.blockRemain} more bytes, only ${t} available)`,{entry:e}),this[_]&&e.write(this[_]),e.end()}this[ke](fi)}}[li](e){if(this[Ot]&&e)this[xs](e);else if(!e&&!this[_])this[ci]();else if(e){if(this[Ot]=!0,this[_]){this[xs](e);let t=this[_];this[_]=void 0,this[ui](t)}else this[ui](e);for(;this[_]&&this[_]?.length>=512&&!this[Re]&&!this[mi];){let t=this[_];this[_]=void 0,this[ui](t)}this[Ot]=!1}(!this[_]||this[Oe])&&this[ci]()}[ui](e){let t=0,i=e.length;for(;t+512<=i&&!this[Re]&&!this[mi];)switch(this[H]){case"begin":case"header":this[en](e,t),t+=512;break;case"ignore":case"body":t+=this[ks](e,t);break;case"meta":t+=this[Jr](e,t);break;default:throw new Error("invalid state: "+this[H])}t<i&&(this[_]=this[_]?Buffer.concat([e.subarray(t),this[_]]):e.subarray(t))}end(e,t,i){return typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,t)),i&&this.once("finish",i),this[Re]||(this[S]?(e&&this[S].write(e),this[S].end()):(this[Oe]=!0,(this.brotli===void 0||this.zstd===void 0)&&(e=e||Buffer.alloc(0)),e&&this.write(e),this[ci]())),this}};pi.Parser=qs});var yi=d(wi=>{"use strict";Object.defineProperty(wi,"__esModule",{value:!0});wi.stripTrailingSlashes=void 0;var ja=s=>{let e=s.length-1,t=-1;for(;e>-1&&s.charAt(e)==="/";)t=e,e--;return t===-1?s:s.slice(0,t)};wi.stripTrailingSlashes=ja});var st=d(C=>{"use strict";var Ua=C&&C.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),qa=C&&C.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),Wa=C&&C.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Ua(t,e,i[r]);return qa(t,e),t}})(),Ha=C&&C.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(C,"__esModule",{value:!0});C.list=C.filesFilter=void 0;var Za=Wa(Ke()),it=Ha(require("node:fs")),sn=require("path"),Ga=Ve(),Ei=_i(),Ws=yi(),Ya=s=>{let e=s.onReadEntry;s.onReadEntry=e?t=>{e(t),t.resume()}:t=>t.resume()},Ka=(s,e)=>{let t=new Map(e.map(n=>[(0,Ws.stripTrailingSlashes)(n),!0])),i=s.filter,r=(n,o="")=>{let a=o||(0,sn.parse)(n).root||".",h;if(n===a)h=!1;else{let l=t.get(n);h=l!==void 0?l:r((0,sn.dirname)(n),a)}return t.set(n,h),h};s.filter=i?(n,o)=>i(n,o)&&r((0,Ws.stripTrailingSlashes)(n)):n=>r((0,Ws.stripTrailingSlashes)(n))};C.filesFilter=Ka;var Va=s=>{let e=new Ei.Parser(s),t=s.file,i;try{i=it.default.openSync(t,"r");let r=it.default.fstatSync(i),n=s.maxReadSize||16*1024*1024;if(r.size<n){let o=Buffer.allocUnsafe(r.size),a=it.default.readSync(i,o,0,r.size,0);e.end(a===o.byteLength?o:o.subarray(0,a))}else{let o=0,a=Buffer.allocUnsafe(n);for(;o<r.size;){let h=it.default.readSync(i,a,0,n,o);if(h===0)break;o+=h,e.write(a.subarray(0,h))}e.end()}}finally{if(typeof i=="number")try{it.default.closeSync(i)}catch{}}},$a=(s,e)=>{let t=new Ei.Parser(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,a)=>{t.on("error",a),t.on("end",o),it.default.stat(r,(h,l)=>{if(h)a(h);else{let u=new Za.ReadStream(r,{readSize:i,size:l.size});u.on("error",a),u.pipe(t)}})})};C.list=(0,Ga.makeCommand)(Va,$a,s=>new Ei.Parser(s),s=>new Ei.Parser(s),(s,e)=>{e?.length&&(0,C.filesFilter)(s,e),s.noResume||Ya(s)})});var rn=d(bi=>{"use strict";Object.defineProperty(bi,"__esModule",{value:!0});bi.modeFix=void 0;var Xa=(s,e,t)=>(s&=4095,t&&(s=(s|384)&-19),e&&(s&256&&(s|=64),s&32&&(s|=8),s&4&&(s|=1)),s);bi.modeFix=Xa});var Hs=d(Si=>{"use strict";Object.defineProperty(Si,"__esModule",{value:!0});Si.stripAbsolutePath=void 0;var Qa=require("node:path"),{isAbsolute:Ja,parse:nn}=Qa.win32,eh=s=>{let e="",t=nn(s);for(;Ja(s)||t.root;){let i=s.charAt(0)==="/"&&s.slice(0,4)!=="//?/"?"/":t.root;s=s.slice(i.length),e+=i,t=nn(s)}return[e,s]};Si.stripAbsolutePath=eh});var Gs=d(rt=>{"use strict";Object.defineProperty(rt,"__esModule",{value:!0});rt.decode=rt.encode=void 0;var gi=["|","<",">","?",":"],Zs=gi.map(s=>String.fromCodePoint(61440+Number(s.codePointAt(0)))),th=new Map(gi.map((s,e)=>[s,Zs[e]])),ih=new Map(Zs.map((s,e)=>[s,gi[e]])),sh=s=>gi.reduce((e,t)=>e.split(t).join(th.get(t)),s);rt.encode=sh;var rh=s=>Zs.reduce((e,t)=>e.split(t).join(ih.get(t)),s);rt.decode=rh});var sr=d(M=>{"use strict";var nh=M&&M.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),oh=M&&M.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),ah=M&&M.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&nh(t,e,i[r]);return oh(t,e),t}})(),cn=M&&M.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(M,"__esModule",{value:!0});M.WriteEntryTar=M.WriteEntrySync=M.WriteEntry=void 0;var oe=cn(require("fs")),fn=We(),on=cn(require("path")),dn=Je(),mn=rn(),ne=et(),pn=Xt(),_n=ii(),wn=Hs(),hh=yi(),yn=hi(),lh=ah(Gs()),En=(s,e)=>e?(s=(0,ne.normalizeWindowsPath)(s).replace(/^\.(\/|$)/,""),(0,hh.stripTrailingSlashes)(e)+"/"+s):(0,ne.normalizeWindowsPath)(s),uh=16*1024*1024,an=Symbol("process"),hn=Symbol("file"),ln=Symbol("directory"),Ks=Symbol("symlink"),un=Symbol("hardlink"),Rt=Symbol("header"),Oi=Symbol("read"),Vs=Symbol("lstat"),Ri=Symbol("onlstat"),$s=Symbol("onread"),Xs=Symbol("onreadlink"),Qs=Symbol("openfile"),Js=Symbol("onopenfile"),ve=Symbol("close"),vi=Symbol("mode"),er=Symbol("awaitDrain"),Ys=Symbol("ondrain"),ae=Symbol("prefix"),Ti=class extends fn.Minipass{path;portable;myuid=process.getuid&&process.getuid()||0;myuser=process.env.USER||"";maxReadSize;linkCache;statCache;preservePaths;cwd;strict;mtime;noPax;noMtime;prefix;fd;blockLen=0;blockRemain=0;buf;pos=0;remain=0;length=0;offset=0;win32;absolute;header;type;linkpath;stat;onWriteEntry;#e=!1;constructor(e,t={}){let i=(0,pn.dealias)(t);super(),this.path=(0,ne.normalizeWindowsPath)(e),this.portable=!!i.portable,this.maxReadSize=i.maxReadSize||uh,this.linkCache=i.linkCache||new Map,this.statCache=i.statCache||new Map,this.preservePaths=!!i.preservePaths,this.cwd=(0,ne.normalizeWindowsPath)(i.cwd||process.cwd()),this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.mtime=i.mtime,this.prefix=i.prefix?(0,ne.normalizeWindowsPath)(i.prefix):void 0,this.onWriteEntry=i.onWriteEntry,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let r=!1;if(!this.preservePaths){let[o,a]=(0,wn.stripAbsolutePath)(this.path);o&&typeof a=="string"&&(this.path=a,r=o)}this.win32=!!i.win32||process.platform==="win32",this.win32&&(this.path=lh.decode(this.path.replaceAll(/\\/g,"/")),e=e.replaceAll(/\\/g,"/")),this.absolute=(0,ne.normalizeWindowsPath)(i.absolute||on.default.resolve(this.cwd,e)),this.path===""&&(this.path="./"),r&&this.warn("TAR_ENTRY_INFO",`stripping ${r} from absolute path`,{entry:this,path:r+this.path});let n=this.statCache.get(this.absolute);n?this[Ri](n):this[Vs]()}warn(e,t,i={}){return(0,yn.warnMethod)(this,e,t,i)}emit(e,...t){return e==="error"&&(this.#e=!0),super.emit(e,...t)}[Vs](){oe.default.lstat(this.absolute,(e,t)=>{if(e)return this.emit("error",e);this[Ri](t)})}[Ri](e){this.statCache.set(this.absolute,e),this.stat=e,e.isFile()||(e.size=0),this.type=ch(e),this.emit("stat",e),this[an]()}[an](){switch(this.type){case"File":return this[hn]();case"Directory":return this[ln]();case"SymbolicLink":return this[Ks]();default:return this.end()}}[vi](e){return(0,mn.modeFix)(e,this.type==="Directory",this.portable)}[ae](e){return En(e,this.prefix)}[Rt](){if(!this.stat)throw new Error("cannot write header before stat");this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.onWriteEntry?.(this),this.header=new dn.Header({path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,mode:this[vi](this.stat.mode),uid:this.portable?void 0:this.stat.uid,gid:this.portable?void 0:this.stat.gid,size:this.stat.size,mtime:this.noMtime?void 0:this.mtime||this.stat.mtime,type:this.type==="Unsupported"?void 0:this.type,uname:this.portable?void 0:this.stat.uid===this.myuid?this.myuser:"",atime:this.portable?void 0:this.stat.atime,ctime:this.portable?void 0:this.stat.ctime}),this.header.encode()&&!this.noPax&&super.write(new _n.Pax({atime:this.portable?void 0:this.header.atime,ctime:this.portable?void 0:this.header.ctime,gid:this.portable?void 0:this.header.gid,mtime:this.noMtime?void 0:this.mtime||this.header.mtime,path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,size:this.header.size,uid:this.portable?void 0:this.header.uid,uname:this.portable?void 0:this.header.uname,dev:this.portable?void 0:this.stat.dev,ino:this.portable?void 0:this.stat.ino,nlink:this.portable?void 0:this.stat.nlink}).encode());let e=this.header?.block;if(!e)throw new Error("failed to encode header");super.write(e)}[ln](){if(!this.stat)throw new Error("cannot create directory entry without stat");this.path.slice(-1)!=="/"&&(this.path+="/"),this.stat.size=0,this[Rt](),this.end()}[Ks](){oe.default.readlink(this.absolute,(e,t)=>{if(e)return this.emit("error",e);this[Xs](t)})}[Xs](e){this.linkpath=(0,ne.normalizeWindowsPath)(e),this[Rt](),this.end()}[un](e){if(!this.stat)throw new Error("cannot create link entry without stat");this.type="Link",this.linkpath=(0,ne.normalizeWindowsPath)(on.default.relative(this.cwd,e)),this.stat.size=0,this[Rt](),this.end()}[hn](){if(!this.stat)throw new Error("cannot create file entry without stat");if(this.stat.nlink>1){let e=`${this.stat.dev}:${this.stat.ino}`,t=this.linkCache.get(e);if(t?.indexOf(this.cwd)===0)return this[un](t);this.linkCache.set(e,this.absolute)}if(this[Rt](),this.stat.size===0)return this.end();this[Qs]()}[Qs](){oe.default.open(this.absolute,"r",(e,t)=>{if(e)return this.emit("error",e);this[Js](t)})}[Js](e){if(this.fd=e,this.#e)return this[ve]();if(!this.stat)throw new Error("should stat before calling onopenfile");this.blockLen=512*Math.ceil(this.stat.size/512),this.blockRemain=this.blockLen;let t=Math.min(this.blockLen,this.maxReadSize);this.buf=Buffer.allocUnsafe(t),this.offset=0,this.pos=0,this.remain=this.stat.size,this.length=this.buf.length,this[Oi]()}[Oi](){let{fd:e,buf:t,offset:i,length:r,pos:n}=this;if(e===void 0||t===void 0)throw new Error("cannot read file without first opening");oe.default.read(e,t,i,r,n,(o,a)=>{if(o)return this[ve](()=>this.emit("error",o));this[$s](a)})}[ve](e=()=>{}){this.fd!==void 0&&oe.default.close(this.fd,e)}[$s](e){if(e<=0&&this.remain>0){let r=Object.assign(new Error("encountered unexpected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[ve](()=>this.emit("error",r))}if(e>this.remain){let r=Object.assign(new Error("did not encounter expected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[ve](()=>this.emit("error",r))}if(!this.buf)throw new Error("should have created buffer prior to reading");if(e===this.remain)for(let r=e;r<this.length&&e<this.blockRemain;r++)this.buf[r+this.offset]=0,e++,this.remain++;let t=this.offset===0&&e===this.buf.length?this.buf:this.buf.subarray(this.offset,this.offset+e);this.write(t)?this[Ys]():this[er](()=>this[Ys]())}[er](e){this.once("drain",e)}write(e,t,i){if(typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8")),this.blockRemain<e.length){let r=Object.assign(new Error("writing more data than expected"),{path:this.absolute});return this.emit("error",r)}return this.remain-=e.length,this.blockRemain-=e.length,this.pos+=e.length,this.offset+=e.length,super.write(e,null,i)}[Ys](){if(!this.remain)return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),this[ve](e=>e?this.emit("error",e):this.end());if(!this.buf)throw new Error("buffer lost somehow in ONDRAIN");this.offset>=this.length&&(this.buf=Buffer.allocUnsafe(Math.min(this.blockRemain,this.buf.length)),this.offset=0),this.length=this.buf.length-this.offset,this[Oi]()}};M.WriteEntry=Ti;var tr=class extends Ti{sync=!0;[Vs](){this[Ri](oe.default.lstatSync(this.absolute))}[Ks](){this[Xs](oe.default.readlinkSync(this.absolute))}[Qs](){this[Js](oe.default.openSync(this.absolute,"r"))}[Oi](){let e=!0;try{let{fd:t,buf:i,offset:r,length:n,pos:o}=this;if(t===void 0||i===void 0)throw new Error("fd and buf must be set in READ method");let a=oe.default.readSync(t,i,r,n,o);this[$s](a),e=!1}finally{if(e)try{this[ve](()=>{})}catch{}}}[er](e){e()}[ve](e=()=>{}){this.fd!==void 0&&oe.default.closeSync(this.fd),e()}};M.WriteEntrySync=tr;var ir=class extends fn.Minipass{blockLen=0;blockRemain=0;buf=0;pos=0;remain=0;length=0;preservePaths;portable;strict;noPax;noMtime;readEntry;type;prefix;path;mode;uid;gid;uname;gname;header;mtime;atime;ctime;linkpath;size;onWriteEntry;warn(e,t,i={}){return(0,yn.warnMethod)(this,e,t,i)}constructor(e,t={}){let i=(0,pn.dealias)(t);super(),this.preservePaths=!!i.preservePaths,this.portable=!!i.portable,this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.onWriteEntry=i.onWriteEntry,this.readEntry=e;let{type:r}=e;if(r==="Unsupported")throw new Error("writing entry that should be ignored");this.type=r,this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.prefix=i.prefix,this.path=(0,ne.normalizeWindowsPath)(e.path),this.mode=e.mode!==void 0?this[vi](e.mode):void 0,this.uid=this.portable?void 0:e.uid,this.gid=this.portable?void 0:e.gid,this.uname=this.portable?void 0:e.uname,this.gname=this.portable?void 0:e.gname,this.size=e.size,this.mtime=this.noMtime?void 0:i.mtime||e.mtime,this.atime=this.portable?void 0:e.atime,this.ctime=this.portable?void 0:e.ctime,this.linkpath=e.linkpath!==void 0?(0,ne.normalizeWindowsPath)(e.linkpath):void 0,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let n=!1;if(!this.preservePaths){let[a,h]=(0,wn.stripAbsolutePath)(this.path);a&&typeof h=="string"&&(this.path=h,n=a)}this.remain=e.size,this.blockRemain=e.startBlockSize,this.onWriteEntry?.(this),this.header=new dn.Header({path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,mode:this.mode,uid:this.portable?void 0:this.uid,gid:this.portable?void 0:this.gid,size:this.size,mtime:this.noMtime?void 0:this.mtime,type:this.type,uname:this.portable?void 0:this.uname,atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime}),n&&this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute path`,{entry:this,path:n+this.path}),this.header.encode()&&!this.noPax&&super.write(new _n.Pax({atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime,gid:this.portable?void 0:this.gid,mtime:this.noMtime?void 0:this.mtime,path:this[ae](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[ae](this.linkpath):this.linkpath,size:this.size,uid:this.portable?void 0:this.uid,uname:this.portable?void 0:this.uname,dev:this.portable?void 0:this.readEntry.dev,ino:this.portable?void 0:this.readEntry.ino,nlink:this.portable?void 0:this.readEntry.nlink}).encode());let o=this.header?.block;if(!o)throw new Error("failed to encode header");super.write(o),e.pipe(this)}[ae](e){return En(e,this.prefix)}[vi](e){return(0,mn.modeFix)(e,this.type==="Directory",this.portable)}write(e,t,i){typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,typeof t=="string"?t:"utf8"));let r=e.length;if(r>this.blockRemain)throw new Error("writing more to entry than is appropriate");return this.blockRemain-=r,super.write(e,i)}end(e,t,i){return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),typeof e=="function"&&(i=e,t=void 0,e=void 0),typeof t=="function"&&(i=t,t=void 0),typeof e=="string"&&(e=Buffer.from(e,t??"utf8")),i&&this.once("finish",i),e?super.end(e,i):super.end(i),this}};M.WriteEntryTar=ir;var ch=s=>s.isFile()?"File":s.isDirectory()?"Directory":s.isSymbolicLink()?"SymbolicLink":"Unsupported"});var bn=d(ot=>{"use strict";Object.defineProperty(ot,"__esModule",{value:!0});ot.Node=ot.Yallist=void 0;var rr=class s{tail;head;length=0;static create(e=[]){return new s(e)}constructor(e=[]){for(let t of e)this.push(t)}*[Symbol.iterator](){for(let e=this.head;e;e=e.next)yield e.value}removeNode(e){if(e.list!==this)throw new Error("removing node which does not belong to this list");let t=e.next,i=e.prev;return t&&(t.prev=i),i&&(i.next=t),e===this.head&&(this.head=t),e===this.tail&&(this.tail=i),this.length--,e.next=void 0,e.prev=void 0,e.list=void 0,t}unshiftNode(e){if(e===this.head)return;e.list&&e.list.removeNode(e);let t=this.head;e.list=this,e.next=t,t&&(t.prev=e),this.head=e,this.tail||(this.tail=e),this.length++}pushNode(e){if(e===this.tail)return;e.list&&e.list.removeNode(e);let t=this.tail;e.list=this,e.prev=t,t&&(t.next=e),this.tail=e,this.head||(this.head=e),this.length++}push(...e){for(let t=0,i=e.length;t<i;t++)dh(this,e[t]);return this.length}unshift(...e){for(var t=0,i=e.length;t<i;t++)mh(this,e[t]);return this.length}pop(){if(!this.tail)return;let e=this.tail.value,t=this.tail;return this.tail=this.tail.prev,this.tail?this.tail.next=void 0:this.head=void 0,t.list=void 0,this.length--,e}shift(){if(!this.head)return;let e=this.head.value,t=this.head;return this.head=this.head.next,this.head?this.head.prev=void 0:this.tail=void 0,t.list=void 0,this.length--,e}forEach(e,t){t=t||this;for(let i=this.head,r=0;i;r++)e.call(t,i.value,r,this),i=i.next}forEachReverse(e,t){t=t||this;for(let i=this.tail,r=this.length-1;i;r--)e.call(t,i.value,r,this),i=i.prev}get(e){let t=0,i=this.head;for(;i&&t<e;t++)i=i.next;if(t===e&&i)return i.value}getReverse(e){let t=0,i=this.tail;for(;i&&t<e;t++)i=i.prev;if(t===e&&i)return i.value}map(e,t){t=t||this;let i=new s;for(let r=this.head;r;)i.push(e.call(t,r.value,this)),r=r.next;return i}mapReverse(e,t){t=t||this;var i=new s;for(let r=this.tail;r;)i.push(e.call(t,r.value,this)),r=r.prev;return i}reduce(e,t){let i,r=this.head;if(arguments.length>1)i=t;else if(this.head)r=this.head.next,i=this.head.value;else throw new TypeError("Reduce of empty list with no initial value");for(var n=0;r;n++)i=e(i,r.value,n),r=r.next;return i}reduceReverse(e,t){let i,r=this.tail;if(arguments.length>1)i=t;else if(this.tail)r=this.tail.prev,i=this.tail.value;else throw new TypeError("Reduce of empty list with no initial value");for(let n=this.length-1;r;n--)i=e(i,r.value,n),r=r.prev;return i}toArray(){let e=new Array(this.length);for(let t=0,i=this.head;i;t++)e[t]=i.value,i=i.next;return e}toArrayReverse(){let e=new Array(this.length);for(let t=0,i=this.tail;i;t++)e[t]=i.value,i=i.prev;return e}slice(e=0,t=this.length){t<0&&(t+=this.length),e<0&&(e+=this.length);let i=new s;if(t<e||t<0)return i;e<0&&(e=0),t>this.length&&(t=this.length);let r=this.head,n=0;for(n=0;r&&n<e;n++)r=r.next;for(;r&&n<t;n++,r=r.next)i.push(r.value);return i}sliceReverse(e=0,t=this.length){t<0&&(t+=this.length),e<0&&(e+=this.length);let i=new s;if(t<e||t<0)return i;e<0&&(e=0),t>this.length&&(t=this.length);let r=this.length,n=this.tail;for(;n&&r>t;r--)n=n.prev;for(;n&&r>e;r--,n=n.prev)i.push(n.value);return i}splice(e,t=0,...i){e>this.length&&(e=this.length-1),e<0&&(e=this.length+e);let r=this.head;for(let o=0;r&&o<e;o++)r=r.next;let n=[];for(let o=0;r&&o<t;o++)n.push(r.value),r=this.removeNode(r);r?r!==this.tail&&(r=r.prev):r=this.tail;for(let o of i)r=fh(this,r,o);return n}reverse(){let e=this.head,t=this.tail;for(let i=e;i;i=i.prev){let r=i.prev;i.prev=i.next,i.next=r}return this.head=t,this.tail=e,this}};ot.Yallist=rr;function fh(s,e,t){let i=e,r=e?e.next:s.head,n=new nt(t,i,r,s);return n.next===void 0&&(s.tail=n),n.prev===void 0&&(s.head=n),s.length++,n}function dh(s,e){s.tail=new nt(e,s.tail,void 0,s),s.head||(s.head=s.tail),s.length++}function mh(s,e){s.head=new nt(e,void 0,s.head,s),s.tail||(s.tail=s.head),s.length++}var nt=class{list;next;prev;value;constructor(e,t,i,r){this.list=r,this.value=e,t?(t.next=this,this.prev=t):this.prev=void 0,i?(i.prev=this,this.next=i):this.next=void 0}};ot.Node=nt});var Ci=d(L=>{"use strict";var ph=L&&L.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),_h=L&&L.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),wh=L&&L.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&ph(t,e,i[r]);return _h(t,e),t}})(),vn=L&&L.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(L,"__esModule",{value:!0});L.PackSync=L.Pack=L.PackJob=void 0;var Ii=vn(require("fs")),ur=sr(),Pt=class{path;absolute;entry;stat;readdir;pending=!1;pendingLink=!1;ignore=!1;piped=!1;constructor(e,t){this.path=e||"./",this.absolute=t}};L.PackJob=Pt;var yh=We(),nr=wh(Ps()),Eh=bn(),bh=oi(),Sh=hi(),Sn=Buffer.alloc(1024),Pi=Symbol("onStat"),vt=Symbol("ended"),X=Symbol("queue"),Tt=Symbol("queue"),Te=Symbol("current"),je=Symbol("process"),Dt=Symbol("processing"),Di=Symbol("processJob"),Q=Symbol("jobs"),or=Symbol("jobDone"),Ni=Symbol("addFSEntry"),gn=Symbol("addTarEntry"),cr=Symbol("stat"),fr=Symbol("readdir"),Mi=Symbol("onreaddir"),Li=Symbol("pipe"),On=Symbol("entry"),ar=Symbol("entryOpt"),Ai=Symbol("writeEntryClass"),Tn=Symbol("write"),hr=Symbol("ondrain"),Rn=vn(require("path")),lr=et(),Fi=class extends yh.Minipass{sync=!1;opt;cwd;maxReadSize;preservePaths;strict;noPax;prefix;linkCache;statCache;file;portable;zip;readdirCache;noDirRecurse;follow;noMtime;mtime;filter;jobs;[Ai];onWriteEntry;[X];[Tt]=new Map;[Q]=0;[Dt]=!1;[vt]=!1;constructor(e={}){if(super(),this.opt=e,this.file=e.file||"",this.cwd=e.cwd||process.cwd(),this.maxReadSize=e.maxReadSize,this.preservePaths=!!e.preservePaths,this.strict=!!e.strict,this.noPax=!!e.noPax,this.prefix=(0,lr.normalizeWindowsPath)(e.prefix||""),this.linkCache=e.linkCache||new Map,this.statCache=e.statCache||new Map,this.readdirCache=e.readdirCache||new Map,this.onWriteEntry=e.onWriteEntry,this[Ai]=ur.WriteEntry,typeof e.onwarn=="function"&&this.on("warn",e.onwarn),this.portable=!!e.portable,e.gzip||e.brotli||e.zstd){if((e.gzip?1:0)+(e.brotli?1:0)+(e.zstd?1:0)>1)throw new TypeError("gzip, brotli, zstd are mutually exclusive");if(e.gzip&&(typeof e.gzip!="object"&&(e.gzip={}),this.portable&&(e.gzip.portable=!0),this.zip=new nr.Gzip(e.gzip)),e.brotli&&(typeof e.brotli!="object"&&(e.brotli={}),this.zip=new nr.BrotliCompress(e.brotli)),e.zstd&&(typeof e.zstd!="object"&&(e.zstd={}),this.zip=new nr.ZstdCompress(e.zstd)),!this.zip)throw new Error("impossible");let t=this.zip;t.on("data",i=>super.write(i)),t.on("end",()=>super.end()),t.on("drain",()=>this[hr]()),this.on("resume",()=>t.resume())}else this.on("drain",this[hr]);this.noDirRecurse=!!e.noDirRecurse,this.follow=!!e.follow,this.noMtime=!!e.noMtime,e.mtime&&(this.mtime=e.mtime),this.filter=typeof e.filter=="function"?e.filter:()=>!0,this[X]=new Eh.Yallist,this[Q]=0,this.jobs=Number(e.jobs)||4,this[Dt]=!1,this[vt]=!1}[Tn](e){return super.write(e)}add(e){return this.write(e),this}end(e,t,i){return typeof e=="function"&&(i=e,e=void 0),typeof t=="function"&&(i=t,t=void 0),e&&this.add(e),this[vt]=!0,this[je](),i&&i(),this}write(e){if(this[vt])throw new Error("write after end");return e instanceof bh.ReadEntry?this[gn](e):this[Ni](e),this.flowing}[gn](e){let t=(0,lr.normalizeWindowsPath)(Rn.default.resolve(this.cwd,e.path));if(!this.filter(e.path,e))e.resume();else{let i=new Pt(e.path,t);i.entry=new ur.WriteEntryTar(e,this[ar](i)),i.entry.on("end",()=>this[or](i)),this[Q]+=1,this[X].push(i)}this[je]()}[Ni](e){let t=(0,lr.normalizeWindowsPath)(Rn.default.resolve(this.cwd,e));this[X].push(new Pt(e,t)),this[je]()}[cr](e){e.pending=!0,this[Q]+=1;let t=this.follow?"stat":"lstat";Ii.default[t](e.absolute,(i,r)=>{e.pending=!1,this[Q]-=1,i?this.emit("error",i):this[Pi](e,r)})}[Pi](e,t){if(this.statCache.set(e.absolute,t),e.stat=t,!this.filter(e.path,t))e.ignore=!0;else if(t.isFile()&&t.nlink>1&&!this.linkCache.get(`${t.dev}:${t.ino}`)&&!this.sync)if(e===this[Te])this[Di](e);else{let i=`${t.dev}:${t.ino}`,r=this[Tt].get(i);r?r.push(e):this[Tt].set(i,[e]),e.pendingLink=!0,e.pending=!0}this[je]()}[fr](e){e.pending=!0,this[Q]+=1,Ii.default.readdir(e.absolute,(t,i)=>{if(e.pending=!1,this[Q]-=1,t)return this.emit("error",t);this[Mi](e,i)})}[Mi](e,t){this.readdirCache.set(e.absolute,t),e.readdir=t,this[je]()}[je](){if(!this[Dt]){this[Dt]=!0;for(let e=this[X].head;e&&this[Q]<this.jobs;e=e.next)if(this[Di](e.value),e.value.ignore){let t=e.next;this[X].removeNode(e),e.next=t}this[Dt]=!1,this[vt]&&this[X].length===0&&this[Q]===0&&(this.zip?this.zip.end(Sn):(super.write(Sn),super.end()))}}get[Te](){return this[X]&&this[X].head&&this[X].head.value}[or](e){this[X].shift(),this[Q]-=1;let{stat:t}=e;if(t&&t.isFile()&&t.nlink>1){let i=`${t.dev}:${t.ino}`,r=this[Tt].get(i);if(r){this[Tt].delete(i);for(let n of r)n.pending=!1,this[Di](n)}}this[je]()}[Di](e){if(e.pending&&e.pendingLink&&e===this[Te]&&(e.pending=!1,e.pendingLink=!1),!e.pending){if(e.entry){e===this[Te]&&!e.piped&&this[Li](e);return}if(!e.stat){let t=this.statCache.get(e.absolute);t?this[Pi](e,t):this[cr](e)}if(e.stat&&!e.ignore){if(!this.noDirRecurse&&e.stat.isDirectory()&&!e.readdir){let t=this.readdirCache.get(e.absolute);if(t?this[Mi](e,t):this[fr](e),!e.readdir)return}if(e.entry=this[On](e),!e.entry){e.ignore=!0;return}e===this[Te]&&!e.piped&&this[Li](e)}}}[ar](e){return{onwarn:(t,i,r)=>this.warn(t,i,r),noPax:this.noPax,cwd:this.cwd,absolute:e.absolute,preservePaths:this.preservePaths,maxReadSize:this.maxReadSize,strict:this.strict,portable:this.portable,linkCache:this.linkCache,statCache:this.statCache,noMtime:this.noMtime,mtime:this.mtime,prefix:this.prefix,onWriteEntry:this.onWriteEntry}}[On](e){this[Q]+=1;try{return new this[Ai](e.path,this[ar](e)).on("end",()=>this[or](e)).on("error",i=>this.emit("error",i))}catch(t){this.emit("error",t)}}[hr](){this[Te]&&this[Te].entry&&this[Te].entry.resume()}[Li](e){e.piped=!0,e.readdir&&e.readdir.forEach(r=>{let n=e.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[Ni](o+r)});let t=e.entry,i=this.zip;if(!t)throw new Error("cannot pipe without source");i?t.on("data",r=>{i.write(r)||t.pause()}):t.on("data",r=>{super.write(r)||t.pause()})}pause(){return this.zip&&this.zip.pause(),super.pause()}warn(e,t,i={}){(0,Sh.warnMethod)(this,e,t,i)}};L.Pack=Fi;var dr=class extends Fi{sync=!0;constructor(e){super(e),this[Ai]=ur.WriteEntrySync}pause(){}resume(){}[cr](e){let t=this.follow?"statSync":"lstatSync";this[Pi](e,Ii.default[t](e.absolute))}[fr](e){this[Mi](e,Ii.default.readdirSync(e.absolute))}[Li](e){let t=e.entry,i=this.zip;if(e.readdir&&e.readdir.forEach(r=>{let n=e.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[Ni](o+r)}),!t)throw new Error("Cannot pipe without source");i?t.on("data",r=>{i.write(r)}):t.on("data",r=>{super[Tn](r)})}};L.PackSync=dr});var mr=d(at=>{"use strict";var gh=at&&at.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(at,"__esModule",{value:!0});at.create=void 0;var Dn=Ke(),Pn=gh(require("node:path")),Nn=st(),Oh=Ve(),Bi=Ci(),Rh=(s,e)=>{let t=new Bi.PackSync(s),i=new Dn.WriteStreamSync(s.file,{mode:s.mode||438});t.pipe(i),Mn(t,e)},vh=(s,e)=>{let t=new Bi.Pack(s),i=new Dn.WriteStream(s.file,{mode:s.mode||438});t.pipe(i);let r=new Promise((n,o)=>{i.on("error",o),i.on("close",n),t.on("error",o)});return Ln(t,e).catch(n=>t.emit("error",n)),r},Mn=(s,e)=>{e.forEach(t=>{t.charAt(0)==="@"?(0,Nn.list)({file:Pn.default.resolve(s.cwd,t.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t)}),s.end()},Ln=async(s,e)=>{for(let t of e)t.charAt(0)==="@"?await(0,Nn.list)({file:Pn.default.resolve(String(s.cwd),t.slice(1)),noResume:!0,onReadEntry:i=>{s.add(i)}}):s.add(t);s.end()},Th=(s,e)=>{let t=new Bi.PackSync(s);return Mn(t,e),t},Dh=(s,e)=>{let t=new Bi.Pack(s);return Ln(t,e).catch(i=>t.emit("error",i)),t};at.create=(0,Oh.makeCommand)(Rh,vh,Th,Dh,(s,e)=>{if(!e?.length)throw new TypeError("no paths specified to add to archive")})});var jn=d(ht=>{"use strict";var Ph=ht&&ht.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(ht,"__esModule",{value:!0});ht.getWriteFlag=void 0;var Fn=Ph(require("fs")),Nh=process.env.__FAKE_PLATFORM__||process.platform,Cn=Nh==="win32",{O_CREAT:Bn,O_NOFOLLOW:An,O_TRUNC:zn,O_WRONLY:kn}=Fn.default.constants,xn=Number(process.env.__FAKE_FS_O_FILENAME__)||Fn.default.constants.UV_FS_O_FILEMAP||0,Mh=Cn&&!!xn,Lh=512*1024,Ah=xn|zn|Bn|kn,In=!Cn&&typeof An=="number"?An|zn|Bn|kn:null;ht.getWriteFlag=In!==null?()=>In:Mh?s=>s<Lh?Ah:"w":()=>"w"});var qn=d(he=>{"use strict";var Un=he&&he.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(he,"__esModule",{value:!0});he.chownrSync=he.chownr=void 0;var ki=Un(require("node:fs")),Nt=Un(require("node:path")),pr=(s,e,t)=>{try{return ki.default.lchownSync(s,e,t)}catch(i){if(i?.code!=="ENOENT")throw i}},zi=(s,e,t,i)=>{ki.default.lchown(s,e,t,r=>{i(r&&r?.code!=="ENOENT"?r:null)})},Ih=(s,e,t,i,r)=>{if(e.isDirectory())(0,he.chownr)(Nt.default.resolve(s,e.name),t,i,n=>{if(n)return r(n);let o=Nt.default.resolve(s,e.name);zi(o,t,i,r)});else{let n=Nt.default.resolve(s,e.name);zi(n,t,i,r)}},Fh=(s,e,t,i)=>{ki.default.readdir(s,{withFileTypes:!0},(r,n)=>{if(r){if(r.code==="ENOENT")return i();if(r.code!=="ENOTDIR"&&r.code!=="ENOTSUP")return i(r)}if(r||!n.length)return zi(s,e,t,i);let o=n.length,a=null,h=l=>{if(!a){if(l)return i(a=l);if(--o===0)return zi(s,e,t,i)}};for(let l of n)Ih(s,l,e,t,h)})};he.chownr=Fh;var Ch=(s,e,t,i)=>{e.isDirectory()&&(0,he.chownrSync)(Nt.default.resolve(s,e.name),t,i),pr(Nt.default.resolve(s,e.name),t,i)},Bh=(s,e,t)=>{let i;try{i=ki.default.readdirSync(s,{withFileTypes:!0})}catch(r){let n=r;if(n?.code==="ENOENT")return;if(n?.code==="ENOTDIR"||n?.code==="ENOTSUP")return pr(s,e,t);throw n}for(let r of i)Ch(s,r,e,t);return pr(s,e,t)};he.chownrSync=Bh});var Wn=d(xi=>{"use strict";Object.defineProperty(xi,"__esModule",{value:!0});xi.CwdError=void 0;var _r=class extends Error{path;code;syscall="chdir";constructor(e,t){super(`${t}: Cannot cd into '${e}'`),this.path=e,this.code=t}get name(){return"CwdError"}};xi.CwdError=_r});var yr=d(ji=>{"use strict";Object.defineProperty(ji,"__esModule",{value:!0});ji.SymlinkError=void 0;var wr=class extends Error{path;symlink;syscall="symlink";code="TAR_SYMLINK_ERROR";constructor(e,t){super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"),this.symlink=e,this.path=t}get name(){return"SymlinkError"}};ji.SymlinkError=wr});var Kn=d(De=>{"use strict";var br=De&&De.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(De,"__esModule",{value:!0});De.mkdirSync=De.mkdir=void 0;var Hn=qn(),j=br(require("node:fs")),zh=br(require("node:fs/promises")),Ui=br(require("node:path")),Zn=Wn(),pe=et(),Gn=yr(),kh=(s,e)=>{j.default.stat(s,(t,i)=>{(t||!i.isDirectory())&&(t=new Zn.CwdError(s,t?.code||"ENOTDIR")),e(t)})},xh=(s,e,t)=>{s=(0,pe.normalizeWindowsPath)(s);let i=e.umask??18,r=e.mode|448,n=(r&i)!==0,o=e.uid,a=e.gid,h=typeof o=="number"&&typeof a=="number"&&(o!==e.processUid||a!==e.processGid),l=e.preserve,u=e.unlink,c=(0,pe.normalizeWindowsPath)(e.cwd),E=(w,P)=>{w?t(w):P&&h?(0,Hn.chownr)(P,o,a,kt=>E(kt)):n?j.default.chmod(s,r,t):t()};if(s===c)return kh(s,E);if(l)return zh.default.mkdir(s,{mode:r,recursive:!0}).then(w=>E(null,w??void 0),E);let A=(0,pe.normalizeWindowsPath)(Ui.default.relative(c,s)).split("/");Er(c,A,r,u,c,void 0,E)};De.mkdir=xh;var Er=(s,e,t,i,r,n,o)=>{if(e.length===0)return o(null,n);let a=e.shift(),h=(0,pe.normalizeWindowsPath)(Ui.default.resolve(s+"/"+a));j.default.mkdir(h,t,Yn(h,e,t,i,r,n,o))},Yn=(s,e,t,i,r,n,o)=>a=>{a?j.default.lstat(s,(h,l)=>{if(h)h.path=h.path&&(0,pe.normalizeWindowsPath)(h.path),o(h);else if(l.isDirectory())Er(s,e,t,i,r,n,o);else if(i)j.default.unlink(s,u=>{if(u)return o(u);j.default.mkdir(s,t,Yn(s,e,t,i,r,n,o))});else{if(l.isSymbolicLink())return o(new Gn.SymlinkError(s,s+"/"+e.join("/")));o(a)}}):(n=n||s,Er(s,e,t,i,r,n,o))},jh=s=>{let e=!1,t;try{e=j.default.statSync(s).isDirectory()}catch(i){t=i?.code}finally{if(!e)throw new Zn.CwdError(s,t??"ENOTDIR")}},Uh=(s,e)=>{s=(0,pe.normalizeWindowsPath)(s);let t=e.umask??18,i=e.mode|448,r=(i&t)!==0,n=e.uid,o=e.gid,a=typeof n=="number"&&typeof o=="number"&&(n!==e.processUid||o!==e.processGid),h=e.preserve,l=e.unlink,u=(0,pe.normalizeWindowsPath)(e.cwd),c=w=>{w&&a&&(0,Hn.chownrSync)(w,n,o),r&&j.default.chmodSync(s,i)};if(s===u)return jh(u),c();if(h)return c(j.default.mkdirSync(s,{mode:i,recursive:!0})??void 0);let D=(0,pe.normalizeWindowsPath)(Ui.default.relative(u,s)).split("/"),A;for(let w=D.shift(),P=u;w&&(P+="/"+w);w=D.shift()){P=(0,pe.normalizeWindowsPath)(Ui.default.resolve(P));try{j.default.mkdirSync(P,i),A=A||P}catch{let kt=j.default.lstatSync(P);if(kt.isDirectory())continue;if(l){j.default.unlinkSync(P),j.default.mkdirSync(P,i),A=A||P;continue}else if(kt.isSymbolicLink())return new Gn.SymlinkError(P,P+"/"+D.join("/"))}}return c(A)};De.mkdirSync=Uh});var $n=d(qi=>{"use strict";Object.defineProperty(qi,"__esModule",{value:!0});qi.normalizeUnicode=void 0;var Sr=Object.create(null),Vn=1e4,lt=new Set,qh=s=>{lt.has(s)?lt.delete(s):Sr[s]=s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"),lt.add(s);let e=Sr[s],t=lt.size-Vn;if(t>Vn/10){for(let i of lt)if(lt.delete(i),delete Sr[i],--t<=0)break}return e};qi.normalizeUnicode=qh});var Qn=d(Wi=>{"use strict";Object.defineProperty(Wi,"__esModule",{value:!0});Wi.PathReservations=void 0;var Xn=require("node:path"),Wh=$n(),Hh=yi(),Zh=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Gh=Zh==="win32",Yh=s=>s.split("/").slice(0,-1).reduce((t,i)=>{let r=t.at(-1);return r!==void 0&&(i=(0,Xn.join)(r,i)),t.push(i||"/"),t},[]),gr=class{#e=new Map;#i=new Map;#s=new Set;reserve(e,t){e=Gh?["win32 parallelization disabled"]:e.map(r=>(0,Hh.stripTrailingSlashes)((0,Xn.join)((0,Wh.normalizeUnicode)(r))));let i=new Set(e.map(r=>Yh(r)).reduce((r,n)=>r.concat(n)));this.#i.set(t,{dirs:i,paths:e});for(let r of e){let n=this.#e.get(r);n?n.push(t):this.#e.set(r,[t])}for(let r of i){let n=this.#e.get(r);if(!n)this.#e.set(r,[new Set([t])]);else{let o=n.at(-1);o instanceof Set?o.add(t):n.push(new Set([t]))}}return this.#r(t)}#n(e){let t=this.#i.get(e);if(!t)throw new Error("function does not have any path reservations");return{paths:t.paths.map(i=>this.#e.get(i)),dirs:[...t.dirs].map(i=>this.#e.get(i))}}check(e){let{paths:t,dirs:i}=this.#n(e);return t.every(r=>r&&r[0]===e)&&i.every(r=>r&&r[0]instanceof Set&&r[0].has(e))}#r(e){return this.#s.has(e)||!this.check(e)?!1:(this.#s.add(e),e(()=>this.#t(e)),!0)}#t(e){if(!this.#s.has(e))return!1;let t=this.#i.get(e);if(!t)throw new Error("invalid reservation");let{paths:i,dirs:r}=t,n=new Set;for(let o of i){let a=this.#e.get(o);if(!a||a?.[0]!==e)continue;let h=a[1];if(!h){this.#e.delete(o);continue}if(a.shift(),typeof h=="function")n.add(h);else for(let l of h)n.add(l)}for(let o of r){let a=this.#e.get(o),h=a?.[0];if(!(!a||!(h instanceof Set)))if(h.size===1&&a.length===1){this.#e.delete(o);continue}else if(h.size===1){a.shift();let l=a[0];typeof l=="function"&&n.add(l)}else h.delete(e)}return this.#s.delete(e),n.forEach(o=>this.#r(o)),!0}};Wi.PathReservations=gr});var Jn=d(Hi=>{"use strict";Object.defineProperty(Hi,"__esModule",{value:!0});Hi.umask=void 0;var Kh=()=>process.umask();Hi.umask=Kh});var Ir=d(z=>{"use strict";var Vh=z&&z.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),$h=z&&z.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),lo=z&&z.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Vh(t,e,i[r]);return $h(t,e),t}})(),Ar=z&&z.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(z,"__esModule",{value:!0});z.UnpackSync=z.Unpack=void 0;var Xh=lo(Ke()),Qh=Ar(require("node:assert")),uo=require("node:crypto"),m=Ar(require("node:fs")),g=Ar(require("node:path")),co=jn(),fo=Kn(),U=et(),Jh=_i(),el=Hs(),eo=lo(Gs()),tl=Qn(),mo=yr(),il=Jn(),to=Symbol("onEntry"),Tr=Symbol("checkFs"),io=Symbol("checkFs2"),Dr=Symbol("isReusable"),Z=Symbol("makeFs"),Pr=Symbol("file"),Nr=Symbol("directory"),Gi=Symbol("link"),so=Symbol("symlink"),ro=Symbol("hardlink"),Lt=Symbol("ensureNoSymlink"),no=Symbol("unsupported"),oo=Symbol("checkPath"),Or=Symbol("stripAbsolutePath"),Pe=Symbol("mkdir"),T=Symbol("onError"),Zi=Symbol("pending"),ao=Symbol("pend"),ut=Symbol("unpend"),Rr=Symbol("ended"),vr=Symbol("maybeClose"),Mr=Symbol("skip"),At=Symbol("doChown"),It=Symbol("uid"),Ft=Symbol("gid"),Ct=Symbol("checkedCwd"),sl=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Bt=sl==="win32",rl=1024,nl=(s,e)=>{if(!Bt)return m.default.unlink(s,e);let t=s+".DELETE."+(0,uo.randomBytes)(16).toString("hex");m.default.rename(s,t,i=>{if(i)return e(i);m.default.unlink(t,e)})},ol=s=>{if(!Bt)return m.default.unlinkSync(s);let e=s+".DELETE."+(0,uo.randomBytes)(16).toString("hex");m.default.renameSync(s,e),m.default.unlinkSync(e)},ho=(s,e,t)=>s!==void 0&&s===s>>>0?s:e!==void 0&&e===e>>>0?e:t,Yi=class extends Jh.Parser{[Rr]=!1;[Ct]=!1;[Zi]=0;reservations=new tl.PathReservations;transform;writable=!0;readable=!1;uid;gid;setOwner;preserveOwner;processGid;processUid;maxDepth;forceChown;win32;newer;keep;noMtime;preservePaths;unlink;cwd;strip;processUmask;umask;dmode;fmode;chmod;constructor(e={}){if(e.ondone=()=>{this[Rr]=!0,this[vr]()},super(e),this.transform=e.transform,this.chmod=!!e.chmod,typeof e.uid=="number"||typeof e.gid=="number"){if(typeof e.uid!="number"||typeof e.gid!="number")throw new TypeError("cannot set owner without number uid and gid");if(e.preserveOwner)throw new TypeError("cannot preserve owner in archive and also set owner explicitly");this.uid=e.uid,this.gid=e.gid,this.setOwner=!0}else this.uid=void 0,this.gid=void 0,this.setOwner=!1;this.preserveOwner=e.preserveOwner===void 0&&typeof e.uid!="number"?!!(process.getuid&&process.getuid()===0):!!e.preserveOwner,this.processUid=(this.preserveOwner||this.setOwner)&&process.getuid?process.getuid():void 0,this.processGid=(this.preserveOwner||this.setOwner)&&process.getgid?process.getgid():void 0,this.maxDepth=typeof e.maxDepth=="number"?e.maxDepth:rl,this.forceChown=e.forceChown===!0,this.win32=!!e.win32||Bt,this.newer=!!e.newer,this.keep=!!e.keep,this.noMtime=!!e.noMtime,this.preservePaths=!!e.preservePaths,this.unlink=!!e.unlink,this.cwd=(0,U.normalizeWindowsPath)(g.default.resolve(e.cwd||process.cwd())),this.strip=Number(e.strip)||0,this.processUmask=this.chmod?typeof e.processUmask=="number"?e.processUmask:(0,il.umask)():0,this.umask=typeof e.umask=="number"?e.umask:this.processUmask,this.dmode=e.dmode||511&~this.umask,this.fmode=e.fmode||438&~this.umask,this.on("entry",t=>this[to](t))}warn(e,t,i={}){return(e==="TAR_BAD_ARCHIVE"||e==="TAR_ABORT")&&(i.recoverable=!1),super.warn(e,t,i)}[vr](){this[Rr]&&this[Zi]===0&&(this.emit("prefinish"),this.emit("finish"),this.emit("end"))}[Or](e,t){let i=e[t],{type:r}=e;if(!i||this.preservePaths)return!0;let[n,o]=(0,el.stripAbsolutePath)(i),a=o.replaceAll(/\\/g,"/").split("/");if(a.includes("..")||Bt&&/^[a-z]:\.\.$/i.test(a[0]??"")){if(t==="path"||r==="Link")return this.warn("TAR_ENTRY_ERROR",`${t} contains '..'`,{entry:e,[t]:i}),!1;let h=g.default.posix.dirname(e.path),l=g.default.posix.normalize(g.default.posix.join(h,a.join("/")));if(l.startsWith("../")||l==="..")return this.warn("TAR_ENTRY_ERROR",`${t} escapes extraction directory`,{entry:e,[t]:i}),!1}return n&&(e[t]=String(o),this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute ${t}`,{entry:e,[t]:i})),!0}[oo](e){let t=(0,U.normalizeWindowsPath)(e.path),i=t.split("/");if(this.strip){if(i.length<this.strip)return!1;if(e.type==="Link"){let r=(0,U.normalizeWindowsPath)(String(e.linkpath)).split("/");if(r.length>=this.strip)e.linkpath=r.slice(this.strip).join("/");else return!1}i.splice(0,this.strip),e.path=i.join("/")}if(isFinite(this.maxDepth)&&i.length>this.maxDepth)return this.warn("TAR_ENTRY_ERROR","path excessively deep",{entry:e,path:t,depth:i.length,maxDepth:this.maxDepth}),!1;if(!this[Or](e,"path")||!this[Or](e,"linkpath"))return!1;if(e.absolute=g.default.isAbsolute(e.path)?(0,U.normalizeWindowsPath)(g.default.resolve(e.path)):(0,U.normalizeWindowsPath)(g.default.resolve(this.cwd,e.path)),!this.preservePaths&&typeof e.absolute=="string"&&e.absolute.indexOf(this.cwd+"/")!==0&&e.absolute!==this.cwd)return this.warn("TAR_ENTRY_ERROR","path escaped extraction target",{entry:e,path:(0,U.normalizeWindowsPath)(e.path),resolvedPath:e.absolute,cwd:this.cwd}),!1;if(e.absolute===this.cwd&&e.type!=="Directory"&&e.type!=="GNUDumpDir")return!1;if(this.win32){let{root:r}=g.default.win32.parse(String(e.absolute));e.absolute=r+eo.encode(String(e.absolute).slice(r.length));let{root:n}=g.default.win32.parse(e.path);e.path=n+eo.encode(e.path.slice(n.length))}return!0}[to](e){if(!this[oo](e))return e.resume();switch(Qh.default.equal(typeof e.absolute,"string"),e.type){case"Directory":case"GNUDumpDir":e.mode&&(e.mode=e.mode|448);case"File":case"OldFile":case"ContiguousFile":case"Link":case"SymbolicLink":return this[Tr](e);default:return this[no](e)}}[T](e,t){e.name==="CwdError"?this.emit("error",e):(this.warn("TAR_ENTRY_ERROR",e,{entry:t}),this[ut](),t.resume())}[Pe](e,t,i){(0,fo.mkdir)((0,U.normalizeWindowsPath)(e),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:t},i)}[At](e){return this.forceChown||this.preserveOwner&&(typeof e.uid=="number"&&e.uid!==this.processUid||typeof e.gid=="number"&&e.gid!==this.processGid)||typeof this.uid=="number"&&this.uid!==this.processUid||typeof this.gid=="number"&&this.gid!==this.processGid}[It](e){return ho(this.uid,e.uid,this.processUid)}[Ft](e){return ho(this.gid,e.gid,this.processGid)}[Pr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.fmode,r=new Xh.WriteStream(String(e.absolute),{flags:(0,co.getWriteFlag)(e.size),mode:i,autoClose:!1});r.on("error",h=>{r.fd&&m.default.close(r.fd,()=>{}),r.write=()=>!0,this[T](h,e),t()});let n=1,o=h=>{if(h){r.fd&&m.default.close(r.fd,()=>{}),this[T](h,e),t();return}--n===0&&r.fd!==void 0&&m.default.close(r.fd,l=>{l?this[T](l,e):this[ut](),t()})};r.on("finish",()=>{let h=String(e.absolute),l=r.fd;if(typeof l=="number"&&e.mtime&&!this.noMtime){n++;let u=e.atime||new Date,c=e.mtime;m.default.futimes(l,u,c,E=>E?m.default.utimes(h,u,c,D=>o(D&&E)):o())}if(typeof l=="number"&&this[At](e)){n++;let u=this[It](e),c=this[Ft](e);typeof u=="number"&&typeof c=="number"&&m.default.fchown(l,u,c,E=>E?m.default.chown(h,u,c,D=>o(D&&E)):o())}o()});let a=this.transform&&this.transform(e)||e;a!==e&&(a.on("error",h=>{this[T](h,e),t()}),e.pipe(a)),a.pipe(r)}[Nr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.dmode;this[Pe](String(e.absolute),i,r=>{if(r){this[T](r,e),t();return}let n=1,o=()=>{--n===0&&(t(),this[ut](),e.resume())};e.mtime&&!this.noMtime&&(n++,m.default.utimes(String(e.absolute),e.atime||new Date,e.mtime,o)),this[At](e)&&(n++,m.default.chown(String(e.absolute),Number(this[It](e)),Number(this[Ft](e)),o)),o()})}[no](e){e.unsupported=!0,this.warn("TAR_ENTRY_UNSUPPORTED",`unsupported entry type: ${e.type}`,{entry:e}),e.resume()}[so](e,t){let i=(0,U.normalizeWindowsPath)(g.default.relative(this.cwd,g.default.resolve(g.default.dirname(String(e.absolute)),String(e.linkpath)))).split("/");this[Lt](e,this.cwd,i,()=>this[Gi](e,String(e.linkpath),"symlink",t),r=>{this[T](r,e),t()})}[ro](e,t){let i=(0,U.normalizeWindowsPath)(g.default.resolve(this.cwd,String(e.linkpath))),r=(0,U.normalizeWindowsPath)(String(e.linkpath)).split("/");this[Lt](e,this.cwd,r,()=>this[Gi](e,i,"link",t),n=>{this[T](n,e),t()})}[Lt](e,t,i,r,n){let o=i.shift();if(this.preservePaths||o===void 0)return r();let a=g.default.resolve(t,o);m.default.lstat(a,(h,l)=>{if(h)return r();if(l?.isSymbolicLink())return n(new mo.SymlinkError(a,g.default.resolve(a,i.join("/"))));this[Lt](e,a,i,r,n)})}[ao](){this[Zi]++}[ut](){this[Zi]--,this[vr]()}[Mr](e){this[ut](),e.resume()}[Dr](e,t){return e.type==="File"&&!this.unlink&&t.isFile()&&t.nlink<=1&&!Bt}[Tr](e){this[ao]();let t=[e.path];e.linkpath&&t.push(e.linkpath),this.reservations.reserve(t,i=>this[io](e,i))}[io](e,t){let i=a=>{t(a)},r=()=>{this[Pe](this.cwd,this.dmode,a=>{if(a){this[T](a,e),i();return}this[Ct]=!0,n()})},n=()=>{if(e.absolute!==this.cwd){let a=(0,U.normalizeWindowsPath)(g.default.dirname(String(e.absolute)));if(a!==this.cwd)return this[Pe](a,this.dmode,h=>{if(h){this[T](h,e),i();return}o()})}o()},o=()=>{m.default.lstat(String(e.absolute),(a,h)=>{if(h&&(this.keep||this.newer&&h.mtime>(e.mtime??h.mtime))){this[Mr](e),i();return}if(a||this[Dr](e,h))return this[Z](null,e,i);if(h.isDirectory()){if(e.type==="Directory"){let l=this.chmod&&e.mode&&(h.mode&4095)!==e.mode,u=c=>this[Z](c??null,e,i);return l?m.default.chmod(String(e.absolute),Number(e.mode),u):u()}if(e.absolute!==this.cwd)return m.default.rmdir(String(e.absolute),l=>this[Z](l??null,e,i))}if(e.absolute===this.cwd)return this[Z](null,e,i);nl(String(e.absolute),l=>this[Z](l??null,e,i))})};this[Ct]?n():r()}[Z](e,t,i){if(e){this[T](e,t),i();return}switch(t.type){case"File":case"OldFile":case"ContiguousFile":return this[Pr](t,i);case"Link":return this[ro](t,i);case"SymbolicLink":return this[so](t,i);case"Directory":case"GNUDumpDir":return this[Nr](t,i)}}[Gi](e,t,i,r){m.default[i](t,String(e.absolute),n=>{n?this[T](n,e):(this[ut](),e.resume()),r()})}};z.Unpack=Yi;var Mt=s=>{try{return[null,s()]}catch(e){return[e,null]}},Lr=class extends Yi{sync=!0;[Z](e,t){return super[Z](e,t,()=>{})}[Tr](e){if(!this[Ct]){let n=this[Pe](this.cwd,this.dmode);if(n)return this[T](n,e);this[Ct]=!0}if(e.absolute!==this.cwd){let n=(0,U.normalizeWindowsPath)(g.default.dirname(String(e.absolute)));if(n!==this.cwd){let o=this[Pe](n,this.dmode);if(o)return this[T](o,e)}}let[t,i]=Mt(()=>m.default.lstatSync(String(e.absolute)));if(i&&(this.keep||this.newer&&i.mtime>(e.mtime??i.mtime)))return this[Mr](e);if(t||this[Dr](e,i))return this[Z](null,e);if(i.isDirectory()){if(e.type==="Directory"){let o=this.chmod&&e.mode&&(i.mode&4095)!==e.mode,[a]=o?Mt(()=>{m.default.chmodSync(String(e.absolute),Number(e.mode))}):[];return this[Z](a,e)}let[n]=Mt(()=>m.default.rmdirSync(String(e.absolute)));this[Z](n,e)}let[r]=e.absolute===this.cwd?[]:Mt(()=>ol(String(e.absolute)));this[Z](r,e)}[Pr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.fmode,r=a=>{let h;try{m.default.closeSync(n)}catch(l){h=l}(a||h)&&this[T](a||h,e),t()},n;try{n=m.default.openSync(String(e.absolute),(0,co.getWriteFlag)(e.size),i)}catch(a){return r(a)}let o=this.transform&&this.transform(e)||e;o!==e&&(o.on("error",a=>this[T](a,e)),e.pipe(o)),o.on("data",a=>{try{m.default.writeSync(n,a,0,a.length)}catch(h){r(h)}}),o.on("end",()=>{let a=null;if(e.mtime&&!this.noMtime){let h=e.atime||new Date,l=e.mtime;try{m.default.futimesSync(n,h,l)}catch(u){try{m.default.utimesSync(String(e.absolute),h,l)}catch{a=u}}}if(this[At](e)){let h=this[It](e),l=this[Ft](e);try{m.default.fchownSync(n,Number(h),Number(l))}catch(u){try{m.default.chownSync(String(e.absolute),Number(h),Number(l))}catch{a=a||u}}}r(a)})}[Nr](e,t){let i=typeof e.mode=="number"?e.mode&4095:this.dmode,r=this[Pe](String(e.absolute),i);if(r){this[T](r,e),t();return}if(e.mtime&&!this.noMtime)try{m.default.utimesSync(String(e.absolute),e.atime||new Date,e.mtime)}catch{}if(this[At](e))try{m.default.chownSync(String(e.absolute),Number(this[It](e)),Number(this[Ft](e)))}catch{}t(),e.resume()}[Pe](e,t){try{return(0,fo.mkdirSync)((0,U.normalizeWindowsPath)(e),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:t})}catch(i){return i}}[Lt](e,t,i,r,n){if(this.preservePaths||i.length===0)return r();let o=t;for(let a of i){o=g.default.resolve(o,a);let[h,l]=Mt(()=>m.default.lstatSync(o));if(h)return r();if(l.isSymbolicLink())return n(new mo.SymlinkError(o,g.default.resolve(t,i.join("/"))))}r()}[Gi](e,t,i,r){let n=`${i}Sync`;try{m.default[n](t,String(e.absolute)),r(),e.resume()}catch(o){return this[T](o,e)}}};z.UnpackSync=Lr});var Fr=d(G=>{"use strict";var al=G&&G.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),hl=G&&G.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),ll=G&&G.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&al(t,e,i[r]);return hl(t,e),t}})(),ul=G&&G.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(G,"__esModule",{value:!0});G.extract=void 0;var po=ll(Ke()),_o=ul(require("node:fs")),cl=st(),fl=Ve(),Ki=Ir(),dl=s=>{let e=new Ki.UnpackSync(s),t=s.file,i=_o.default.statSync(t),r=s.maxReadSize||16*1024*1024;new po.ReadStreamSync(t,{readSize:r,size:i.size}).pipe(e)},ml=(s,e)=>{let t=new Ki.Unpack(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,a)=>{t.on("error",a),t.on("close",o),_o.default.stat(r,(h,l)=>{if(h)a(h);else{let u=new po.ReadStream(r,{readSize:i,size:l.size});u.on("error",a),u.pipe(t)}})})};G.extract=(0,fl.makeCommand)(dl,ml,s=>new Ki.UnpackSync(s),s=>new Ki.Unpack(s),(s,e)=>{e?.length&&(0,cl.filesFilter)(s,e)})});var Vi=d(ct=>{"use strict";var wo=ct&&ct.__importDefault||function(s){return s&&s.__esModule?s:{default:s}};Object.defineProperty(ct,"__esModule",{value:!0});ct.replace=void 0;var yo=Ke(),q=wo(require("node:fs")),Eo=wo(require("node:path")),bo=Je(),So=st(),pl=Ve(),_l=Xt(),go=Ci(),wl=(s,e)=>{let t=new go.PackSync(s),i=!0,r,n;try{try{r=q.default.openSync(s.file,"r+")}catch(h){if(h?.code==="ENOENT")r=q.default.openSync(s.file,"w+");else throw h}let o=q.default.fstatSync(r),a=Buffer.alloc(512);e:for(n=0;n<o.size;n+=512){for(let u=0,c=0;u<512;u+=c){if(c=q.default.readSync(r,a,u,a.length-u,n+u),n===0&&a[0]===31&&a[1]===139)throw new Error("cannot append to compressed archives");if(!c)break e}let h=new bo.Header(a);if(!h.cksumValid)break;let l=512*Math.ceil((h.size||0)/512);if(n+l+512>o.size)break;n+=l,s.mtimeCache&&h.mtime&&s.mtimeCache.set(String(h.path),h.mtime)}i=!1,yl(s,t,n,r,e)}finally{if(i)try{q.default.closeSync(r)}catch{}}},yl=(s,e,t,i,r)=>{let n=new yo.WriteStreamSync(s.file,{fd:i,start:t});e.pipe(n),bl(e,r)},El=(s,e)=>{e=Array.from(e);let t=new go.Pack(s),i=(n,o,a)=>{let h=(D,A)=>{D?q.default.close(n,w=>a(D)):a(null,A)},l=0;if(o===0)return h(null,0);let u=0,c=Buffer.alloc(512),E=(D,A)=>{if(D||A===void 0)return h(D);if(u+=A,u<512&&A)return q.default.read(n,c,u,c.length-u,l+u,E);if(l===0&&c[0]===31&&c[1]===139)return h(new Error("cannot append to compressed archives"));if(u<512)return h(null,l);let w=new bo.Header(c);if(!w.cksumValid)return h(null,l);let P=512*Math.ceil((w.size??0)/512);if(l+P+512>o||(l+=P+512,l>=o))return h(null,l);s.mtimeCache&&w.mtime&&s.mtimeCache.set(String(w.path),w.mtime),u=0,q.default.read(n,c,0,512,l,E)};q.default.read(n,c,0,512,l,E)};return new Promise((n,o)=>{t.on("error",o);let a="r+",h=(l,u)=>{if(l&&l.code==="ENOENT"&&a==="r+")return a="w+",q.default.open(s.file,a,h);if(l||!u)return o(l);q.default.fstat(u,(c,E)=>{if(c)return q.default.close(u,()=>o(c));i(u,E.size,(D,A)=>{if(D)return o(D);let w=new yo.WriteStream(s.file,{fd:u,start:A});t.pipe(w),w.on("error",o),w.on("close",n),Sl(t,e)})})};q.default.open(s.file,a,h)})},bl=(s,e)=>{e.forEach(t=>{t.charAt(0)==="@"?(0,So.list)({file:Eo.default.resolve(s.cwd,t.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t)}),s.end()},Sl=async(s,e)=>{for(let t of e)t.charAt(0)==="@"?await(0,So.list)({file:Eo.default.resolve(String(s.cwd),t.slice(1)),noResume:!0,onReadEntry:i=>s.add(i)}):s.add(t);s.end()};ct.replace=(0,pl.makeCommand)(wl,El,()=>{throw new TypeError("file is required")},()=>{throw new TypeError("file is required")},(s,e)=>{if(!(0,_l.isFile)(s))throw new TypeError("file is required");if(s.gzip||s.brotli||s.zstd||s.file.endsWith(".br")||s.file.endsWith(".tbr"))throw new TypeError("cannot append to compressed archives");if(!e?.length)throw new TypeError("no paths specified to add/replace")})});var Cr=d($i=>{"use strict";Object.defineProperty($i,"__esModule",{value:!0});$i.update=void 0;var gl=Ve(),zt=Vi();$i.update=(0,gl.makeCommand)(zt.replace.syncFile,zt.replace.asyncFile,zt.replace.syncNoFile,zt.replace.asyncNoFile,(s,e=[])=>{zt.replace.validate?.(s,e),Ol(s)});var Ol=s=>{let e=s.filter;s.mtimeCache||(s.mtimeCache=new Map),s.filter=e?(t,i)=>e(t,i)&&!((s.mtimeCache?.get(t)??i.mtime??0)>(i.mtime??0)):(t,i)=>!((s.mtimeCache?.get(t)??i.mtime??0)>(i.mtime??0))}});var Oo=exports&&exports.__createBinding||(Object.create?(function(s,e,t,i){i===void 0&&(i=t);var r=Object.getOwnPropertyDescriptor(e,t);(!r||("get"in r?!e.__esModule:r.writable||r.configurable))&&(r={enumerable:!0,get:function(){return e[t]}}),Object.defineProperty(s,i,r)}):(function(s,e,t,i){i===void 0&&(i=t),s[i]=e[t]})),Rl=exports&&exports.__setModuleDefault||(Object.create?(function(s,e){Object.defineProperty(s,"default",{enumerable:!0,value:e})}):function(s,e){s.default=e}),Y=exports&&exports.__exportStar||function(s,e){for(var t in s)t!=="default"&&!Object.prototype.hasOwnProperty.call(e,t)&&Oo(e,s,t)},vl=exports&&exports.__importStar||(function(){var s=function(e){return s=Object.getOwnPropertyNames||function(t){var i=[];for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(i[i.length]=r);return i},s(e)};return function(e){if(e&&e.__esModule)return e;var t={};if(e!=null)for(var i=s(e),r=0;r<i.length;r++)i[r]!=="default"&&Oo(t,e,i[r]);return Rl(t,e),t}})();Object.defineProperty(exports,"__esModule",{value:!0});exports.u=exports.types=exports.r=exports.t=exports.x=exports.c=void 0;Y(mr(),exports);var Tl=mr();Object.defineProperty(exports,"c",{enumerable:!0,get:function(){return Tl.create}});Y(Fr(),exports);var Dl=Fr();Object.defineProperty(exports,"x",{enumerable:!0,get:function(){return Dl.extract}});Y(Je(),exports);Y(st(),exports);var Pl=st();Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return Pl.list}});Y(Ci(),exports);Y(_i(),exports);Y(ii(),exports);Y(oi(),exports);Y(Vi(),exports);var Nl=Vi();Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return Nl.replace}});exports.types=vl(Ns());Y(Ir(),exports);Y(Cr(),exports);var Ml=Cr();Object.defineProperty(exports,"u",{enumerable:!0,get:function(){return Ml.update}});Y(sr(),exports);
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/tar/dist/commonjs/pack.js b/deps/npm/node_modules/tar/dist/commonjs/pack.js
index 76a503a95f696a..bf8481bfae9861 100644
--- a/deps/npm/node_modules/tar/dist/commonjs/pack.js
+++ b/deps/npm/node_modules/tar/dist/commonjs/pack.js
@@ -54,6 +54,7 @@ class PackJob {
     stat;
     readdir;
     pending = false;
+    pendingLink = false;
     ignore = false;
     piped = false;
     constructor(path, absolute) {
@@ -71,6 +72,7 @@ const EOF = Buffer.alloc(1024);
 const ONSTAT = Symbol('onStat');
 const ENDED = Symbol('ended');
 const QUEUE = Symbol('queue');
+const PENDINGLINKS = Symbol('queue');
 const CURRENT = Symbol('current');
 const PROCESS = Symbol('process');
 const PROCESSING = Symbol('processing');
@@ -122,6 +124,7 @@ class Pack extends minipass_1.Minipass {
     // class, but then we'd have to be tracking the tail of the queue the
     // whole time, and Yallist just does that for us anyway.
     [QUEUE];
+    [PENDINGLINKS] = new Map();
     [JOBS] = 0;
     [PROCESSING] = false;
     [ENDED] = false;
@@ -279,14 +282,26 @@ class Pack extends minipass_1.Minipass {
         }
         else if (stat.isFile() &&
             stat.nlink > 1 &&
-            job === this[CURRENT] &&
             !this.linkCache.get(`${stat.dev}:${stat.ino}`) &&
             !this.sync) {
-            // if it's not filtered, and it's a new File entry,
-            // jump the queue in case any pending Link entries are about
-            // to try to link to it. This prevents a hardlink from coming ahead
-            // of its target in the archive.
-            this[PROCESSJOB](job);
+            // if it's not filtered, and it's a new File entry, and next anyway
+            // process right away in case any pending Link entries are about
+            // to try to link to it.
+            if (job === this[CURRENT]) {
+                this[PROCESSJOB](job);
+            }
+            else {
+                // if it's NOT the current entry, it needs to be deferred,
+                // so that the link target can be built first.
+                const key = `${stat.dev}:${stat.ino}`;
+                const pending = this[PENDINGLINKS].get(key);
+                if (pending)
+                    pending.push(job);
+                else
+                    this[PENDINGLINKS].set(key, [job]);
+                job.pendingLink = true;
+                job.pending = true;
+            }
         }
         this[PROCESS]();
     }
@@ -334,12 +349,31 @@ class Pack extends minipass_1.Minipass {
     get [CURRENT]() {
         return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
     }
-    [JOBDONE](_job) {
+    [JOBDONE](job) {
         this[QUEUE].shift();
         this[JOBS] -= 1;
+        const { stat } = job;
+        if (stat && stat.isFile() && stat.nlink > 1) {
+            // might be a file with pending links
+            const key = `${stat.dev}:${stat.ino}`;
+            const pending = this[PENDINGLINKS].get(key);
+            if (pending) {
+                this[PENDINGLINKS].delete(key);
+                for (const job of pending) {
+                    job.pending = false;
+                    this[PROCESSJOB](job);
+                }
+            }
+        }
         this[PROCESS]();
     }
     [PROCESSJOB](job) {
+        if (job.pending && job.pendingLink && job === this[CURRENT]) {
+            // At least one of the links to this file are not being included
+            // in the tarball, so we need to just proceed.
+            job.pending = false;
+            job.pendingLink = false;
+        }
         if (job.pending) {
             return;
         }
diff --git a/deps/npm/node_modules/tar/dist/esm/index.min.js b/deps/npm/node_modules/tar/dist/esm/index.min.js
index 8b043cabab710d..89c9806c4bd74e 100644
--- a/deps/npm/node_modules/tar/dist/esm/index.min.js
+++ b/deps/npm/node_modules/tar/dist/esm/index.min.js
@@ -1,4 +1,4 @@
-var kr=Object.defineProperty;var vr=(s,t)=>{for(var e in t)kr(s,e,{get:t[e],enumerable:!0})};import Kr from"events";import I from"fs";import{EventEmitter as Ti}from"node:events";import Ns from"node:stream";import{StringDecoder as Mr}from"node:string_decoder";var Os=typeof process=="object"&&process?process:{stdout:null,stderr:null},Br=s=>!!s&&typeof s=="object"&&(s instanceof D||s instanceof Ns||Pr(s)||zr(s)),Pr=s=>!!s&&typeof s=="object"&&s instanceof Ti&&typeof s.pipe=="function"&&s.pipe!==Ns.Writable.prototype.pipe,zr=s=>!!s&&typeof s=="object"&&s instanceof Ti&&typeof s.write=="function"&&typeof s.end=="function",q=Symbol("EOF"),j=Symbol("maybeEmitEnd"),rt=Symbol("emittedEnd"),Le=Symbol("emittingEnd"),jt=Symbol("emittedError"),Ne=Symbol("closed"),Ts=Symbol("read"),Ae=Symbol("flush"),xs=Symbol("flushChunk"),z=Symbol("encoding"),Mt=Symbol("decoder"),b=Symbol("flowing"),Qt=Symbol("paused"),Bt=Symbol("resume"),_=Symbol("buffer"),A=Symbol("pipes"),g=Symbol("bufferLength"),yi=Symbol("bufferPush"),De=Symbol("bufferShift"),L=Symbol("objectMode"),w=Symbol("destroyed"),Ri=Symbol("error"),bi=Symbol("emitData"),Ls=Symbol("emitEnd"),_i=Symbol("emitEnd2"),Z=Symbol("async"),gi=Symbol("abort"),Ie=Symbol("aborted"),Jt=Symbol("signal"),yt=Symbol("dataListeners"),C=Symbol("discarded"),te=s=>Promise.resolve().then(s),Ur=s=>s(),Hr=s=>s==="end"||s==="finish"||s==="prefinish",Wr=s=>s instanceof ArrayBuffer||!!s&&typeof s=="object"&&s.constructor&&s.constructor.name==="ArrayBuffer"&&s.byteLength>=0,Gr=s=>!Buffer.isBuffer(s)&&ArrayBuffer.isView(s),Ce=class{src;dest;opts;ondrain;constructor(t,e,i){this.src=t,this.dest=e,this.opts=i,this.ondrain=()=>t[Bt](),this.dest.on("drain",this.ondrain)}unpipe(){this.dest.removeListener("drain",this.ondrain)}proxyErrors(t){}end(){this.unpipe(),this.opts.end&&this.dest.end()}},Oi=class extends Ce{unpipe(){this.src.removeListener("error",this.proxyErrors),super.unpipe()}constructor(t,e,i){super(t,e,i),this.proxyErrors=r=>this.dest.emit("error",r),t.on("error",this.proxyErrors)}},Zr=s=>!!s.objectMode,Yr=s=>!s.objectMode&&!!s.encoding&&s.encoding!=="buffer",D=class extends Ti{[b]=!1;[Qt]=!1;[A]=[];[_]=[];[L];[z];[Z];[Mt];[q]=!1;[rt]=!1;[Le]=!1;[Ne]=!1;[jt]=null;[g]=0;[w]=!1;[Jt];[Ie]=!1;[yt]=0;[C]=!1;writable=!0;readable=!0;constructor(...t){let e=t[0]||{};if(super(),e.objectMode&&typeof e.encoding=="string")throw new TypeError("Encoding and objectMode may not be used together");Zr(e)?(this[L]=!0,this[z]=null):Yr(e)?(this[z]=e.encoding,this[L]=!1):(this[L]=!1,this[z]=null),this[Z]=!!e.async,this[Mt]=this[z]?new Mr(this[z]):null,e&&e.debugExposeBuffer===!0&&Object.defineProperty(this,"buffer",{get:()=>this[_]}),e&&e.debugExposePipes===!0&&Object.defineProperty(this,"pipes",{get:()=>this[A]});let{signal:i}=e;i&&(this[Jt]=i,i.aborted?this[gi]():i.addEventListener("abort",()=>this[gi]()))}get bufferLength(){return this[g]}get encoding(){return this[z]}set encoding(t){throw new Error("Encoding must be set at instantiation time")}setEncoding(t){throw new Error("Encoding must be set at instantiation time")}get objectMode(){return this[L]}set objectMode(t){throw new Error("objectMode must be set at instantiation time")}get async(){return this[Z]}set async(t){this[Z]=this[Z]||!!t}[gi](){this[Ie]=!0,this.emit("abort",this[Jt]?.reason),this.destroy(this[Jt]?.reason)}get aborted(){return this[Ie]}set aborted(t){}write(t,e,i){if(this[Ie])return!1;if(this[q])throw new Error("write after end");if(this[w])return this.emit("error",Object.assign(new Error("Cannot call write after a stream was destroyed"),{code:"ERR_STREAM_DESTROYED"})),!0;typeof e=="function"&&(i=e,e="utf8"),e||(e="utf8");let r=this[Z]?te:Ur;if(!this[L]&&!Buffer.isBuffer(t)){if(Gr(t))t=Buffer.from(t.buffer,t.byteOffset,t.byteLength);else if(Wr(t))t=Buffer.from(t);else if(typeof t!="string")throw new Error("Non-contiguous data written to non-objectMode stream")}return this[L]?(this[b]&&this[g]!==0&&this[Ae](!0),this[b]?this.emit("data",t):this[yi](t),this[g]!==0&&this.emit("readable"),i&&r(i),this[b]):t.length?(typeof t=="string"&&!(e===this[z]&&!this[Mt]?.lastNeed)&&(t=Buffer.from(t,e)),Buffer.isBuffer(t)&&this[z]&&(t=this[Mt].write(t)),this[b]&&this[g]!==0&&this[Ae](!0),this[b]?this.emit("data",t):this[yi](t),this[g]!==0&&this.emit("readable"),i&&r(i),this[b]):(this[g]!==0&&this.emit("readable"),i&&r(i),this[b])}read(t){if(this[w])return null;if(this[C]=!1,this[g]===0||t===0||t&&t>this[g])return this[j](),null;this[L]&&(t=null),this[_].length>1&&!this[L]&&(this[_]=[this[z]?this[_].join(""):Buffer.concat(this[_],this[g])]);let e=this[Ts](t||null,this[_][0]);return this[j](),e}[Ts](t,e){if(this[L])this[De]();else{let i=e;t===i.length||t===null?this[De]():typeof i=="string"?(this[_][0]=i.slice(t),e=i.slice(0,t),this[g]-=t):(this[_][0]=i.subarray(t),e=i.subarray(0,t),this[g]-=t)}return this.emit("data",e),!this[_].length&&!this[q]&&this.emit("drain"),e}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e="utf8"),t!==void 0&&this.write(t,e),i&&this.once("end",i),this[q]=!0,this.writable=!1,(this[b]||!this[Qt])&&this[j](),this}[Bt](){this[w]||(!this[yt]&&!this[A].length&&(this[C]=!0),this[Qt]=!1,this[b]=!0,this.emit("resume"),this[_].length?this[Ae]():this[q]?this[j]():this.emit("drain"))}resume(){return this[Bt]()}pause(){this[b]=!1,this[Qt]=!0,this[C]=!1}get destroyed(){return this[w]}get flowing(){return this[b]}get paused(){return this[Qt]}[yi](t){this[L]?this[g]+=1:this[g]+=t.length,this[_].push(t)}[De](){return this[L]?this[g]-=1:this[g]-=this[_][0].length,this[_].shift()}[Ae](t=!1){do;while(this[xs](this[De]())&&this[_].length);!t&&!this[_].length&&!this[q]&&this.emit("drain")}[xs](t){return this.emit("data",t),this[b]}pipe(t,e){if(this[w])return t;this[C]=!1;let i=this[rt];return e=e||{},t===Os.stdout||t===Os.stderr?e.end=!1:e.end=e.end!==!1,e.proxyErrors=!!e.proxyErrors,i?e.end&&t.end():(this[A].push(e.proxyErrors?new Oi(this,t,e):new Ce(this,t,e)),this[Z]?te(()=>this[Bt]()):this[Bt]()),t}unpipe(t){let e=this[A].find(i=>i.dest===t);e&&(this[A].length===1?(this[b]&&this[yt]===0&&(this[b]=!1),this[A]=[]):this[A].splice(this[A].indexOf(e),1),e.unpipe())}addListener(t,e){return this.on(t,e)}on(t,e){let i=super.on(t,e);if(t==="data")this[C]=!1,this[yt]++,!this[A].length&&!this[b]&&this[Bt]();else if(t==="readable"&&this[g]!==0)super.emit("readable");else if(Hr(t)&&this[rt])super.emit(t),this.removeAllListeners(t);else if(t==="error"&&this[jt]){let r=e;this[Z]?te(()=>r.call(this,this[jt])):r.call(this,this[jt])}return i}removeListener(t,e){return this.off(t,e)}off(t,e){let i=super.off(t,e);return t==="data"&&(this[yt]=this.listeners("data").length,this[yt]===0&&!this[C]&&!this[A].length&&(this[b]=!1)),i}removeAllListeners(t){let e=super.removeAllListeners(t);return(t==="data"||t===void 0)&&(this[yt]=0,!this[C]&&!this[A].length&&(this[b]=!1)),e}get emittedEnd(){return this[rt]}[j](){!this[Le]&&!this[rt]&&!this[w]&&this[_].length===0&&this[q]&&(this[Le]=!0,this.emit("end"),this.emit("prefinish"),this.emit("finish"),this[Ne]&&this.emit("close"),this[Le]=!1)}emit(t,...e){let i=e[0];if(t!=="error"&&t!=="close"&&t!==w&&this[w])return!1;if(t==="data")return!this[L]&&!i?!1:this[Z]?(te(()=>this[bi](i)),!0):this[bi](i);if(t==="end")return this[Ls]();if(t==="close"){if(this[Ne]=!0,!this[rt]&&!this[w])return!1;let n=super.emit("close");return this.removeAllListeners("close"),n}else if(t==="error"){this[jt]=i,super.emit(Ri,i);let n=!this[Jt]||this.listeners("error").length?super.emit("error",i):!1;return this[j](),n}else if(t==="resume"){let n=super.emit("resume");return this[j](),n}else if(t==="finish"||t==="prefinish"){let n=super.emit(t);return this.removeAllListeners(t),n}let r=super.emit(t,...e);return this[j](),r}[bi](t){for(let i of this[A])i.dest.write(t)===!1&&this.pause();let e=this[C]?!1:super.emit("data",t);return this[j](),e}[Ls](){return this[rt]?!1:(this[rt]=!0,this.readable=!1,this[Z]?(te(()=>this[_i]()),!0):this[_i]())}[_i](){if(this[Mt]){let e=this[Mt].end();if(e){for(let i of this[A])i.dest.write(e);this[C]||super.emit("data",e)}}for(let e of this[A])e.end();let t=super.emit("end");return this.removeAllListeners("end"),t}async collect(){let t=Object.assign([],{dataLength:0});this[L]||(t.dataLength=0);let e=this.promise();return this.on("data",i=>{t.push(i),this[L]||(t.dataLength+=i.length)}),await e,t}async concat(){if(this[L])throw new Error("cannot concat in objectMode");let t=await this.collect();return this[z]?t.join(""):Buffer.concat(t,t.dataLength)}async promise(){return new Promise((t,e)=>{this.on(w,()=>e(new Error("stream destroyed"))),this.on("error",i=>e(i)),this.on("end",()=>t())})}[Symbol.asyncIterator](){this[C]=!1;let t=!1,e=async()=>(this.pause(),t=!0,{value:void 0,done:!0});return{next:()=>{if(t)return e();let r=this.read();if(r!==null)return Promise.resolve({done:!1,value:r});if(this[q])return e();let n,o,h=d=>{this.off("data",a),this.off("end",l),this.off(w,c),e(),o(d)},a=d=>{this.off("error",h),this.off("end",l),this.off(w,c),this.pause(),n({value:d,done:!!this[q]})},l=()=>{this.off("error",h),this.off("data",a),this.off(w,c),e(),n({done:!0,value:void 0})},c=()=>h(new Error("stream destroyed"));return new Promise((d,S)=>{o=S,n=d,this.once(w,c),this.once("error",h),this.once("end",l),this.once("data",a)})},throw:e,return:e,[Symbol.asyncIterator](){return this},[Symbol.asyncDispose]:async()=>{}}}[Symbol.iterator](){this[C]=!1;let t=!1,e=()=>(this.pause(),this.off(Ri,e),this.off(w,e),this.off("end",e),t=!0,{done:!0,value:void 0}),i=()=>{if(t)return e();let r=this.read();return r===null?e():{done:!1,value:r}};return this.once("end",e),this.once(Ri,e),this.once(w,e),{next:i,throw:e,return:e,[Symbol.iterator](){return this},[Symbol.dispose]:()=>{}}}destroy(t){if(this[w])return t?this.emit("error",t):this.emit(w),this;this[w]=!0,this[C]=!0,this[_].length=0,this[g]=0;let e=this;return typeof e.close=="function"&&!this[Ne]&&e.close(),t?this.emit("error",t):this.emit(w),this}static get isStream(){return Br}};var Vr=I.writev,ot=Symbol("_autoClose"),H=Symbol("_close"),ee=Symbol("_ended"),m=Symbol("_fd"),xi=Symbol("_finished"),J=Symbol("_flags"),Li=Symbol("_flush"),Ii=Symbol("_handleChunk"),Ci=Symbol("_makeBuf"),se=Symbol("_mode"),Fe=Symbol("_needDrain"),Ut=Symbol("_onerror"),Ht=Symbol("_onopen"),Ni=Symbol("_onread"),Pt=Symbol("_onwrite"),ht=Symbol("_open"),U=Symbol("_path"),nt=Symbol("_pos"),Y=Symbol("_queue"),zt=Symbol("_read"),Ai=Symbol("_readSize"),Q=Symbol("_reading"),ie=Symbol("_remain"),Di=Symbol("_size"),ke=Symbol("_write"),Rt=Symbol("_writing"),ve=Symbol("_defaultFlag"),bt=Symbol("_errored"),_t=class extends D{[bt]=!1;[m];[U];[Ai];[Q]=!1;[Di];[ie];[ot];constructor(t,e){if(e=e||{},super(e),this.readable=!0,this.writable=!1,typeof t!="string")throw new TypeError("path must be a string");this[bt]=!1,this[m]=typeof e.fd=="number"?e.fd:void 0,this[U]=t,this[Ai]=e.readSize||16*1024*1024,this[Q]=!1,this[Di]=typeof e.size=="number"?e.size:1/0,this[ie]=this[Di],this[ot]=typeof e.autoClose=="boolean"?e.autoClose:!0,typeof this[m]=="number"?this[zt]():this[ht]()}get fd(){return this[m]}get path(){return this[U]}write(){throw new TypeError("this is a readable stream")}end(){throw new TypeError("this is a readable stream")}[ht](){I.open(this[U],"r",(t,e)=>this[Ht](t,e))}[Ht](t,e){t?this[Ut](t):(this[m]=e,this.emit("open",e),this[zt]())}[Ci](){return Buffer.allocUnsafe(Math.min(this[Ai],this[ie]))}[zt](){if(!this[Q]){this[Q]=!0;let t=this[Ci]();if(t.length===0)return process.nextTick(()=>this[Ni](null,0,t));I.read(this[m],t,0,t.length,null,(e,i,r)=>this[Ni](e,i,r))}}[Ni](t,e,i){this[Q]=!1,t?this[Ut](t):this[Ii](e,i)&&this[zt]()}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}[Ut](t){this[Q]=!0,this[H](),this.emit("error",t)}[Ii](t,e){let i=!1;return this[ie]-=t,t>0&&(i=super.write(t<e.length?e.subarray(0,t):e)),(t===0||this[ie]<=0)&&(i=!1,this[H](),super.end()),i}emit(t,...e){switch(t){case"prefinish":case"finish":return!1;case"drain":return typeof this[m]=="number"&&this[zt](),!1;case"error":return this[bt]?!1:(this[bt]=!0,super.emit(t,...e));default:return super.emit(t,...e)}}},Me=class extends _t{[ht](){let t=!0;try{this[Ht](null,I.openSync(this[U],"r")),t=!1}finally{t&&this[H]()}}[zt](){let t=!0;try{if(!this[Q]){this[Q]=!0;do{let e=this[Ci](),i=e.length===0?0:I.readSync(this[m],e,0,e.length,null);if(!this[Ii](i,e))break}while(!0);this[Q]=!1}t=!1}finally{t&&this[H]()}}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}},tt=class extends Kr{readable=!1;writable=!0;[bt]=!1;[Rt]=!1;[ee]=!1;[Y]=[];[Fe]=!1;[U];[se];[ot];[m];[ve];[J];[xi]=!1;[nt];constructor(t,e){e=e||{},super(e),this[U]=t,this[m]=typeof e.fd=="number"?e.fd:void 0,this[se]=e.mode===void 0?438:e.mode,this[nt]=typeof e.start=="number"?e.start:void 0,this[ot]=typeof e.autoClose=="boolean"?e.autoClose:!0;let i=this[nt]!==void 0?"r+":"w";this[ve]=e.flags===void 0,this[J]=e.flags===void 0?i:e.flags,this[m]===void 0&&this[ht]()}emit(t,...e){if(t==="error"){if(this[bt])return!1;this[bt]=!0}return super.emit(t,...e)}get fd(){return this[m]}get path(){return this[U]}[Ut](t){this[H](),this[Rt]=!0,this.emit("error",t)}[ht](){I.open(this[U],this[J],this[se],(t,e)=>this[Ht](t,e))}[Ht](t,e){this[ve]&&this[J]==="r+"&&t&&t.code==="ENOENT"?(this[J]="w",this[ht]()):t?this[Ut](t):(this[m]=e,this.emit("open",e),this[Rt]||this[Li]())}end(t,e){return t&&this.write(t,e),this[ee]=!0,!this[Rt]&&!this[Y].length&&typeof this[m]=="number"&&this[Pt](null,0),this}write(t,e){return typeof t=="string"&&(t=Buffer.from(t,e)),this[ee]?(this.emit("error",new Error("write() after end()")),!1):this[m]===void 0||this[Rt]||this[Y].length?(this[Y].push(t),this[Fe]=!0,!1):(this[Rt]=!0,this[ke](t),!0)}[ke](t){I.write(this[m],t,0,t.length,this[nt],(e,i)=>this[Pt](e,i))}[Pt](t,e){t?this[Ut](t):(this[nt]!==void 0&&typeof e=="number"&&(this[nt]+=e),this[Y].length?this[Li]():(this[Rt]=!1,this[ee]&&!this[xi]?(this[xi]=!0,this[H](),this.emit("finish")):this[Fe]&&(this[Fe]=!1,this.emit("drain"))))}[Li](){if(this[Y].length===0)this[ee]&&this[Pt](null,0);else if(this[Y].length===1)this[ke](this[Y].pop());else{let t=this[Y];this[Y]=[],Vr(this[m],t,this[nt],(e,i)=>this[Pt](e,i))}}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}},Wt=class extends tt{[ht](){let t;if(this[ve]&&this[J]==="r+")try{t=I.openSync(this[U],this[J],this[se])}catch(e){if(e?.code==="ENOENT")return this[J]="w",this[ht]();throw e}else t=I.openSync(this[U],this[J],this[se]);this[Ht](null,t)}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}[ke](t){let e=!0;try{this[Pt](null,I.writeSync(this[m],t,0,t.length,this[nt])),e=!1}finally{if(e)try{this[H]()}catch{}}}};import nr from"node:path";import Vt from"node:fs";import{dirname as xn,parse as Ln}from"path";var $r=new Map([["C","cwd"],["f","file"],["z","gzip"],["P","preservePaths"],["U","unlink"],["strip-components","strip"],["stripComponents","strip"],["keep-newer","newer"],["keepNewer","newer"],["keep-newer-files","newer"],["keepNewerFiles","newer"],["k","keep"],["keep-existing","keep"],["keepExisting","keep"],["m","noMtime"],["no-mtime","noMtime"],["p","preserveOwner"],["L","follow"],["h","follow"],["onentry","onReadEntry"]]),As=s=>!!s.sync&&!!s.file,Ds=s=>!s.sync&&!!s.file,Is=s=>!!s.sync&&!s.file,Cs=s=>!s.sync&&!s.file;var Fs=s=>!!s.file;var Xr=s=>{let t=$r.get(s);return t||s},re=(s={})=>{if(!s)return{};let t={};for(let[e,i]of Object.entries(s)){let r=Xr(e);t[r]=i}return t.chmod===void 0&&t.noChmod===!1&&(t.chmod=!0),delete t.noChmod,t};var K=(s,t,e,i,r)=>Object.assign((n=[],o,h)=>{Array.isArray(n)&&(o=n,n={}),typeof o=="function"&&(h=o,o=void 0),o=o?Array.from(o):[];let a=re(n);if(r?.(a,o),As(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return s(a,o)}else if(Ds(a)){let l=t(a,o);return h?l.then(()=>h(),h):l}else if(Is(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return e(a,o)}else if(Cs(a)){if(typeof h=="function")throw new TypeError("callback only supported with file option");return i(a,o)}throw new Error("impossible options??")},{syncFile:s,asyncFile:t,syncNoFile:e,asyncNoFile:i,validate:r});import{EventEmitter as _n}from"events";import Mi from"assert";import{Buffer as gt}from"buffer";import*as ks from"zlib";import qr from"zlib";var jr=qr.constants||{ZLIB_VERNUM:4736},M=Object.freeze(Object.assign(Object.create(null),{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_VERSION_ERROR:-6,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,DEFLATE:1,INFLATE:2,GZIP:3,GUNZIP:4,DEFLATERAW:5,INFLATERAW:6,UNZIP:7,BROTLI_DECODE:8,BROTLI_ENCODE:9,Z_MIN_WINDOWBITS:8,Z_MAX_WINDOWBITS:15,Z_DEFAULT_WINDOWBITS:15,Z_MIN_CHUNK:64,Z_MAX_CHUNK:1/0,Z_DEFAULT_CHUNK:16384,Z_MIN_MEMLEVEL:1,Z_MAX_MEMLEVEL:9,Z_DEFAULT_MEMLEVEL:8,Z_MIN_LEVEL:-1,Z_MAX_LEVEL:9,Z_DEFAULT_LEVEL:-1,BROTLI_OPERATION_PROCESS:0,BROTLI_OPERATION_FLUSH:1,BROTLI_OPERATION_FINISH:2,BROTLI_OPERATION_EMIT_METADATA:3,BROTLI_MODE_GENERIC:0,BROTLI_MODE_TEXT:1,BROTLI_MODE_FONT:2,BROTLI_DEFAULT_MODE:0,BROTLI_MIN_QUALITY:0,BROTLI_MAX_QUALITY:11,BROTLI_DEFAULT_QUALITY:11,BROTLI_MIN_WINDOW_BITS:10,BROTLI_MAX_WINDOW_BITS:24,BROTLI_LARGE_MAX_WINDOW_BITS:30,BROTLI_DEFAULT_WINDOW:22,BROTLI_MIN_INPUT_BLOCK_BITS:16,BROTLI_MAX_INPUT_BLOCK_BITS:24,BROTLI_PARAM_MODE:0,BROTLI_PARAM_QUALITY:1,BROTLI_PARAM_LGWIN:2,BROTLI_PARAM_LGBLOCK:3,BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:4,BROTLI_PARAM_SIZE_HINT:5,BROTLI_PARAM_LARGE_WINDOW:6,BROTLI_PARAM_NPOSTFIX:7,BROTLI_PARAM_NDIRECT:8,BROTLI_DECODER_RESULT_ERROR:0,BROTLI_DECODER_RESULT_SUCCESS:1,BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:2,BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:0,BROTLI_DECODER_PARAM_LARGE_WINDOW:1,BROTLI_DECODER_NO_ERROR:0,BROTLI_DECODER_SUCCESS:1,BROTLI_DECODER_NEEDS_MORE_INPUT:2,BROTLI_DECODER_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:-1,BROTLI_DECODER_ERROR_FORMAT_RESERVED:-2,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:-3,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:-4,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:-5,BROTLI_DECODER_ERROR_FORMAT_CL_SPACE:-6,BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE:-7,BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT:-8,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1:-9,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2:-10,BROTLI_DECODER_ERROR_FORMAT_TRANSFORM:-11,BROTLI_DECODER_ERROR_FORMAT_DICTIONARY:-12,BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS:-13,BROTLI_DECODER_ERROR_FORMAT_PADDING_1:-14,BROTLI_DECODER_ERROR_FORMAT_PADDING_2:-15,BROTLI_DECODER_ERROR_FORMAT_DISTANCE:-16,BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET:-19,BROTLI_DECODER_ERROR_INVALID_ARGUMENTS:-20,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES:-21,BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS:-22,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP:-25,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1:-26,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2:-27,BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES:-30,BROTLI_DECODER_ERROR_UNREACHABLE:-31},jr));var Qr=gt.concat,vs=Object.getOwnPropertyDescriptor(gt,"concat"),Jr=s=>s,ki=vs?.writable===!0||vs?.set!==void 0?s=>{gt.concat=s?Jr:Qr}:s=>{},Ot=Symbol("_superWrite"),Gt=class extends Error{code;errno;constructor(t,e){super("zlib: "+t.message,{cause:t}),this.code=t.code,this.errno=t.errno,this.code||(this.code="ZLIB_ERROR"),this.message="zlib: "+t.message,Error.captureStackTrace(this,e??this.constructor)}get name(){return"ZlibError"}},vi=Symbol("flushFlag"),ne=class extends D{#t=!1;#i=!1;#s;#n;#r;#e;#o;get sawError(){return this.#t}get handle(){return this.#e}get flushFlag(){return this.#s}constructor(t,e){if(!t||typeof t!="object")throw new TypeError("invalid options for ZlibBase constructor");if(super(t),this.#s=t.flush??0,this.#n=t.finishFlush??0,this.#r=t.fullFlushFlag??0,typeof ks[e]!="function")throw new TypeError("Compression method not supported: "+e);try{this.#e=new ks[e](t)}catch(i){throw new Gt(i,this.constructor)}this.#o=i=>{this.#t||(this.#t=!0,this.close(),this.emit("error",i))},this.#e?.on("error",i=>this.#o(new Gt(i))),this.once("end",()=>this.close)}close(){this.#e&&(this.#e.close(),this.#e=void 0,this.emit("close"))}reset(){if(!this.#t)return Mi(this.#e,"zlib binding closed"),this.#e.reset?.()}flush(t){this.ended||(typeof t!="number"&&(t=this.#r),this.write(Object.assign(gt.alloc(0),{[vi]:t})))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&(e?this.write(t,e):this.write(t)),this.flush(this.#n),this.#i=!0,super.end(i)}get ended(){return this.#i}[Ot](t){return super.write(t)}write(t,e,i){if(typeof e=="function"&&(i=e,e="utf8"),typeof t=="string"&&(t=gt.from(t,e)),this.#t)return;Mi(this.#e,"zlib binding closed");let r=this.#e._handle,n=r.close;r.close=()=>{};let o=this.#e.close;this.#e.close=()=>{},ki(!0);let h;try{let l=typeof t[vi]=="number"?t[vi]:this.#s;h=this.#e._processChunk(t,l),ki(!1)}catch(l){ki(!1),this.#o(new Gt(l,this.write))}finally{this.#e&&(this.#e._handle=r,r.close=n,this.#e.close=o,this.#e.removeAllListeners("error"))}this.#e&&this.#e.on("error",l=>this.#o(new Gt(l,this.write)));let a;if(h)if(Array.isArray(h)&&h.length>0){let l=h[0];a=this[Ot](gt.from(l));for(let c=1;c<h.length;c++)a=this[Ot](h[c])}else a=this[Ot](gt.from(h));return i&&i(),a}},Be=class extends ne{#t;#i;constructor(t,e){t=t||{},t.flush=t.flush||M.Z_NO_FLUSH,t.finishFlush=t.finishFlush||M.Z_FINISH,t.fullFlushFlag=M.Z_FULL_FLUSH,super(t,e),this.#t=t.level,this.#i=t.strategy}params(t,e){if(!this.sawError){if(!this.handle)throw new Error("cannot switch params when binding is closed");if(!this.handle.params)throw new Error("not supported in this implementation");if(this.#t!==t||this.#i!==e){this.flush(M.Z_SYNC_FLUSH),Mi(this.handle,"zlib binding closed");let i=this.handle.flush;this.handle.flush=(r,n)=>{typeof r=="function"&&(n=r,r=this.flushFlag),this.flush(r),n?.()};try{this.handle.params(t,e)}finally{this.handle.flush=i}this.handle&&(this.#t=t,this.#i=e)}}}};var Pe=class extends Be{#t;constructor(t){super(t,"Gzip"),this.#t=t&&!!t.portable}[Ot](t){return this.#t?(this.#t=!1,t[9]=255,super[Ot](t)):super[Ot](t)}};var ze=class extends Be{constructor(t){super(t,"Unzip")}},Ue=class extends ne{constructor(t,e){t=t||{},t.flush=t.flush||M.BROTLI_OPERATION_PROCESS,t.finishFlush=t.finishFlush||M.BROTLI_OPERATION_FINISH,t.fullFlushFlag=M.BROTLI_OPERATION_FLUSH,super(t,e)}},He=class extends Ue{constructor(t){super(t,"BrotliCompress")}},We=class extends Ue{constructor(t){super(t,"BrotliDecompress")}},Ge=class extends ne{constructor(t,e){t=t||{},t.flush=t.flush||M.ZSTD_e_continue,t.finishFlush=t.finishFlush||M.ZSTD_e_end,t.fullFlushFlag=M.ZSTD_e_flush,super(t,e)}},Ze=class extends Ge{constructor(t){super(t,"ZstdCompress")}},Ye=class extends Ge{constructor(t){super(t,"ZstdDecompress")}};import{posix as Zt}from"node:path";var Ms=(s,t)=>{if(Number.isSafeInteger(s))s<0?sn(s,t):en(s,t);else throw Error("cannot encode number outside of javascript safe integer range");return t},en=(s,t)=>{t[0]=128;for(var e=t.length;e>1;e--)t[e-1]=s&255,s=Math.floor(s/256)},sn=(s,t)=>{t[0]=255;var e=!1;s=s*-1;for(var i=t.length;i>1;i--){var r=s&255;s=Math.floor(s/256),e?t[i-1]=Ps(r):r===0?t[i-1]=0:(e=!0,t[i-1]=zs(r))}},Bs=s=>{let t=s[0],e=t===128?nn(s.subarray(1,s.length)):t===255?rn(s):null;if(e===null)throw Error("invalid base256 encoding");if(!Number.isSafeInteger(e))throw Error("parsed number outside of javascript safe integer range");return e},rn=s=>{for(var t=s.length,e=0,i=!1,r=t-1;r>-1;r--){var n=Number(s[r]),o;i?o=Ps(n):n===0?o=n:(i=!0,o=zs(n)),o!==0&&(e-=o*Math.pow(256,t-r-1))}return e},nn=s=>{for(var t=s.length,e=0,i=t-1;i>-1;i--){var r=Number(s[i]);r!==0&&(e+=r*Math.pow(256,t-i-1))}return e},Ps=s=>(255^s)&255,zs=s=>(255^s)+1&255;var Bi={};vr(Bi,{code:()=>Ke,isCode:()=>oe,isName:()=>hn,name:()=>he});var oe=s=>he.has(s),hn=s=>Ke.has(s),he=new Map([["0","File"],["","OldFile"],["1","Link"],["2","SymbolicLink"],["3","CharacterDevice"],["4","BlockDevice"],["5","Directory"],["6","FIFO"],["7","ContiguousFile"],["g","GlobalExtendedHeader"],["x","ExtendedHeader"],["A","SolarisACL"],["D","GNUDumpDir"],["I","Inode"],["K","NextFileHasLongLinkpath"],["L","NextFileHasLongPath"],["M","ContinuationFile"],["N","OldGnuLongPath"],["S","SparseFile"],["V","TapeVolumeHeader"],["X","OldExtendedHeader"]]),Ke=new Map(Array.from(he).map(s=>[s[1],s[0]]));var F=class{cksumValid=!1;needPax=!1;nullBlock=!1;block;path;mode;uid;gid;size;cksum;#t="Unsupported";linkpath;uname;gname;devmaj=0;devmin=0;atime;ctime;mtime;charset;comment;constructor(t,e=0,i,r){Buffer.isBuffer(t)?this.decode(t,e||0,i,r):t&&this.#i(t)}decode(t,e,i,r){if(e||(e=0),!t||!(t.length>=e+512))throw new Error("need 512 bytes for header");this.path=i?.path??Tt(t,e,100),this.mode=i?.mode??r?.mode??at(t,e+100,8),this.uid=i?.uid??r?.uid??at(t,e+108,8),this.gid=i?.gid??r?.gid??at(t,e+116,8),this.size=i?.size??r?.size??at(t,e+124,12),this.mtime=i?.mtime??r?.mtime??Pi(t,e+136,12),this.cksum=at(t,e+148,12),r&&this.#i(r,!0),i&&this.#i(i);let n=Tt(t,e+156,1);if(oe(n)&&(this.#t=n||"0"),this.#t==="0"&&this.path.slice(-1)==="/"&&(this.#t="5"),this.#t==="5"&&(this.size=0),this.linkpath=Tt(t,e+157,100),t.subarray(e+257,e+265).toString()==="ustar\x0000")if(this.uname=i?.uname??r?.uname??Tt(t,e+265,32),this.gname=i?.gname??r?.gname??Tt(t,e+297,32),this.devmaj=i?.devmaj??r?.devmaj??at(t,e+329,8)??0,this.devmin=i?.devmin??r?.devmin??at(t,e+337,8)??0,t[e+475]!==0){let h=Tt(t,e+345,155);this.path=h+"/"+this.path}else{let h=Tt(t,e+345,130);h&&(this.path=h+"/"+this.path),this.atime=i?.atime??r?.atime??Pi(t,e+476,12),this.ctime=i?.ctime??r?.ctime??Pi(t,e+488,12)}let o=256;for(let h=e;h<e+148;h++)o+=t[h];for(let h=e+156;h<e+512;h++)o+=t[h];this.cksumValid=o===this.cksum,this.cksum===void 0&&o===256&&(this.nullBlock=!0)}#i(t,e=!1){Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="path"&&e||i==="linkpath"&&e||i==="global"))))}encode(t,e=0){if(t||(t=this.block=Buffer.alloc(512)),this.#t==="Unsupported"&&(this.#t="0"),!(t.length>=e+512))throw new Error("need 512 bytes for header");let i=this.ctime||this.atime?130:155,r=an(this.path||"",i),n=r[0],o=r[1];this.needPax=!!r[2],this.needPax=xt(t,e,100,n)||this.needPax,this.needPax=lt(t,e+100,8,this.mode)||this.needPax,this.needPax=lt(t,e+108,8,this.uid)||this.needPax,this.needPax=lt(t,e+116,8,this.gid)||this.needPax,this.needPax=lt(t,e+124,12,this.size)||this.needPax,this.needPax=zi(t,e+136,12,this.mtime)||this.needPax,t[e+156]=Number(this.#t.codePointAt(0)),this.needPax=xt(t,e+157,100,this.linkpath)||this.needPax,t.write("ustar\x0000",e+257,8),this.needPax=xt(t,e+265,32,this.uname)||this.needPax,this.needPax=xt(t,e+297,32,this.gname)||this.needPax,this.needPax=lt(t,e+329,8,this.devmaj)||this.needPax,this.needPax=lt(t,e+337,8,this.devmin)||this.needPax,this.needPax=xt(t,e+345,i,o)||this.needPax,t[e+475]!==0?this.needPax=xt(t,e+345,155,o)||this.needPax:(this.needPax=xt(t,e+345,130,o)||this.needPax,this.needPax=zi(t,e+476,12,this.atime)||this.needPax,this.needPax=zi(t,e+488,12,this.ctime)||this.needPax);let h=256;for(let a=e;a<e+148;a++)h+=t[a];for(let a=e+156;a<e+512;a++)h+=t[a];return this.cksum=h,lt(t,e+148,8,this.cksum),this.cksumValid=!0,this.needPax}get type(){return this.#t==="Unsupported"?this.#t:he.get(this.#t)}get typeKey(){return this.#t}set type(t){let e=String(Ke.get(t));if(oe(e)||e==="Unsupported")this.#t=e;else if(oe(t))this.#t=t;else throw new TypeError("invalid entry type: "+t)}},an=(s,t)=>{let i=s,r="",n,o=Zt.parse(s).root||".";if(Buffer.byteLength(i)<100)n=[i,r,!1];else{r=Zt.dirname(i),i=Zt.basename(i);do Buffer.byteLength(i)<=100&&Buffer.byteLength(r)<=t?n=[i,r,!1]:Buffer.byteLength(i)>100&&Buffer.byteLength(r)<=t?n=[i.slice(0,99),r,!0]:(i=Zt.join(Zt.basename(r),i),r=Zt.dirname(r));while(r!==o&&n===void 0);n||(n=[s.slice(0,99),"",!0])}return n},Tt=(s,t,e)=>s.subarray(t,t+e).toString("utf8").replace(/\0.*/,""),Pi=(s,t,e)=>ln(at(s,t,e)),ln=s=>s===void 0?void 0:new Date(s*1e3),at=(s,t,e)=>Number(s[t])&128?Bs(s.subarray(t,t+e)):fn(s,t,e),cn=s=>isNaN(s)?void 0:s,fn=(s,t,e)=>cn(parseInt(s.subarray(t,t+e).toString("utf8").replace(/\0.*$/,"").trim(),8)),dn={12:8589934591,8:2097151},lt=(s,t,e,i)=>i===void 0?!1:i>dn[e]||i<0?(Ms(i,s.subarray(t,t+e)),!0):(un(s,t,e,i),!1),un=(s,t,e,i)=>s.write(mn(i,e),t,e,"ascii"),mn=(s,t)=>pn(Math.floor(s).toString(8),t),pn=(s,t)=>(s.length===t-1?s:new Array(t-s.length-1).join("0")+s+" ")+"\0",zi=(s,t,e,i)=>i===void 0?!1:lt(s,t,e,i.getTime()/1e3),En=new Array(156).join("\0"),xt=(s,t,e,i)=>i===void 0?!1:(s.write(i+En,t,e,"utf8"),i.length!==Buffer.byteLength(i)||i.length>e);import{basename as wn}from"node:path";var ct=class s{atime;mtime;ctime;charset;comment;gid;uid;gname;uname;linkpath;dev;ino;nlink;path;size;mode;global;constructor(t,e=!1){this.atime=t.atime,this.charset=t.charset,this.comment=t.comment,this.ctime=t.ctime,this.dev=t.dev,this.gid=t.gid,this.global=e,this.gname=t.gname,this.ino=t.ino,this.linkpath=t.linkpath,this.mtime=t.mtime,this.nlink=t.nlink,this.path=t.path,this.size=t.size,this.uid=t.uid,this.uname=t.uname}encode(){let t=this.encodeBody();if(t==="")return Buffer.allocUnsafe(0);let e=Buffer.byteLength(t),i=512*Math.ceil(1+e/512),r=Buffer.allocUnsafe(i);for(let n=0;n<512;n++)r[n]=0;new F({path:("PaxHeader/"+wn(this.path??"")).slice(0,99),mode:this.mode||420,uid:this.uid,gid:this.gid,size:e,mtime:this.mtime,type:this.global?"GlobalExtendedHeader":"ExtendedHeader",linkpath:"",uname:this.uname||"",gname:this.gname||"",devmaj:0,devmin:0,atime:this.atime,ctime:this.ctime}).encode(r),r.write(t,512,e,"utf8");for(let n=e+512;n<r.length;n++)r[n]=0;return r}encodeBody(){return this.encodeField("path")+this.encodeField("ctime")+this.encodeField("atime")+this.encodeField("dev")+this.encodeField("ino")+this.encodeField("nlink")+this.encodeField("charset")+this.encodeField("comment")+this.encodeField("gid")+this.encodeField("gname")+this.encodeField("linkpath")+this.encodeField("mtime")+this.encodeField("size")+this.encodeField("uid")+this.encodeField("uname")}encodeField(t){if(this[t]===void 0)return"";let e=this[t],i=e instanceof Date?e.getTime()/1e3:e,r=" "+(t==="dev"||t==="ino"||t==="nlink"?"SCHILY.":"")+t+"="+i+`
-`,n=Buffer.byteLength(r),o=Math.floor(Math.log(n)/Math.log(10))+1;return n+o>=Math.pow(10,o)&&(o+=1),o+n+r}static parse(t,e,i=!1){return new s(Sn(yn(t),e),i)}},Sn=(s,t)=>t?Object.assign({},t,s):s,yn=s=>s.replace(/\n$/,"").split(`
-`).reduce(Rn,Object.create(null)),Rn=(s,t)=>{let e=parseInt(t,10);if(e!==Buffer.byteLength(t)+1)return s;t=t.slice((e+" ").length);let i=t.split("="),r=i.shift();if(!r)return s;let n=r.replace(/^SCHILY\.(dev|ino|nlink)/,"$1"),o=i.join("=");return s[n]=/^([A-Z]+\.)?([mac]|birth|creation)time$/.test(n)?new Date(Number(o)*1e3):/^[0-9]+$/.test(o)?+o:o,s};var bn=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,f=bn!=="win32"?s=>s:s=>s&&s.replaceAll(/\\/g,"/");var Yt=class extends D{extended;globalExtended;header;startBlockSize;blockRemain;remain;type;meta=!1;ignore=!1;path;mode;uid;gid;uname;gname;size=0;mtime;atime;ctime;linkpath;dev;ino;nlink;invalid=!1;absolute;unsupported=!1;constructor(t,e,i){switch(super({}),this.pause(),this.extended=e,this.globalExtended=i,this.header=t,this.remain=t.size??0,this.startBlockSize=512*Math.ceil(this.remain/512),this.blockRemain=this.startBlockSize,this.type=t.type,this.type){case"File":case"OldFile":case"Link":case"SymbolicLink":case"CharacterDevice":case"BlockDevice":case"Directory":case"FIFO":case"ContiguousFile":case"GNUDumpDir":break;case"NextFileHasLongLinkpath":case"NextFileHasLongPath":case"OldGnuLongPath":case"GlobalExtendedHeader":case"ExtendedHeader":case"OldExtendedHeader":this.meta=!0;break;default:this.ignore=!0}if(!t.path)throw new Error("no path provided for tar.ReadEntry");this.path=f(t.path),this.mode=t.mode,this.mode&&(this.mode=this.mode&4095),this.uid=t.uid,this.gid=t.gid,this.uname=t.uname,this.gname=t.gname,this.size=this.remain,this.mtime=t.mtime,this.atime=t.atime,this.ctime=t.ctime,this.linkpath=t.linkpath?f(t.linkpath):void 0,this.uname=t.uname,this.gname=t.gname,e&&this.#t(e),i&&this.#t(i,!0)}write(t){let e=t.length;if(e>this.blockRemain)throw new Error("writing more to entry than is appropriate");let i=this.remain,r=this.blockRemain;return this.remain=Math.max(0,i-e),this.blockRemain=Math.max(0,r-e),this.ignore?!0:i>=e?super.write(t):super.write(t.subarray(0,i))}#t(t,e=!1){t.path&&(t.path=f(t.path)),t.linkpath&&(t.linkpath=f(t.linkpath)),Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="path"&&e))))}};var Lt=(s,t,e,i={})=>{s.file&&(i.file=s.file),s.cwd&&(i.cwd=s.cwd),i.code=e instanceof Error&&e.code||t,i.tarCode=t,!s.strict&&i.recoverable!==!1?(e instanceof Error&&(i=Object.assign(e,i),e=e.message),s.emit("warn",t,e,i)):e instanceof Error?s.emit("error",Object.assign(e,i)):s.emit("error",Object.assign(new Error(`${t}: ${e}`),i))};var gn=1024*1024,Zi=Buffer.from([31,139]),Yi=Buffer.from([40,181,47,253]),On=Math.max(Zi.length,Yi.length),B=Symbol("state"),Nt=Symbol("writeEntry"),et=Symbol("readEntry"),Ui=Symbol("nextEntry"),Us=Symbol("processEntry"),V=Symbol("extendedHeader"),ae=Symbol("globalExtendedHeader"),ft=Symbol("meta"),Hs=Symbol("emitMeta"),p=Symbol("buffer"),it=Symbol("queue"),dt=Symbol("ended"),Hi=Symbol("emittedEnd"),At=Symbol("emit"),y=Symbol("unzip"),Ve=Symbol("consumeChunk"),$e=Symbol("consumeChunkSub"),Wi=Symbol("consumeBody"),Ws=Symbol("consumeMeta"),Gs=Symbol("consumeHeader"),le=Symbol("consuming"),Gi=Symbol("bufferConcat"),Xe=Symbol("maybeEnd"),Kt=Symbol("writing"),ut=Symbol("aborted"),qe=Symbol("onDone"),Dt=Symbol("sawValidEntry"),je=Symbol("sawNullBlock"),Qe=Symbol("sawEOF"),Zs=Symbol("closeStream"),Tn=()=>!0,st=class extends _n{file;strict;maxMetaEntrySize;filter;brotli;zstd;writable=!0;readable=!1;[it]=[];[p];[et];[Nt];[B]="begin";[ft]="";[V];[ae];[dt]=!1;[y];[ut]=!1;[Dt];[je]=!1;[Qe]=!1;[Kt]=!1;[le]=!1;[Hi]=!1;constructor(t={}){super(),this.file=t.file||"",this.on(qe,()=>{(this[B]==="begin"||this[Dt]===!1)&&this.warn("TAR_BAD_ARCHIVE","Unrecognized archive format")}),t.ondone?this.on(qe,t.ondone):this.on(qe,()=>{this.emit("prefinish"),this.emit("finish"),this.emit("end")}),this.strict=!!t.strict,this.maxMetaEntrySize=t.maxMetaEntrySize||gn,this.filter=typeof t.filter=="function"?t.filter:Tn;let e=t.file&&(t.file.endsWith(".tar.br")||t.file.endsWith(".tbr"));this.brotli=!(t.gzip||t.zstd)&&t.brotli!==void 0?t.brotli:e?void 0:!1;let i=t.file&&(t.file.endsWith(".tar.zst")||t.file.endsWith(".tzst"));this.zstd=!(t.gzip||t.brotli)&&t.zstd!==void 0?t.zstd:i?!0:void 0,this.on("end",()=>this[Zs]()),typeof t.onwarn=="function"&&this.on("warn",t.onwarn),typeof t.onReadEntry=="function"&&this.on("entry",t.onReadEntry)}warn(t,e,i={}){Lt(this,t,e,i)}[Gs](t,e){this[Dt]===void 0&&(this[Dt]=!1);let i;try{i=new F(t,e,this[V],this[ae])}catch(r){return this.warn("TAR_ENTRY_INVALID",r)}if(i.nullBlock)this[je]?(this[Qe]=!0,this[B]==="begin"&&(this[B]="header"),this[At]("eof")):(this[je]=!0,this[At]("nullBlock"));else if(this[je]=!1,!i.cksumValid)this.warn("TAR_ENTRY_INVALID","checksum failure",{header:i});else if(!i.path)this.warn("TAR_ENTRY_INVALID","path is required",{header:i});else{let r=i.type;if(/^(Symbolic)?Link$/.test(r)&&!i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath required",{header:i});else if(!/^(Symbolic)?Link$/.test(r)&&!/^(Global)?ExtendedHeader$/.test(r)&&i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath forbidden",{header:i});else{let n=this[Nt]=new Yt(i,this[V],this[ae]);if(!this[Dt])if(n.remain){let o=()=>{n.invalid||(this[Dt]=!0)};n.on("end",o)}else this[Dt]=!0;n.meta?n.size>this.maxMetaEntrySize?(n.ignore=!0,this[At]("ignoredEntry",n),this[B]="ignore",n.resume()):n.size>0&&(this[ft]="",n.on("data",o=>this[ft]+=o),this[B]="meta"):(this[V]=void 0,n.ignore=n.ignore||!this.filter(n.path,n),n.ignore?(this[At]("ignoredEntry",n),this[B]=n.remain?"ignore":"header",n.resume()):(n.remain?this[B]="body":(this[B]="header",n.end()),this[et]?this[it].push(n):(this[it].push(n),this[Ui]())))}}}[Zs](){queueMicrotask(()=>this.emit("close"))}[Us](t){let e=!0;if(!t)this[et]=void 0,e=!1;else if(Array.isArray(t)){let[i,...r]=t;this.emit(i,...r)}else this[et]=t,this.emit("entry",t),t.emittedEnd||(t.on("end",()=>this[Ui]()),e=!1);return e}[Ui](){do;while(this[Us](this[it].shift()));if(this[it].length===0){let t=this[et];!t||t.flowing||t.size===t.remain?this[Kt]||this.emit("drain"):t.once("drain",()=>this.emit("drain"))}}[Wi](t,e){let i=this[Nt];if(!i)throw new Error("attempt to consume body without entry??");let r=i.blockRemain??0,n=r>=t.length&&e===0?t:t.subarray(e,e+r);return i.write(n),i.blockRemain||(this[B]="header",this[Nt]=void 0,i.end()),n.length}[Ws](t,e){let i=this[Nt],r=this[Wi](t,e);return!this[Nt]&&i&&this[Hs](i),r}[At](t,e,i){this[it].length===0&&!this[et]?this.emit(t,e,i):this[it].push([t,e,i])}[Hs](t){switch(this[At]("meta",this[ft]),t.type){case"ExtendedHeader":case"OldExtendedHeader":this[V]=ct.parse(this[ft],this[V],!1);break;case"GlobalExtendedHeader":this[ae]=ct.parse(this[ft],this[ae],!0);break;case"NextFileHasLongPath":case"OldGnuLongPath":{let e=this[V]??Object.create(null);this[V]=e,e.path=this[ft].replace(/\0.*/,"");break}case"NextFileHasLongLinkpath":{let e=this[V]||Object.create(null);this[V]=e,e.linkpath=this[ft].replace(/\0.*/,"");break}default:throw new Error("unknown meta: "+t.type)}}abort(t){this[ut]=!0,this.emit("abort",t),this.warn("TAR_ABORT",t,{recoverable:!1})}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this[ut])return i?.(),!1;if((this[y]===void 0||this.brotli===void 0&&this[y]===!1)&&t){if(this[p]&&(t=Buffer.concat([this[p],t]),this[p]=void 0),t.length<On)return this[p]=t,i?.(),!0;for(let a=0;this[y]===void 0&&a<Zi.length;a++)t[a]!==Zi[a]&&(this[y]=!1);let o=!1;if(this[y]===!1&&this.zstd!==!1){o=!0;for(let a=0;a<Yi.length;a++)if(t[a]!==Yi[a]){o=!1;break}}let h=this.brotli===void 0&&!o;if(this[y]===!1&&h)if(t.length<512)if(this[dt])this.brotli=!0;else return this[p]=t,i?.(),!0;else try{new F(t.subarray(0,512)),this.brotli=!1}catch{this.brotli=!0}if(this[y]===void 0||this[y]===!1&&(this.brotli||o)){let a=this[dt];this[dt]=!1,this[y]=this[y]===void 0?new ze({}):o?new Ye({}):new We({}),this[y].on("data",c=>this[Ve](c)),this[y].on("error",c=>this.abort(c)),this[y].on("end",()=>{this[dt]=!0,this[Ve]()}),this[Kt]=!0;let l=!!this[y][a?"end":"write"](t);return this[Kt]=!1,i?.(),l}}this[Kt]=!0,this[y]?this[y].write(t):this[Ve](t),this[Kt]=!1;let n=this[it].length>0?!1:this[et]?this[et].flowing:!0;return!n&&this[it].length===0&&this[et]?.once("drain",()=>this.emit("drain")),i?.(),n}[Gi](t){t&&!this[ut]&&(this[p]=this[p]?Buffer.concat([this[p],t]):t)}[Xe](){if(this[dt]&&!this[Hi]&&!this[ut]&&!this[le]){this[Hi]=!0;let t=this[Nt];if(t&&t.blockRemain){let e=this[p]?this[p].length:0;this.warn("TAR_BAD_ARCHIVE",`Truncated input (needed ${t.blockRemain} more bytes, only ${e} available)`,{entry:t}),this[p]&&t.write(this[p]),t.end()}this[At](qe)}}[Ve](t){if(this[le]&&t)this[Gi](t);else if(!t&&!this[p])this[Xe]();else if(t){if(this[le]=!0,this[p]){this[Gi](t);let e=this[p];this[p]=void 0,this[$e](e)}else this[$e](t);for(;this[p]&&this[p]?.length>=512&&!this[ut]&&!this[Qe];){let e=this[p];this[p]=void 0,this[$e](e)}this[le]=!1}(!this[p]||this[dt])&&this[Xe]()}[$e](t){let e=0,i=t.length;for(;e+512<=i&&!this[ut]&&!this[Qe];)switch(this[B]){case"begin":case"header":this[Gs](t,e),e+=512;break;case"ignore":case"body":e+=this[Wi](t,e);break;case"meta":e+=this[Ws](t,e);break;default:throw new Error("invalid state: "+this[B])}e<i&&(this[p]=this[p]?Buffer.concat([t.subarray(e),this[p]]):t.subarray(e))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e)),i&&this.once("finish",i),this[ut]||(this[y]?(t&&this[y].write(t),this[y].end()):(this[dt]=!0,(this.brotli===void 0||this.zstd===void 0)&&(t=t||Buffer.alloc(0)),t&&this.write(t),this[Xe]())),this}};var mt=s=>{let t=s.length-1,e=-1;for(;t>-1&&s.charAt(t)==="/";)e=t,t--;return e===-1?s:s.slice(0,e)};var Nn=s=>{let t=s.onReadEntry;s.onReadEntry=t?e=>{t(e),e.resume()}:e=>e.resume()},Ki=(s,t)=>{let e=new Map(t.map(n=>[mt(n),!0])),i=s.filter,r=(n,o="")=>{let h=o||Ln(n).root||".",a;if(n===h)a=!1;else{let l=e.get(n);a=l!==void 0?l:r(xn(n),h)}return e.set(n,a),a};s.filter=i?(n,o)=>i(n,o)&&r(mt(n)):n=>r(mt(n))},An=s=>{let t=new st(s),e=s.file,i;try{i=Vt.openSync(e,"r");let r=Vt.fstatSync(i),n=s.maxReadSize||16*1024*1024;if(r.size<n){let o=Buffer.allocUnsafe(r.size),h=Vt.readSync(i,o,0,r.size,0);t.end(h===o.byteLength?o:o.subarray(0,h))}else{let o=0,h=Buffer.allocUnsafe(n);for(;o<r.size;){let a=Vt.readSync(i,h,0,n,o);if(a===0)break;o+=a,t.write(h.subarray(0,a))}t.end()}}finally{if(typeof i=="number")try{Vt.closeSync(i)}catch{}}},Dn=(s,t)=>{let e=new st(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("end",o),Vt.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},It=K(An,Dn,s=>new st(s),s=>new st(s),(s,t)=>{t?.length&&Ki(s,t),s.noResume||Nn(s)});import fi from"fs";import $ from"fs";import $s from"path";var Vi=(s,t,e)=>(s&=4095,e&&(s=(s|384)&-19),t&&(s&256&&(s|=64),s&32&&(s|=8),s&4&&(s|=1)),s);import{win32 as In}from"node:path";var{isAbsolute:Cn,parse:Ys}=In,ce=s=>{let t="",e=Ys(s);for(;Cn(s)||e.root;){let i=s.charAt(0)==="/"&&s.slice(0,4)!=="//?/"?"/":e.root;s=s.slice(i.length),t+=i,e=Ys(s)}return[t,s]};var Je=["|","<",">","?",":"],$i=Je.map(s=>String.fromCodePoint(61440+Number(s.codePointAt(0)))),Fn=new Map(Je.map((s,t)=>[s,$i[t]])),kn=new Map($i.map((s,t)=>[s,Je[t]])),Xi=s=>Je.reduce((t,e)=>t.split(e).join(Fn.get(e)),s),Ks=s=>$i.reduce((t,e)=>t.split(e).join(kn.get(e)),s);var Js=(s,t)=>t?(s=f(s).replace(/^\.(\/|$)/,""),mt(t)+"/"+s):f(s),vn=16*1024*1024,Xs=Symbol("process"),qs=Symbol("file"),js=Symbol("directory"),ji=Symbol("symlink"),Qs=Symbol("hardlink"),fe=Symbol("header"),ti=Symbol("read"),Qi=Symbol("lstat"),ei=Symbol("onlstat"),Ji=Symbol("onread"),ts=Symbol("onreadlink"),es=Symbol("openfile"),is=Symbol("onopenfile"),pt=Symbol("close"),ii=Symbol("mode"),ss=Symbol("awaitDrain"),qi=Symbol("ondrain"),X=Symbol("prefix"),de=class extends D{path;portable;myuid=process.getuid&&process.getuid()||0;myuser=process.env.USER||"";maxReadSize;linkCache;statCache;preservePaths;cwd;strict;mtime;noPax;noMtime;prefix;fd;blockLen=0;blockRemain=0;buf;pos=0;remain=0;length=0;offset=0;win32;absolute;header;type;linkpath;stat;onWriteEntry;#t=!1;constructor(t,e={}){let i=re(e);super(),this.path=f(t),this.portable=!!i.portable,this.maxReadSize=i.maxReadSize||vn,this.linkCache=i.linkCache||new Map,this.statCache=i.statCache||new Map,this.preservePaths=!!i.preservePaths,this.cwd=f(i.cwd||process.cwd()),this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.mtime=i.mtime,this.prefix=i.prefix?f(i.prefix):void 0,this.onWriteEntry=i.onWriteEntry,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let r=!1;if(!this.preservePaths){let[o,h]=ce(this.path);o&&typeof h=="string"&&(this.path=h,r=o)}this.win32=!!i.win32||process.platform==="win32",this.win32&&(this.path=Ks(this.path.replaceAll(/\\/g,"/")),t=t.replaceAll(/\\/g,"/")),this.absolute=f(i.absolute||$s.resolve(this.cwd,t)),this.path===""&&(this.path="./"),r&&this.warn("TAR_ENTRY_INFO",`stripping ${r} from absolute path`,{entry:this,path:r+this.path});let n=this.statCache.get(this.absolute);n?this[ei](n):this[Qi]()}warn(t,e,i={}){return Lt(this,t,e,i)}emit(t,...e){return t==="error"&&(this.#t=!0),super.emit(t,...e)}[Qi](){$.lstat(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[ei](e)})}[ei](t){this.statCache.set(this.absolute,t),this.stat=t,t.isFile()||(t.size=0),this.type=Mn(t),this.emit("stat",t),this[Xs]()}[Xs](){switch(this.type){case"File":return this[qs]();case"Directory":return this[js]();case"SymbolicLink":return this[ji]();default:return this.end()}}[ii](t){return Vi(t,this.type==="Directory",this.portable)}[X](t){return Js(t,this.prefix)}[fe](){if(!this.stat)throw new Error("cannot write header before stat");this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.onWriteEntry?.(this),this.header=new F({path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,mode:this[ii](this.stat.mode),uid:this.portable?void 0:this.stat.uid,gid:this.portable?void 0:this.stat.gid,size:this.stat.size,mtime:this.noMtime?void 0:this.mtime||this.stat.mtime,type:this.type==="Unsupported"?void 0:this.type,uname:this.portable?void 0:this.stat.uid===this.myuid?this.myuser:"",atime:this.portable?void 0:this.stat.atime,ctime:this.portable?void 0:this.stat.ctime}),this.header.encode()&&!this.noPax&&super.write(new ct({atime:this.portable?void 0:this.header.atime,ctime:this.portable?void 0:this.header.ctime,gid:this.portable?void 0:this.header.gid,mtime:this.noMtime?void 0:this.mtime||this.header.mtime,path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,size:this.header.size,uid:this.portable?void 0:this.header.uid,uname:this.portable?void 0:this.header.uname,dev:this.portable?void 0:this.stat.dev,ino:this.portable?void 0:this.stat.ino,nlink:this.portable?void 0:this.stat.nlink}).encode());let t=this.header?.block;if(!t)throw new Error("failed to encode header");super.write(t)}[js](){if(!this.stat)throw new Error("cannot create directory entry without stat");this.path.slice(-1)!=="/"&&(this.path+="/"),this.stat.size=0,this[fe](),this.end()}[ji](){$.readlink(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[ts](e)})}[ts](t){this.linkpath=f(t),this[fe](),this.end()}[Qs](t){if(!this.stat)throw new Error("cannot create link entry without stat");this.type="Link",this.linkpath=f($s.relative(this.cwd,t)),this.stat.size=0,this[fe](),this.end()}[qs](){if(!this.stat)throw new Error("cannot create file entry without stat");if(this.stat.nlink>1){let t=`${this.stat.dev}:${this.stat.ino}`,e=this.linkCache.get(t);if(e?.indexOf(this.cwd)===0)return this[Qs](e);this.linkCache.set(t,this.absolute)}if(this[fe](),this.stat.size===0)return this.end();this[es]()}[es](){$.open(this.absolute,"r",(t,e)=>{if(t)return this.emit("error",t);this[is](e)})}[is](t){if(this.fd=t,this.#t)return this[pt]();if(!this.stat)throw new Error("should stat before calling onopenfile");this.blockLen=512*Math.ceil(this.stat.size/512),this.blockRemain=this.blockLen;let e=Math.min(this.blockLen,this.maxReadSize);this.buf=Buffer.allocUnsafe(e),this.offset=0,this.pos=0,this.remain=this.stat.size,this.length=this.buf.length,this[ti]()}[ti](){let{fd:t,buf:e,offset:i,length:r,pos:n}=this;if(t===void 0||e===void 0)throw new Error("cannot read file without first opening");$.read(t,e,i,r,n,(o,h)=>{if(o)return this[pt](()=>this.emit("error",o));this[Ji](h)})}[pt](t=()=>{}){this.fd!==void 0&&$.close(this.fd,t)}[Ji](t){if(t<=0&&this.remain>0){let r=Object.assign(new Error("encountered unexpected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(t>this.remain){let r=Object.assign(new Error("did not encounter expected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(!this.buf)throw new Error("should have created buffer prior to reading");if(t===this.remain)for(let r=t;r<this.length&&t<this.blockRemain;r++)this.buf[r+this.offset]=0,t++,this.remain++;let e=this.offset===0&&t===this.buf.length?this.buf:this.buf.subarray(this.offset,this.offset+t);this.write(e)?this[qi]():this[ss](()=>this[qi]())}[ss](t){this.once("drain",t)}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this.blockRemain<t.length){let r=Object.assign(new Error("writing more data than expected"),{path:this.absolute});return this.emit("error",r)}return this.remain-=t.length,this.blockRemain-=t.length,this.pos+=t.length,this.offset+=t.length,super.write(t,null,i)}[qi](){if(!this.remain)return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),this[pt](t=>t?this.emit("error",t):this.end());if(!this.buf)throw new Error("buffer lost somehow in ONDRAIN");this.offset>=this.length&&(this.buf=Buffer.allocUnsafe(Math.min(this.blockRemain,this.buf.length)),this.offset=0),this.length=this.buf.length-this.offset,this[ti]()}},si=class extends de{sync=!0;[Qi](){this[ei]($.lstatSync(this.absolute))}[ji](){this[ts]($.readlinkSync(this.absolute))}[es](){this[is]($.openSync(this.absolute,"r"))}[ti](){let t=!0;try{let{fd:e,buf:i,offset:r,length:n,pos:o}=this;if(e===void 0||i===void 0)throw new Error("fd and buf must be set in READ method");let h=$.readSync(e,i,r,n,o);this[Ji](h),t=!1}finally{if(t)try{this[pt](()=>{})}catch{}}}[ss](t){t()}[pt](t=()=>{}){this.fd!==void 0&&$.closeSync(this.fd),t()}},ri=class extends D{blockLen=0;blockRemain=0;buf=0;pos=0;remain=0;length=0;preservePaths;portable;strict;noPax;noMtime;readEntry;type;prefix;path;mode;uid;gid;uname;gname;header;mtime;atime;ctime;linkpath;size;onWriteEntry;warn(t,e,i={}){return Lt(this,t,e,i)}constructor(t,e={}){let i=re(e);super(),this.preservePaths=!!i.preservePaths,this.portable=!!i.portable,this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.onWriteEntry=i.onWriteEntry,this.readEntry=t;let{type:r}=t;if(r==="Unsupported")throw new Error("writing entry that should be ignored");this.type=r,this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.prefix=i.prefix,this.path=f(t.path),this.mode=t.mode!==void 0?this[ii](t.mode):void 0,this.uid=this.portable?void 0:t.uid,this.gid=this.portable?void 0:t.gid,this.uname=this.portable?void 0:t.uname,this.gname=this.portable?void 0:t.gname,this.size=t.size,this.mtime=this.noMtime?void 0:i.mtime||t.mtime,this.atime=this.portable?void 0:t.atime,this.ctime=this.portable?void 0:t.ctime,this.linkpath=t.linkpath!==void 0?f(t.linkpath):void 0,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let n=!1;if(!this.preservePaths){let[h,a]=ce(this.path);h&&typeof a=="string"&&(this.path=a,n=h)}this.remain=t.size,this.blockRemain=t.startBlockSize,this.onWriteEntry?.(this),this.header=new F({path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,mode:this.mode,uid:this.portable?void 0:this.uid,gid:this.portable?void 0:this.gid,size:this.size,mtime:this.noMtime?void 0:this.mtime,type:this.type,uname:this.portable?void 0:this.uname,atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime}),n&&this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute path`,{entry:this,path:n+this.path}),this.header.encode()&&!this.noPax&&super.write(new ct({atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime,gid:this.portable?void 0:this.gid,mtime:this.noMtime?void 0:this.mtime,path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,size:this.size,uid:this.portable?void 0:this.uid,uname:this.portable?void 0:this.uname,dev:this.portable?void 0:this.readEntry.dev,ino:this.portable?void 0:this.readEntry.ino,nlink:this.portable?void 0:this.readEntry.nlink}).encode());let o=this.header?.block;if(!o)throw new Error("failed to encode header");super.write(o),t.pipe(this)}[X](t){return Js(t,this.prefix)}[ii](t){return Vi(t,this.type==="Directory",this.portable)}write(t,e,i){typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8"));let r=t.length;if(r>this.blockRemain)throw new Error("writing more to entry than is appropriate");return this.blockRemain-=r,super.write(t,i)}end(t,e,i){return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e??"utf8")),i&&this.once("finish",i),t?super.end(t,i):super.end(i),this}},Mn=s=>s.isFile()?"File":s.isDirectory()?"Directory":s.isSymbolicLink()?"SymbolicLink":"Unsupported";var ni=class s{tail;head;length=0;static create(t=[]){return new s(t)}constructor(t=[]){for(let e of t)this.push(e)}*[Symbol.iterator](){for(let t=this.head;t;t=t.next)yield t.value}removeNode(t){if(t.list!==this)throw new Error("removing node which does not belong to this list");let e=t.next,i=t.prev;return e&&(e.prev=i),i&&(i.next=e),t===this.head&&(this.head=e),t===this.tail&&(this.tail=i),this.length--,t.next=void 0,t.prev=void 0,t.list=void 0,e}unshiftNode(t){if(t===this.head)return;t.list&&t.list.removeNode(t);let e=this.head;t.list=this,t.next=e,e&&(e.prev=t),this.head=t,this.tail||(this.tail=t),this.length++}pushNode(t){if(t===this.tail)return;t.list&&t.list.removeNode(t);let e=this.tail;t.list=this,t.prev=e,e&&(e.next=t),this.tail=t,this.head||(this.head=t),this.length++}push(...t){for(let e=0,i=t.length;e<i;e++)Pn(this,t[e]);return this.length}unshift(...t){for(var e=0,i=t.length;e<i;e++)zn(this,t[e]);return this.length}pop(){if(!this.tail)return;let t=this.tail.value,e=this.tail;return this.tail=this.tail.prev,this.tail?this.tail.next=void 0:this.head=void 0,e.list=void 0,this.length--,t}shift(){if(!this.head)return;let t=this.head.value,e=this.head;return this.head=this.head.next,this.head?this.head.prev=void 0:this.tail=void 0,e.list=void 0,this.length--,t}forEach(t,e){e=e||this;for(let i=this.head,r=0;i;r++)t.call(e,i.value,r,this),i=i.next}forEachReverse(t,e){e=e||this;for(let i=this.tail,r=this.length-1;i;r--)t.call(e,i.value,r,this),i=i.prev}get(t){let e=0,i=this.head;for(;i&&e<t;e++)i=i.next;if(e===t&&i)return i.value}getReverse(t){let e=0,i=this.tail;for(;i&&e<t;e++)i=i.prev;if(e===t&&i)return i.value}map(t,e){e=e||this;let i=new s;for(let r=this.head;r;)i.push(t.call(e,r.value,this)),r=r.next;return i}mapReverse(t,e){e=e||this;var i=new s;for(let r=this.tail;r;)i.push(t.call(e,r.value,this)),r=r.prev;return i}reduce(t,e){let i,r=this.head;if(arguments.length>1)i=e;else if(this.head)r=this.head.next,i=this.head.value;else throw new TypeError("Reduce of empty list with no initial value");for(var n=0;r;n++)i=t(i,r.value,n),r=r.next;return i}reduceReverse(t,e){let i,r=this.tail;if(arguments.length>1)i=e;else if(this.tail)r=this.tail.prev,i=this.tail.value;else throw new TypeError("Reduce of empty list with no initial value");for(let n=this.length-1;r;n--)i=t(i,r.value,n),r=r.prev;return i}toArray(){let t=new Array(this.length);for(let e=0,i=this.head;i;e++)t[e]=i.value,i=i.next;return t}toArrayReverse(){let t=new Array(this.length);for(let e=0,i=this.tail;i;e++)t[e]=i.value,i=i.prev;return t}slice(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.head,n=0;for(n=0;r&&n<t;n++)r=r.next;for(;r&&n<e;n++,r=r.next)i.push(r.value);return i}sliceReverse(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.length,n=this.tail;for(;n&&r>e;r--)n=n.prev;for(;n&&r>t;r--,n=n.prev)i.push(n.value);return i}splice(t,e=0,...i){t>this.length&&(t=this.length-1),t<0&&(t=this.length+t);let r=this.head;for(let o=0;r&&o<t;o++)r=r.next;let n=[];for(let o=0;r&&o<e;o++)n.push(r.value),r=this.removeNode(r);r?r!==this.tail&&(r=r.prev):r=this.tail;for(let o of i)r=Bn(this,r,o);return n}reverse(){let t=this.head,e=this.tail;for(let i=t;i;i=i.prev){let r=i.prev;i.prev=i.next,i.next=r}return this.head=e,this.tail=t,this}};function Bn(s,t,e){let i=t,r=t?t.next:s.head,n=new ue(e,i,r,s);return n.next===void 0&&(s.tail=n),n.prev===void 0&&(s.head=n),s.length++,n}function Pn(s,t){s.tail=new ue(t,s.tail,void 0,s),s.head||(s.head=s.tail),s.length++}function zn(s,t){s.head=new ue(t,void 0,s.head,s),s.tail||(s.tail=s.head),s.length++}var ue=class{list;next;prev;value;constructor(t,e,i,r){this.list=r,this.value=t,e?(e.next=this,this.prev=e):this.prev=void 0,i?(i.prev=this,this.next=i):this.next=void 0}};import sr from"path";var di=class{path;absolute;entry;stat;readdir;pending=!1;ignore=!1;piped=!1;constructor(t,e){this.path=t||"./",this.absolute=e}},tr=Buffer.alloc(1024),oi=Symbol("onStat"),me=Symbol("ended"),W=Symbol("queue"),Ct=Symbol("current"),Ft=Symbol("process"),pe=Symbol("processing"),rs=Symbol("processJob"),G=Symbol("jobs"),ns=Symbol("jobDone"),hi=Symbol("addFSEntry"),er=Symbol("addTarEntry"),as=Symbol("stat"),ls=Symbol("readdir"),ai=Symbol("onreaddir"),li=Symbol("pipe"),ir=Symbol("entry"),os=Symbol("entryOpt"),ci=Symbol("writeEntryClass"),rr=Symbol("write"),hs=Symbol("ondrain"),Et=class extends D{sync=!1;opt;cwd;maxReadSize;preservePaths;strict;noPax;prefix;linkCache;statCache;file;portable;zip;readdirCache;noDirRecurse;follow;noMtime;mtime;filter;jobs;[ci];onWriteEntry;[W];[G]=0;[pe]=!1;[me]=!1;constructor(t={}){if(super(),this.opt=t,this.file=t.file||"",this.cwd=t.cwd||process.cwd(),this.maxReadSize=t.maxReadSize,this.preservePaths=!!t.preservePaths,this.strict=!!t.strict,this.noPax=!!t.noPax,this.prefix=f(t.prefix||""),this.linkCache=t.linkCache||new Map,this.statCache=t.statCache||new Map,this.readdirCache=t.readdirCache||new Map,this.onWriteEntry=t.onWriteEntry,this[ci]=de,typeof t.onwarn=="function"&&this.on("warn",t.onwarn),this.portable=!!t.portable,t.gzip||t.brotli||t.zstd){if((t.gzip?1:0)+(t.brotli?1:0)+(t.zstd?1:0)>1)throw new TypeError("gzip, brotli, zstd are mutually exclusive");if(t.gzip&&(typeof t.gzip!="object"&&(t.gzip={}),this.portable&&(t.gzip.portable=!0),this.zip=new Pe(t.gzip)),t.brotli&&(typeof t.brotli!="object"&&(t.brotli={}),this.zip=new He(t.brotli)),t.zstd&&(typeof t.zstd!="object"&&(t.zstd={}),this.zip=new Ze(t.zstd)),!this.zip)throw new Error("impossible");let e=this.zip;e.on("data",i=>super.write(i)),e.on("end",()=>super.end()),e.on("drain",()=>this[hs]()),this.on("resume",()=>e.resume())}else this.on("drain",this[hs]);this.noDirRecurse=!!t.noDirRecurse,this.follow=!!t.follow,this.noMtime=!!t.noMtime,t.mtime&&(this.mtime=t.mtime),this.filter=typeof t.filter=="function"?t.filter:()=>!0,this[W]=new ni,this[G]=0,this.jobs=Number(t.jobs)||4,this[pe]=!1,this[me]=!1}[rr](t){return super.write(t)}add(t){return this.write(t),this}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&this.add(t),this[me]=!0,this[Ft](),i&&i(),this}write(t){if(this[me])throw new Error("write after end");return t instanceof Yt?this[er](t):this[hi](t),this.flowing}[er](t){let e=f(sr.resolve(this.cwd,t.path));if(!this.filter(t.path,t))t.resume();else{let i=new di(t.path,e);i.entry=new ri(t,this[os](i)),i.entry.on("end",()=>this[ns](i)),this[G]+=1,this[W].push(i)}this[Ft]()}[hi](t){let e=f(sr.resolve(this.cwd,t));this[W].push(new di(t,e)),this[Ft]()}[as](t){t.pending=!0,this[G]+=1;let e=this.follow?"stat":"lstat";fi[e](t.absolute,(i,r)=>{t.pending=!1,this[G]-=1,i?this.emit("error",i):this[oi](t,r)})}[oi](t,e){this.statCache.set(t.absolute,e),t.stat=e,this.filter(t.path,e)?e.isFile()&&e.nlink>1&&t===this[Ct]&&!this.linkCache.get(`${e.dev}:${e.ino}`)&&!this.sync&&this[rs](t):t.ignore=!0,this[Ft]()}[ls](t){t.pending=!0,this[G]+=1,fi.readdir(t.absolute,(e,i)=>{if(t.pending=!1,this[G]-=1,e)return this.emit("error",e);this[ai](t,i)})}[ai](t,e){this.readdirCache.set(t.absolute,e),t.readdir=e,this[Ft]()}[Ft](){if(!this[pe]){this[pe]=!0;for(let t=this[W].head;t&&this[G]<this.jobs;t=t.next)if(this[rs](t.value),t.value.ignore){let e=t.next;this[W].removeNode(t),t.next=e}this[pe]=!1,this[me]&&this[W].length===0&&this[G]===0&&(this.zip?this.zip.end(tr):(super.write(tr),super.end()))}}get[Ct](){return this[W]&&this[W].head&&this[W].head.value}[ns](t){this[W].shift(),this[G]-=1,this[Ft]()}[rs](t){if(!t.pending){if(t.entry){t===this[Ct]&&!t.piped&&this[li](t);return}if(!t.stat){let e=this.statCache.get(t.absolute);e?this[oi](t,e):this[as](t)}if(t.stat&&!t.ignore){if(!this.noDirRecurse&&t.stat.isDirectory()&&!t.readdir){let e=this.readdirCache.get(t.absolute);if(e?this[ai](t,e):this[ls](t),!t.readdir)return}if(t.entry=this[ir](t),!t.entry){t.ignore=!0;return}t===this[Ct]&&!t.piped&&this[li](t)}}}[os](t){return{onwarn:(e,i,r)=>this.warn(e,i,r),noPax:this.noPax,cwd:this.cwd,absolute:t.absolute,preservePaths:this.preservePaths,maxReadSize:this.maxReadSize,strict:this.strict,portable:this.portable,linkCache:this.linkCache,statCache:this.statCache,noMtime:this.noMtime,mtime:this.mtime,prefix:this.prefix,onWriteEntry:this.onWriteEntry}}[ir](t){this[G]+=1;try{return new this[ci](t.path,this[os](t)).on("end",()=>this[ns](t)).on("error",i=>this.emit("error",i))}catch(e){this.emit("error",e)}}[hs](){this[Ct]&&this[Ct].entry&&this[Ct].entry.resume()}[li](t){t.piped=!0,t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[hi](o+r)});let e=t.entry,i=this.zip;if(!e)throw new Error("cannot pipe without source");i?e.on("data",r=>{i.write(r)||e.pause()}):e.on("data",r=>{super.write(r)||e.pause()})}pause(){return this.zip&&this.zip.pause(),super.pause()}warn(t,e,i={}){Lt(this,t,e,i)}},kt=class extends Et{sync=!0;constructor(t){super(t),this[ci]=si}pause(){}resume(){}[as](t){let e=this.follow?"statSync":"lstatSync";this[oi](t,fi[e](t.absolute))}[ls](t){this[ai](t,fi.readdirSync(t.absolute))}[li](t){let e=t.entry,i=this.zip;if(t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[hi](o+r)}),!e)throw new Error("Cannot pipe without source");i?e.on("data",r=>{i.write(r)}):e.on("data",r=>{super[rr](r)})}};var Un=(s,t)=>{let e=new kt(s),i=new Wt(s.file,{mode:s.mode||438});e.pipe(i),or(e,t)},Hn=(s,t)=>{let e=new Et(s),i=new tt(s.file,{mode:s.mode||438});e.pipe(i);let r=new Promise((n,o)=>{i.on("error",o),i.on("close",n),e.on("error",o)});return hr(e,t).catch(n=>e.emit("error",n)),r},or=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?It({file:nr.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},hr=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await It({file:nr.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>{s.add(i)}}):s.add(e);s.end()},Wn=(s,t)=>{let e=new kt(s);return or(e,t),e},Gn=(s,t)=>{let e=new Et(s);return hr(e,t).catch(i=>e.emit("error",i)),e},Zn=K(Un,Hn,Wn,Gn,(s,t)=>{if(!t?.length)throw new TypeError("no paths specified to add to archive")});import Cr from"node:fs";import so from"node:assert";import{randomBytes as Ir}from"node:crypto";import u from"node:fs";import R from"node:path";import cr from"fs";var Yn=process.env.__FAKE_PLATFORM__||process.platform,fr=Yn==="win32",{O_CREAT:dr,O_NOFOLLOW:ar,O_TRUNC:ur,O_WRONLY:mr}=cr.constants,pr=Number(process.env.__FAKE_FS_O_FILENAME__)||cr.constants.UV_FS_O_FILEMAP||0,Kn=fr&&!!pr,Vn=512*1024,$n=pr|ur|dr|mr,lr=!fr&&typeof ar=="number"?ar|ur|dr|mr:null,cs=lr!==null?()=>lr:Kn?s=>s<Vn?$n:"w":()=>"w";import mi from"node:fs";import Ee from"node:path";var fs=(s,t,e)=>{try{return mi.lchownSync(s,t,e)}catch(i){if(i?.code!=="ENOENT")throw i}},ui=(s,t,e,i)=>{mi.lchown(s,t,e,r=>{i(r&&r?.code!=="ENOENT"?r:null)})},Xn=(s,t,e,i,r)=>{if(t.isDirectory())ds(Ee.resolve(s,t.name),e,i,n=>{if(n)return r(n);let o=Ee.resolve(s,t.name);ui(o,e,i,r)});else{let n=Ee.resolve(s,t.name);ui(n,e,i,r)}},ds=(s,t,e,i)=>{mi.readdir(s,{withFileTypes:!0},(r,n)=>{if(r){if(r.code==="ENOENT")return i();if(r.code!=="ENOTDIR"&&r.code!=="ENOTSUP")return i(r)}if(r||!n.length)return ui(s,t,e,i);let o=n.length,h=null,a=l=>{if(!h){if(l)return i(h=l);if(--o===0)return ui(s,t,e,i)}};for(let l of n)Xn(s,l,t,e,a)})},qn=(s,t,e,i)=>{t.isDirectory()&&us(Ee.resolve(s,t.name),e,i),fs(Ee.resolve(s,t.name),e,i)},us=(s,t,e)=>{let i;try{i=mi.readdirSync(s,{withFileTypes:!0})}catch(r){let n=r;if(n?.code==="ENOENT")return;if(n?.code==="ENOTDIR"||n?.code==="ENOTSUP")return fs(s,t,e);throw n}for(let r of i)qn(s,r,t,e);return fs(s,t,e)};import k from"node:fs";import jn from"node:fs/promises";import pi from"node:path";var we=class extends Error{path;code;syscall="chdir";constructor(t,e){super(`${e}: Cannot cd into '${t}'`),this.path=t,this.code=e}get name(){return"CwdError"}};var wt=class extends Error{path;symlink;syscall="symlink";code="TAR_SYMLINK_ERROR";constructor(t,e){super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"),this.symlink=t,this.path=e}get name(){return"SymlinkError"}};var Qn=(s,t)=>{k.stat(s,(e,i)=>{(e||!i.isDirectory())&&(e=new we(s,e?.code||"ENOTDIR")),t(e)})},Er=(s,t,e)=>{s=f(s);let i=t.umask??18,r=t.mode|448,n=(r&i)!==0,o=t.uid,h=t.gid,a=typeof o=="number"&&typeof h=="number"&&(o!==t.processUid||h!==t.processGid),l=t.preserve,c=t.unlink,d=f(t.cwd),S=(E,x)=>{E?e(E):x&&a?ds(x,o,h,xe=>S(xe)):n?k.chmod(s,r,e):e()};if(s===d)return Qn(s,S);if(l)return jn.mkdir(s,{mode:r,recursive:!0}).then(E=>S(null,E??void 0),S);let N=f(pi.relative(d,s)).split("/");ms(d,N,r,c,d,void 0,S)},ms=(s,t,e,i,r,n,o)=>{if(t.length===0)return o(null,n);let h=t.shift(),a=f(pi.resolve(s+"/"+h));k.mkdir(a,e,wr(a,t,e,i,r,n,o))},wr=(s,t,e,i,r,n,o)=>h=>{h?k.lstat(s,(a,l)=>{if(a)a.path=a.path&&f(a.path),o(a);else if(l.isDirectory())ms(s,t,e,i,r,n,o);else if(i)k.unlink(s,c=>{if(c)return o(c);k.mkdir(s,e,wr(s,t,e,i,r,n,o))});else{if(l.isSymbolicLink())return o(new wt(s,s+"/"+t.join("/")));o(h)}}):(n=n||s,ms(s,t,e,i,r,n,o))},Jn=s=>{let t=!1,e;try{t=k.statSync(s).isDirectory()}catch(i){e=i?.code}finally{if(!t)throw new we(s,e??"ENOTDIR")}},Sr=(s,t)=>{s=f(s);let e=t.umask??18,i=t.mode|448,r=(i&e)!==0,n=t.uid,o=t.gid,h=typeof n=="number"&&typeof o=="number"&&(n!==t.processUid||o!==t.processGid),a=t.preserve,l=t.unlink,c=f(t.cwd),d=E=>{E&&h&&us(E,n,o),r&&k.chmodSync(s,i)};if(s===c)return Jn(c),d();if(a)return d(k.mkdirSync(s,{mode:i,recursive:!0})??void 0);let T=f(pi.relative(c,s)).split("/"),N;for(let E=T.shift(),x=c;E&&(x+="/"+E);E=T.shift()){x=f(pi.resolve(x));try{k.mkdirSync(x,i),N=N||x}catch{let xe=k.lstatSync(x);if(xe.isDirectory())continue;if(l){k.unlinkSync(x),k.mkdirSync(x,i),N=N||x;continue}else if(xe.isSymbolicLink())return new wt(x,x+"/"+T.join("/"))}}return d(N)};import{join as br}from"node:path";var ps=Object.create(null),yr=1e4,$t=new Set,Rr=s=>{$t.has(s)?$t.delete(s):ps[s]=s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"),$t.add(s);let t=ps[s],e=$t.size-yr;if(e>yr/10){for(let i of $t)if($t.delete(i),delete ps[i],--e<=0)break}return t};var to=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,eo=to==="win32",io=s=>s.split("/").slice(0,-1).reduce((e,i)=>{let r=e.at(-1);return r!==void 0&&(i=br(r,i)),e.push(i||"/"),e},[]),Ei=class{#t=new Map;#i=new Map;#s=new Set;reserve(t,e){t=eo?["win32 parallelization disabled"]:t.map(r=>mt(br(Rr(r))));let i=new Set(t.map(r=>io(r)).reduce((r,n)=>r.concat(n)));this.#i.set(e,{dirs:i,paths:t});for(let r of t){let n=this.#t.get(r);n?n.push(e):this.#t.set(r,[e])}for(let r of i){let n=this.#t.get(r);if(!n)this.#t.set(r,[new Set([e])]);else{let o=n.at(-1);o instanceof Set?o.add(e):n.push(new Set([e]))}}return this.#r(e)}#n(t){let e=this.#i.get(t);if(!e)throw new Error("function does not have any path reservations");return{paths:e.paths.map(i=>this.#t.get(i)),dirs:[...e.dirs].map(i=>this.#t.get(i))}}check(t){let{paths:e,dirs:i}=this.#n(t);return e.every(r=>r&&r[0]===t)&&i.every(r=>r&&r[0]instanceof Set&&r[0].has(t))}#r(t){return this.#s.has(t)||!this.check(t)?!1:(this.#s.add(t),t(()=>this.#e(t)),!0)}#e(t){if(!this.#s.has(t))return!1;let e=this.#i.get(t);if(!e)throw new Error("invalid reservation");let{paths:i,dirs:r}=e,n=new Set;for(let o of i){let h=this.#t.get(o);if(!h||h?.[0]!==t)continue;let a=h[1];if(!a){this.#t.delete(o);continue}if(h.shift(),typeof a=="function")n.add(a);else for(let l of a)n.add(l)}for(let o of r){let h=this.#t.get(o),a=h?.[0];if(!(!h||!(a instanceof Set)))if(a.size===1&&h.length===1){this.#t.delete(o);continue}else if(a.size===1){h.shift();let l=h[0];typeof l=="function"&&n.add(l)}else a.delete(t)}return this.#s.delete(t),n.forEach(o=>this.#r(o)),!0}};var _r=()=>process.umask();var gr=Symbol("onEntry"),ys=Symbol("checkFs"),Or=Symbol("checkFs2"),Rs=Symbol("isReusable"),P=Symbol("makeFs"),bs=Symbol("file"),_s=Symbol("directory"),Si=Symbol("link"),Tr=Symbol("symlink"),xr=Symbol("hardlink"),ye=Symbol("ensureNoSymlink"),Lr=Symbol("unsupported"),Nr=Symbol("checkPath"),Es=Symbol("stripAbsolutePath"),St=Symbol("mkdir"),O=Symbol("onError"),wi=Symbol("pending"),Ar=Symbol("pend"),Xt=Symbol("unpend"),ws=Symbol("ended"),Ss=Symbol("maybeClose"),gs=Symbol("skip"),Re=Symbol("doChown"),be=Symbol("uid"),_e=Symbol("gid"),ge=Symbol("checkedCwd"),ro=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Oe=ro==="win32",no=1024,oo=(s,t)=>{if(!Oe)return u.unlink(s,t);let e=s+".DELETE."+Ir(16).toString("hex");u.rename(s,e,i=>{if(i)return t(i);u.unlink(e,t)})},ho=s=>{if(!Oe)return u.unlinkSync(s);let t=s+".DELETE."+Ir(16).toString("hex");u.renameSync(s,t),u.unlinkSync(t)},Dr=(s,t,e)=>s!==void 0&&s===s>>>0?s:t!==void 0&&t===t>>>0?t:e,qt=class extends st{[ws]=!1;[ge]=!1;[wi]=0;reservations=new Ei;transform;writable=!0;readable=!1;uid;gid;setOwner;preserveOwner;processGid;processUid;maxDepth;forceChown;win32;newer;keep;noMtime;preservePaths;unlink;cwd;strip;processUmask;umask;dmode;fmode;chmod;constructor(t={}){if(t.ondone=()=>{this[ws]=!0,this[Ss]()},super(t),this.transform=t.transform,this.chmod=!!t.chmod,typeof t.uid=="number"||typeof t.gid=="number"){if(typeof t.uid!="number"||typeof t.gid!="number")throw new TypeError("cannot set owner without number uid and gid");if(t.preserveOwner)throw new TypeError("cannot preserve owner in archive and also set owner explicitly");this.uid=t.uid,this.gid=t.gid,this.setOwner=!0}else this.uid=void 0,this.gid=void 0,this.setOwner=!1;this.preserveOwner=t.preserveOwner===void 0&&typeof t.uid!="number"?!!(process.getuid&&process.getuid()===0):!!t.preserveOwner,this.processUid=(this.preserveOwner||this.setOwner)&&process.getuid?process.getuid():void 0,this.processGid=(this.preserveOwner||this.setOwner)&&process.getgid?process.getgid():void 0,this.maxDepth=typeof t.maxDepth=="number"?t.maxDepth:no,this.forceChown=t.forceChown===!0,this.win32=!!t.win32||Oe,this.newer=!!t.newer,this.keep=!!t.keep,this.noMtime=!!t.noMtime,this.preservePaths=!!t.preservePaths,this.unlink=!!t.unlink,this.cwd=f(R.resolve(t.cwd||process.cwd())),this.strip=Number(t.strip)||0,this.processUmask=this.chmod?typeof t.processUmask=="number"?t.processUmask:_r():0,this.umask=typeof t.umask=="number"?t.umask:this.processUmask,this.dmode=t.dmode||511&~this.umask,this.fmode=t.fmode||438&~this.umask,this.on("entry",e=>this[gr](e))}warn(t,e,i={}){return(t==="TAR_BAD_ARCHIVE"||t==="TAR_ABORT")&&(i.recoverable=!1),super.warn(t,e,i)}[Ss](){this[ws]&&this[wi]===0&&(this.emit("prefinish"),this.emit("finish"),this.emit("end"))}[Es](t,e){let i=t[e],{type:r}=t;if(!i||this.preservePaths)return!0;let[n,o]=ce(i),h=o.replaceAll(/\\/g,"/").split("/");if(h.includes("..")||Oe&&/^[a-z]:\.\.$/i.test(h[0]??"")){if(e==="path"||r==="Link")return this.warn("TAR_ENTRY_ERROR",`${e} contains '..'`,{entry:t,[e]:i}),!1;let a=R.posix.dirname(t.path),l=R.posix.normalize(R.posix.join(a,h.join("/")));if(l.startsWith("../")||l==="..")return this.warn("TAR_ENTRY_ERROR",`${e} escapes extraction directory`,{entry:t,[e]:i}),!1}return n&&(t[e]=String(o),this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute ${e}`,{entry:t,[e]:i})),!0}[Nr](t){let e=f(t.path),i=e.split("/");if(this.strip){if(i.length<this.strip)return!1;if(t.type==="Link"){let r=f(String(t.linkpath)).split("/");if(r.length>=this.strip)t.linkpath=r.slice(this.strip).join("/");else return!1}i.splice(0,this.strip),t.path=i.join("/")}if(isFinite(this.maxDepth)&&i.length>this.maxDepth)return this.warn("TAR_ENTRY_ERROR","path excessively deep",{entry:t,path:e,depth:i.length,maxDepth:this.maxDepth}),!1;if(!this[Es](t,"path")||!this[Es](t,"linkpath"))return!1;if(t.absolute=R.isAbsolute(t.path)?f(R.resolve(t.path)):f(R.resolve(this.cwd,t.path)),!this.preservePaths&&typeof t.absolute=="string"&&t.absolute.indexOf(this.cwd+"/")!==0&&t.absolute!==this.cwd)return this.warn("TAR_ENTRY_ERROR","path escaped extraction target",{entry:t,path:f(t.path),resolvedPath:t.absolute,cwd:this.cwd}),!1;if(t.absolute===this.cwd&&t.type!=="Directory"&&t.type!=="GNUDumpDir")return!1;if(this.win32){let{root:r}=R.win32.parse(String(t.absolute));t.absolute=r+Xi(String(t.absolute).slice(r.length));let{root:n}=R.win32.parse(t.path);t.path=n+Xi(t.path.slice(n.length))}return!0}[gr](t){if(!this[Nr](t))return t.resume();switch(so.equal(typeof t.absolute,"string"),t.type){case"Directory":case"GNUDumpDir":t.mode&&(t.mode=t.mode|448);case"File":case"OldFile":case"ContiguousFile":case"Link":case"SymbolicLink":return this[ys](t);default:return this[Lr](t)}}[O](t,e){t.name==="CwdError"?this.emit("error",t):(this.warn("TAR_ENTRY_ERROR",t,{entry:e}),this[Xt](),e.resume())}[St](t,e,i){Er(f(t),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:e},i)}[Re](t){return this.forceChown||this.preserveOwner&&(typeof t.uid=="number"&&t.uid!==this.processUid||typeof t.gid=="number"&&t.gid!==this.processGid)||typeof this.uid=="number"&&this.uid!==this.processUid||typeof this.gid=="number"&&this.gid!==this.processGid}[be](t){return Dr(this.uid,t.uid,this.processUid)}[_e](t){return Dr(this.gid,t.gid,this.processGid)}[bs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=new tt(String(t.absolute),{flags:cs(t.size),mode:i,autoClose:!1});r.on("error",a=>{r.fd&&u.close(r.fd,()=>{}),r.write=()=>!0,this[O](a,t),e()});let n=1,o=a=>{if(a){r.fd&&u.close(r.fd,()=>{}),this[O](a,t),e();return}--n===0&&r.fd!==void 0&&u.close(r.fd,l=>{l?this[O](l,t):this[Xt](),e()})};r.on("finish",()=>{let a=String(t.absolute),l=r.fd;if(typeof l=="number"&&t.mtime&&!this.noMtime){n++;let c=t.atime||new Date,d=t.mtime;u.futimes(l,c,d,S=>S?u.utimes(a,c,d,T=>o(T&&S)):o())}if(typeof l=="number"&&this[Re](t)){n++;let c=this[be](t),d=this[_e](t);typeof c=="number"&&typeof d=="number"&&u.fchown(l,c,d,S=>S?u.chown(a,c,d,T=>o(T&&S)):o())}o()});let h=this.transform&&this.transform(t)||t;h!==t&&(h.on("error",a=>{this[O](a,t),e()}),t.pipe(h)),h.pipe(r)}[_s](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode;this[St](String(t.absolute),i,r=>{if(r){this[O](r,t),e();return}let n=1,o=()=>{--n===0&&(e(),this[Xt](),t.resume())};t.mtime&&!this.noMtime&&(n++,u.utimes(String(t.absolute),t.atime||new Date,t.mtime,o)),this[Re](t)&&(n++,u.chown(String(t.absolute),Number(this[be](t)),Number(this[_e](t)),o)),o()})}[Lr](t){t.unsupported=!0,this.warn("TAR_ENTRY_UNSUPPORTED",`unsupported entry type: ${t.type}`,{entry:t}),t.resume()}[Tr](t,e){let i=f(R.relative(this.cwd,R.resolve(R.dirname(String(t.absolute)),String(t.linkpath)))).split("/");this[ye](t,this.cwd,i,()=>this[Si](t,String(t.linkpath),"symlink",e),r=>{this[O](r,t),e()})}[xr](t,e){let i=f(R.resolve(this.cwd,String(t.linkpath))),r=f(String(t.linkpath)).split("/");this[ye](t,this.cwd,r,()=>this[Si](t,i,"link",e),n=>{this[O](n,t),e()})}[ye](t,e,i,r,n){let o=i.shift();if(this.preservePaths||o===void 0)return r();let h=R.resolve(e,o);u.lstat(h,(a,l)=>{if(a)return r();if(l?.isSymbolicLink())return n(new wt(h,R.resolve(h,i.join("/"))));this[ye](t,h,i,r,n)})}[Ar](){this[wi]++}[Xt](){this[wi]--,this[Ss]()}[gs](t){this[Xt](),t.resume()}[Rs](t,e){return t.type==="File"&&!this.unlink&&e.isFile()&&e.nlink<=1&&!Oe}[ys](t){this[Ar]();let e=[t.path];t.linkpath&&e.push(t.linkpath),this.reservations.reserve(e,i=>this[Or](t,i))}[Or](t,e){let i=h=>{e(h)},r=()=>{this[St](this.cwd,this.dmode,h=>{if(h){this[O](h,t),i();return}this[ge]=!0,n()})},n=()=>{if(t.absolute!==this.cwd){let h=f(R.dirname(String(t.absolute)));if(h!==this.cwd)return this[St](h,this.dmode,a=>{if(a){this[O](a,t),i();return}o()})}o()},o=()=>{u.lstat(String(t.absolute),(h,a)=>{if(a&&(this.keep||this.newer&&a.mtime>(t.mtime??a.mtime))){this[gs](t),i();return}if(h||this[Rs](t,a))return this[P](null,t,i);if(a.isDirectory()){if(t.type==="Directory"){let l=this.chmod&&t.mode&&(a.mode&4095)!==t.mode,c=d=>this[P](d??null,t,i);return l?u.chmod(String(t.absolute),Number(t.mode),c):c()}if(t.absolute!==this.cwd)return u.rmdir(String(t.absolute),l=>this[P](l??null,t,i))}if(t.absolute===this.cwd)return this[P](null,t,i);oo(String(t.absolute),l=>this[P](l??null,t,i))})};this[ge]?n():r()}[P](t,e,i){if(t){this[O](t,e),i();return}switch(e.type){case"File":case"OldFile":case"ContiguousFile":return this[bs](e,i);case"Link":return this[xr](e,i);case"SymbolicLink":return this[Tr](e,i);case"Directory":case"GNUDumpDir":return this[_s](e,i)}}[Si](t,e,i,r){u[i](e,String(t.absolute),n=>{n?this[O](n,t):(this[Xt](),t.resume()),r()})}},Se=s=>{try{return[null,s()]}catch(t){return[t,null]}},Te=class extends qt{sync=!0;[P](t,e){return super[P](t,e,()=>{})}[ys](t){if(!this[ge]){let n=this[St](this.cwd,this.dmode);if(n)return this[O](n,t);this[ge]=!0}if(t.absolute!==this.cwd){let n=f(R.dirname(String(t.absolute)));if(n!==this.cwd){let o=this[St](n,this.dmode);if(o)return this[O](o,t)}}let[e,i]=Se(()=>u.lstatSync(String(t.absolute)));if(i&&(this.keep||this.newer&&i.mtime>(t.mtime??i.mtime)))return this[gs](t);if(e||this[Rs](t,i))return this[P](null,t);if(i.isDirectory()){if(t.type==="Directory"){let o=this.chmod&&t.mode&&(i.mode&4095)!==t.mode,[h]=o?Se(()=>{u.chmodSync(String(t.absolute),Number(t.mode))}):[];return this[P](h,t)}let[n]=Se(()=>u.rmdirSync(String(t.absolute)));this[P](n,t)}let[r]=t.absolute===this.cwd?[]:Se(()=>ho(String(t.absolute)));this[P](r,t)}[bs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=h=>{let a;try{u.closeSync(n)}catch(l){a=l}(h||a)&&this[O](h||a,t),e()},n;try{n=u.openSync(String(t.absolute),cs(t.size),i)}catch(h){return r(h)}let o=this.transform&&this.transform(t)||t;o!==t&&(o.on("error",h=>this[O](h,t)),t.pipe(o)),o.on("data",h=>{try{u.writeSync(n,h,0,h.length)}catch(a){r(a)}}),o.on("end",()=>{let h=null;if(t.mtime&&!this.noMtime){let a=t.atime||new Date,l=t.mtime;try{u.futimesSync(n,a,l)}catch(c){try{u.utimesSync(String(t.absolute),a,l)}catch{h=c}}}if(this[Re](t)){let a=this[be](t),l=this[_e](t);try{u.fchownSync(n,Number(a),Number(l))}catch(c){try{u.chownSync(String(t.absolute),Number(a),Number(l))}catch{h=h||c}}}r(h)})}[_s](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode,r=this[St](String(t.absolute),i);if(r){this[O](r,t),e();return}if(t.mtime&&!this.noMtime)try{u.utimesSync(String(t.absolute),t.atime||new Date,t.mtime)}catch{}if(this[Re](t))try{u.chownSync(String(t.absolute),Number(this[be](t)),Number(this[_e](t)))}catch{}e(),t.resume()}[St](t,e){try{return Sr(f(t),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:e})}catch(i){return i}}[ye](t,e,i,r,n){if(this.preservePaths||i.length===0)return r();let o=e;for(let h of i){o=R.resolve(o,h);let[a,l]=Se(()=>u.lstatSync(o));if(a)return r();if(l.isSymbolicLink())return n(new wt(o,R.resolve(e,i.join("/"))))}r()}[Si](t,e,i,r){let n=`${i}Sync`;try{u[n](e,String(t.absolute)),r(),t.resume()}catch(o){return this[O](o,t)}}};var ao=s=>{let t=new Te(s),e=s.file,i=Cr.statSync(e),r=s.maxReadSize||16*1024*1024;new Me(e,{readSize:r,size:i.size}).pipe(t)},lo=(s,t)=>{let e=new qt(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("close",o),Cr.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},co=K(ao,lo,s=>new Te(s),s=>new qt(s),(s,t)=>{t?.length&&Ki(s,t)});import v from"node:fs";import Fr from"node:path";var fo=(s,t)=>{let e=new kt(s),i=!0,r,n;try{try{r=v.openSync(s.file,"r+")}catch(a){if(a?.code==="ENOENT")r=v.openSync(s.file,"w+");else throw a}let o=v.fstatSync(r),h=Buffer.alloc(512);t:for(n=0;n<o.size;n+=512){for(let c=0,d=0;c<512;c+=d){if(d=v.readSync(r,h,c,h.length-c,n+c),n===0&&h[0]===31&&h[1]===139)throw new Error("cannot append to compressed archives");if(!d)break t}let a=new F(h);if(!a.cksumValid)break;let l=512*Math.ceil((a.size||0)/512);if(n+l+512>o.size)break;n+=l,s.mtimeCache&&a.mtime&&s.mtimeCache.set(String(a.path),a.mtime)}i=!1,uo(s,e,n,r,t)}finally{if(i)try{v.closeSync(r)}catch{}}},uo=(s,t,e,i,r)=>{let n=new Wt(s.file,{fd:i,start:e});t.pipe(n),po(t,r)},mo=(s,t)=>{t=Array.from(t);let e=new Et(s),i=(n,o,h)=>{let a=(T,N)=>{T?v.close(n,E=>h(T)):h(null,N)},l=0;if(o===0)return a(null,0);let c=0,d=Buffer.alloc(512),S=(T,N)=>{if(T||N===void 0)return a(T);if(c+=N,c<512&&N)return v.read(n,d,c,d.length-c,l+c,S);if(l===0&&d[0]===31&&d[1]===139)return a(new Error("cannot append to compressed archives"));if(c<512)return a(null,l);let E=new F(d);if(!E.cksumValid)return a(null,l);let x=512*Math.ceil((E.size??0)/512);if(l+x+512>o||(l+=x+512,l>=o))return a(null,l);s.mtimeCache&&E.mtime&&s.mtimeCache.set(String(E.path),E.mtime),c=0,v.read(n,d,0,512,l,S)};v.read(n,d,0,512,l,S)};return new Promise((n,o)=>{e.on("error",o);let h="r+",a=(l,c)=>{if(l&&l.code==="ENOENT"&&h==="r+")return h="w+",v.open(s.file,h,a);if(l||!c)return o(l);v.fstat(c,(d,S)=>{if(d)return v.close(c,()=>o(d));i(c,S.size,(T,N)=>{if(T)return o(T);let E=new tt(s.file,{fd:c,start:N});e.pipe(E),E.on("error",o),E.on("close",n),Eo(e,t)})})};v.open(s.file,h,a)})},po=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?It({file:Fr.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},Eo=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await It({file:Fr.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e);s.end()},vt=K(fo,mo,()=>{throw new TypeError("file is required")},()=>{throw new TypeError("file is required")},(s,t)=>{if(!Fs(s))throw new TypeError("file is required");if(s.gzip||s.brotli||s.zstd||s.file.endsWith(".br")||s.file.endsWith(".tbr"))throw new TypeError("cannot append to compressed archives");if(!t?.length)throw new TypeError("no paths specified to add/replace")});var wo=K(vt.syncFile,vt.asyncFile,vt.syncNoFile,vt.asyncNoFile,(s,t=[])=>{vt.validate?.(s,t),So(s)}),So=s=>{let t=s.filter;s.mtimeCache||(s.mtimeCache=new Map),s.filter=t?(e,i)=>t(e,i)&&!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0)):(e,i)=>!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0))};export{F as Header,Et as Pack,di as PackJob,kt as PackSync,st as Parser,ct as Pax,Yt as ReadEntry,qt as Unpack,Te as UnpackSync,de as WriteEntry,si as WriteEntrySync,ri as WriteEntryTar,Zn as c,Zn as create,co as extract,Ki as filesFilter,It as list,vt as r,vt as replace,It as t,Bi as types,wo as u,wo as update,co as x};
+var vr=Object.defineProperty;var Mr=(s,t)=>{for(var e in t)vr(s,e,{get:t[e],enumerable:!0})};import Vr from"events";import I from"fs";import{EventEmitter as Li}from"node:events";import Ds from"node:stream";import{StringDecoder as Br}from"node:string_decoder";var Ts=typeof process=="object"&&process?process:{stdout:null,stderr:null},Pr=s=>!!s&&typeof s=="object"&&(s instanceof A||s instanceof Ds||zr(s)||Ur(s)),zr=s=>!!s&&typeof s=="object"&&s instanceof Li&&typeof s.pipe=="function"&&s.pipe!==Ds.Writable.prototype.pipe,Ur=s=>!!s&&typeof s=="object"&&s instanceof Li&&typeof s.write=="function"&&typeof s.end=="function",q=Symbol("EOF"),Q=Symbol("maybeEmitEnd"),rt=Symbol("emittedEnd"),Ne=Symbol("emittingEnd"),Qt=Symbol("emittedError"),De=Symbol("closed"),xs=Symbol("read"),Ae=Symbol("flush"),Ls=Symbol("flushChunk"),z=Symbol("encoding"),Mt=Symbol("decoder"),g=Symbol("flowing"),Jt=Symbol("paused"),Bt=Symbol("resume"),b=Symbol("buffer"),D=Symbol("pipes"),_=Symbol("bufferLength"),gi=Symbol("bufferPush"),Ie=Symbol("bufferShift"),L=Symbol("objectMode"),w=Symbol("destroyed"),bi=Symbol("error"),_i=Symbol("emitData"),Ns=Symbol("emitEnd"),Oi=Symbol("emitEnd2"),Z=Symbol("async"),Ti=Symbol("abort"),Ce=Symbol("aborted"),jt=Symbol("signal"),Rt=Symbol("dataListeners"),C=Symbol("discarded"),te=s=>Promise.resolve().then(s),Hr=s=>s(),Wr=s=>s==="end"||s==="finish"||s==="prefinish",Gr=s=>s instanceof ArrayBuffer||!!s&&typeof s=="object"&&s.constructor&&s.constructor.name==="ArrayBuffer"&&s.byteLength>=0,Zr=s=>!Buffer.isBuffer(s)&&ArrayBuffer.isView(s),ke=class{src;dest;opts;ondrain;constructor(t,e,i){this.src=t,this.dest=e,this.opts=i,this.ondrain=()=>t[Bt](),this.dest.on("drain",this.ondrain)}unpipe(){this.dest.removeListener("drain",this.ondrain)}proxyErrors(t){}end(){this.unpipe(),this.opts.end&&this.dest.end()}},xi=class extends ke{unpipe(){this.src.removeListener("error",this.proxyErrors),super.unpipe()}constructor(t,e,i){super(t,e,i),this.proxyErrors=r=>this.dest.emit("error",r),t.on("error",this.proxyErrors)}},Yr=s=>!!s.objectMode,Kr=s=>!s.objectMode&&!!s.encoding&&s.encoding!=="buffer",A=class extends Li{[g]=!1;[Jt]=!1;[D]=[];[b]=[];[L];[z];[Z];[Mt];[q]=!1;[rt]=!1;[Ne]=!1;[De]=!1;[Qt]=null;[_]=0;[w]=!1;[jt];[Ce]=!1;[Rt]=0;[C]=!1;writable=!0;readable=!0;constructor(...t){let e=t[0]||{};if(super(),e.objectMode&&typeof e.encoding=="string")throw new TypeError("Encoding and objectMode may not be used together");Yr(e)?(this[L]=!0,this[z]=null):Kr(e)?(this[z]=e.encoding,this[L]=!1):(this[L]=!1,this[z]=null),this[Z]=!!e.async,this[Mt]=this[z]?new Br(this[z]):null,e&&e.debugExposeBuffer===!0&&Object.defineProperty(this,"buffer",{get:()=>this[b]}),e&&e.debugExposePipes===!0&&Object.defineProperty(this,"pipes",{get:()=>this[D]});let{signal:i}=e;i&&(this[jt]=i,i.aborted?this[Ti]():i.addEventListener("abort",()=>this[Ti]()))}get bufferLength(){return this[_]}get encoding(){return this[z]}set encoding(t){throw new Error("Encoding must be set at instantiation time")}setEncoding(t){throw new Error("Encoding must be set at instantiation time")}get objectMode(){return this[L]}set objectMode(t){throw new Error("objectMode must be set at instantiation time")}get async(){return this[Z]}set async(t){this[Z]=this[Z]||!!t}[Ti](){this[Ce]=!0,this.emit("abort",this[jt]?.reason),this.destroy(this[jt]?.reason)}get aborted(){return this[Ce]}set aborted(t){}write(t,e,i){if(this[Ce])return!1;if(this[q])throw new Error("write after end");if(this[w])return this.emit("error",Object.assign(new Error("Cannot call write after a stream was destroyed"),{code:"ERR_STREAM_DESTROYED"})),!0;typeof e=="function"&&(i=e,e="utf8"),e||(e="utf8");let r=this[Z]?te:Hr;if(!this[L]&&!Buffer.isBuffer(t)){if(Zr(t))t=Buffer.from(t.buffer,t.byteOffset,t.byteLength);else if(Gr(t))t=Buffer.from(t);else if(typeof t!="string")throw new Error("Non-contiguous data written to non-objectMode stream")}return this[L]?(this[g]&&this[_]!==0&&this[Ae](!0),this[g]?this.emit("data",t):this[gi](t),this[_]!==0&&this.emit("readable"),i&&r(i),this[g]):t.length?(typeof t=="string"&&!(e===this[z]&&!this[Mt]?.lastNeed)&&(t=Buffer.from(t,e)),Buffer.isBuffer(t)&&this[z]&&(t=this[Mt].write(t)),this[g]&&this[_]!==0&&this[Ae](!0),this[g]?this.emit("data",t):this[gi](t),this[_]!==0&&this.emit("readable"),i&&r(i),this[g]):(this[_]!==0&&this.emit("readable"),i&&r(i),this[g])}read(t){if(this[w])return null;if(this[C]=!1,this[_]===0||t===0||t&&t>this[_])return this[Q](),null;this[L]&&(t=null),this[b].length>1&&!this[L]&&(this[b]=[this[z]?this[b].join(""):Buffer.concat(this[b],this[_])]);let e=this[xs](t||null,this[b][0]);return this[Q](),e}[xs](t,e){if(this[L])this[Ie]();else{let i=e;t===i.length||t===null?this[Ie]():typeof i=="string"?(this[b][0]=i.slice(t),e=i.slice(0,t),this[_]-=t):(this[b][0]=i.subarray(t),e=i.subarray(0,t),this[_]-=t)}return this.emit("data",e),!this[b].length&&!this[q]&&this.emit("drain"),e}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e="utf8"),t!==void 0&&this.write(t,e),i&&this.once("end",i),this[q]=!0,this.writable=!1,(this[g]||!this[Jt])&&this[Q](),this}[Bt](){this[w]||(!this[Rt]&&!this[D].length&&(this[C]=!0),this[Jt]=!1,this[g]=!0,this.emit("resume"),this[b].length?this[Ae]():this[q]?this[Q]():this.emit("drain"))}resume(){return this[Bt]()}pause(){this[g]=!1,this[Jt]=!0,this[C]=!1}get destroyed(){return this[w]}get flowing(){return this[g]}get paused(){return this[Jt]}[gi](t){this[L]?this[_]+=1:this[_]+=t.length,this[b].push(t)}[Ie](){return this[L]?this[_]-=1:this[_]-=this[b][0].length,this[b].shift()}[Ae](t=!1){do;while(this[Ls](this[Ie]())&&this[b].length);!t&&!this[b].length&&!this[q]&&this.emit("drain")}[Ls](t){return this.emit("data",t),this[g]}pipe(t,e){if(this[w])return t;this[C]=!1;let i=this[rt];return e=e||{},t===Ts.stdout||t===Ts.stderr?e.end=!1:e.end=e.end!==!1,e.proxyErrors=!!e.proxyErrors,i?e.end&&t.end():(this[D].push(e.proxyErrors?new xi(this,t,e):new ke(this,t,e)),this[Z]?te(()=>this[Bt]()):this[Bt]()),t}unpipe(t){let e=this[D].find(i=>i.dest===t);e&&(this[D].length===1?(this[g]&&this[Rt]===0&&(this[g]=!1),this[D]=[]):this[D].splice(this[D].indexOf(e),1),e.unpipe())}addListener(t,e){return this.on(t,e)}on(t,e){let i=super.on(t,e);if(t==="data")this[C]=!1,this[Rt]++,!this[D].length&&!this[g]&&this[Bt]();else if(t==="readable"&&this[_]!==0)super.emit("readable");else if(Wr(t)&&this[rt])super.emit(t),this.removeAllListeners(t);else if(t==="error"&&this[Qt]){let r=e;this[Z]?te(()=>r.call(this,this[Qt])):r.call(this,this[Qt])}return i}removeListener(t,e){return this.off(t,e)}off(t,e){let i=super.off(t,e);return t==="data"&&(this[Rt]=this.listeners("data").length,this[Rt]===0&&!this[C]&&!this[D].length&&(this[g]=!1)),i}removeAllListeners(t){let e=super.removeAllListeners(t);return(t==="data"||t===void 0)&&(this[Rt]=0,!this[C]&&!this[D].length&&(this[g]=!1)),e}get emittedEnd(){return this[rt]}[Q](){!this[Ne]&&!this[rt]&&!this[w]&&this[b].length===0&&this[q]&&(this[Ne]=!0,this.emit("end"),this.emit("prefinish"),this.emit("finish"),this[De]&&this.emit("close"),this[Ne]=!1)}emit(t,...e){let i=e[0];if(t!=="error"&&t!=="close"&&t!==w&&this[w])return!1;if(t==="data")return!this[L]&&!i?!1:this[Z]?(te(()=>this[_i](i)),!0):this[_i](i);if(t==="end")return this[Ns]();if(t==="close"){if(this[De]=!0,!this[rt]&&!this[w])return!1;let n=super.emit("close");return this.removeAllListeners("close"),n}else if(t==="error"){this[Qt]=i,super.emit(bi,i);let n=!this[jt]||this.listeners("error").length?super.emit("error",i):!1;return this[Q](),n}else if(t==="resume"){let n=super.emit("resume");return this[Q](),n}else if(t==="finish"||t==="prefinish"){let n=super.emit(t);return this.removeAllListeners(t),n}let r=super.emit(t,...e);return this[Q](),r}[_i](t){for(let i of this[D])i.dest.write(t)===!1&&this.pause();let e=this[C]?!1:super.emit("data",t);return this[Q](),e}[Ns](){return this[rt]?!1:(this[rt]=!0,this.readable=!1,this[Z]?(te(()=>this[Oi]()),!0):this[Oi]())}[Oi](){if(this[Mt]){let e=this[Mt].end();if(e){for(let i of this[D])i.dest.write(e);this[C]||super.emit("data",e)}}for(let e of this[D])e.end();let t=super.emit("end");return this.removeAllListeners("end"),t}async collect(){let t=Object.assign([],{dataLength:0});this[L]||(t.dataLength=0);let e=this.promise();return this.on("data",i=>{t.push(i),this[L]||(t.dataLength+=i.length)}),await e,t}async concat(){if(this[L])throw new Error("cannot concat in objectMode");let t=await this.collect();return this[z]?t.join(""):Buffer.concat(t,t.dataLength)}async promise(){return new Promise((t,e)=>{this.on(w,()=>e(new Error("stream destroyed"))),this.on("error",i=>e(i)),this.on("end",()=>t())})}[Symbol.asyncIterator](){this[C]=!1;let t=!1,e=async()=>(this.pause(),t=!0,{value:void 0,done:!0});return{next:()=>{if(t)return e();let r=this.read();if(r!==null)return Promise.resolve({done:!1,value:r});if(this[q])return e();let n,o,h=d=>{this.off("data",a),this.off("end",l),this.off(w,c),e(),o(d)},a=d=>{this.off("error",h),this.off("end",l),this.off(w,c),this.pause(),n({value:d,done:!!this[q]})},l=()=>{this.off("error",h),this.off("data",a),this.off(w,c),e(),n({done:!0,value:void 0})},c=()=>h(new Error("stream destroyed"));return new Promise((d,S)=>{o=S,n=d,this.once(w,c),this.once("error",h),this.once("end",l),this.once("data",a)})},throw:e,return:e,[Symbol.asyncIterator](){return this},[Symbol.asyncDispose]:async()=>{}}}[Symbol.iterator](){this[C]=!1;let t=!1,e=()=>(this.pause(),this.off(bi,e),this.off(w,e),this.off("end",e),t=!0,{done:!0,value:void 0}),i=()=>{if(t)return e();let r=this.read();return r===null?e():{done:!1,value:r}};return this.once("end",e),this.once(bi,e),this.once(w,e),{next:i,throw:e,return:e,[Symbol.iterator](){return this},[Symbol.dispose]:()=>{}}}destroy(t){if(this[w])return t?this.emit("error",t):this.emit(w),this;this[w]=!0,this[C]=!0,this[b].length=0,this[_]=0;let e=this;return typeof e.close=="function"&&!this[De]&&e.close(),t?this.emit("error",t):this.emit(w),this}static get isStream(){return Pr}};var $r=I.writev,ot=Symbol("_autoClose"),H=Symbol("_close"),ee=Symbol("_ended"),m=Symbol("_fd"),Ni=Symbol("_finished"),j=Symbol("_flags"),Di=Symbol("_flush"),ki=Symbol("_handleChunk"),Fi=Symbol("_makeBuf"),se=Symbol("_mode"),Fe=Symbol("_needDrain"),Ut=Symbol("_onerror"),Ht=Symbol("_onopen"),Ai=Symbol("_onread"),Pt=Symbol("_onwrite"),ht=Symbol("_open"),U=Symbol("_path"),nt=Symbol("_pos"),Y=Symbol("_queue"),zt=Symbol("_read"),Ii=Symbol("_readSize"),J=Symbol("_reading"),ie=Symbol("_remain"),Ci=Symbol("_size"),ve=Symbol("_write"),gt=Symbol("_writing"),Me=Symbol("_defaultFlag"),bt=Symbol("_errored"),_t=class extends A{[bt]=!1;[m];[U];[Ii];[J]=!1;[Ci];[ie];[ot];constructor(t,e){if(e=e||{},super(e),this.readable=!0,this.writable=!1,typeof t!="string")throw new TypeError("path must be a string");this[bt]=!1,this[m]=typeof e.fd=="number"?e.fd:void 0,this[U]=t,this[Ii]=e.readSize||16*1024*1024,this[J]=!1,this[Ci]=typeof e.size=="number"?e.size:1/0,this[ie]=this[Ci],this[ot]=typeof e.autoClose=="boolean"?e.autoClose:!0,typeof this[m]=="number"?this[zt]():this[ht]()}get fd(){return this[m]}get path(){return this[U]}write(){throw new TypeError("this is a readable stream")}end(){throw new TypeError("this is a readable stream")}[ht](){I.open(this[U],"r",(t,e)=>this[Ht](t,e))}[Ht](t,e){t?this[Ut](t):(this[m]=e,this.emit("open",e),this[zt]())}[Fi](){return Buffer.allocUnsafe(Math.min(this[Ii],this[ie]))}[zt](){if(!this[J]){this[J]=!0;let t=this[Fi]();if(t.length===0)return process.nextTick(()=>this[Ai](null,0,t));I.read(this[m],t,0,t.length,null,(e,i,r)=>this[Ai](e,i,r))}}[Ai](t,e,i){this[J]=!1,t?this[Ut](t):this[ki](e,i)&&this[zt]()}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}[Ut](t){this[J]=!0,this[H](),this.emit("error",t)}[ki](t,e){let i=!1;return this[ie]-=t,t>0&&(i=super.write(t<e.length?e.subarray(0,t):e)),(t===0||this[ie]<=0)&&(i=!1,this[H](),super.end()),i}emit(t,...e){switch(t){case"prefinish":case"finish":return!1;case"drain":return typeof this[m]=="number"&&this[zt](),!1;case"error":return this[bt]?!1:(this[bt]=!0,super.emit(t,...e));default:return super.emit(t,...e)}}},Be=class extends _t{[ht](){let t=!0;try{this[Ht](null,I.openSync(this[U],"r")),t=!1}finally{t&&this[H]()}}[zt](){let t=!0;try{if(!this[J]){this[J]=!0;do{let e=this[Fi](),i=e.length===0?0:I.readSync(this[m],e,0,e.length,null);if(!this[ki](i,e))break}while(!0);this[J]=!1}t=!1}finally{t&&this[H]()}}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}},tt=class extends Vr{readable=!1;writable=!0;[bt]=!1;[gt]=!1;[ee]=!1;[Y]=[];[Fe]=!1;[U];[se];[ot];[m];[Me];[j];[Ni]=!1;[nt];constructor(t,e){e=e||{},super(e),this[U]=t,this[m]=typeof e.fd=="number"?e.fd:void 0,this[se]=e.mode===void 0?438:e.mode,this[nt]=typeof e.start=="number"?e.start:void 0,this[ot]=typeof e.autoClose=="boolean"?e.autoClose:!0;let i=this[nt]!==void 0?"r+":"w";this[Me]=e.flags===void 0,this[j]=e.flags===void 0?i:e.flags,this[m]===void 0&&this[ht]()}emit(t,...e){if(t==="error"){if(this[bt])return!1;this[bt]=!0}return super.emit(t,...e)}get fd(){return this[m]}get path(){return this[U]}[Ut](t){this[H](),this[gt]=!0,this.emit("error",t)}[ht](){I.open(this[U],this[j],this[se],(t,e)=>this[Ht](t,e))}[Ht](t,e){this[Me]&&this[j]==="r+"&&t&&t.code==="ENOENT"?(this[j]="w",this[ht]()):t?this[Ut](t):(this[m]=e,this.emit("open",e),this[gt]||this[Di]())}end(t,e){return t&&this.write(t,e),this[ee]=!0,!this[gt]&&!this[Y].length&&typeof this[m]=="number"&&this[Pt](null,0),this}write(t,e){return typeof t=="string"&&(t=Buffer.from(t,e)),this[ee]?(this.emit("error",new Error("write() after end()")),!1):this[m]===void 0||this[gt]||this[Y].length?(this[Y].push(t),this[Fe]=!0,!1):(this[gt]=!0,this[ve](t),!0)}[ve](t){I.write(this[m],t,0,t.length,this[nt],(e,i)=>this[Pt](e,i))}[Pt](t,e){t?this[Ut](t):(this[nt]!==void 0&&typeof e=="number"&&(this[nt]+=e),this[Y].length?this[Di]():(this[gt]=!1,this[ee]&&!this[Ni]?(this[Ni]=!0,this[H](),this.emit("finish")):this[Fe]&&(this[Fe]=!1,this.emit("drain"))))}[Di](){if(this[Y].length===0)this[ee]&&this[Pt](null,0);else if(this[Y].length===1)this[ve](this[Y].pop());else{let t=this[Y];this[Y]=[],$r(this[m],t,this[nt],(e,i)=>this[Pt](e,i))}}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.close(t,e=>e?this.emit("error",e):this.emit("close"))}}},Wt=class extends tt{[ht](){let t;if(this[Me]&&this[j]==="r+")try{t=I.openSync(this[U],this[j],this[se])}catch(e){if(e?.code==="ENOENT")return this[j]="w",this[ht]();throw e}else t=I.openSync(this[U],this[j],this[se]);this[Ht](null,t)}[H](){if(this[ot]&&typeof this[m]=="number"){let t=this[m];this[m]=void 0,I.closeSync(t),this.emit("close")}}[ve](t){let e=!0;try{this[Pt](null,I.writeSync(this[m],t,0,t.length,this[nt])),e=!1}finally{if(e)try{this[H]()}catch{}}}};import or from"node:path";import Vt from"node:fs";import{dirname as Ln,parse as Nn}from"path";var Xr=new Map([["C","cwd"],["f","file"],["z","gzip"],["P","preservePaths"],["U","unlink"],["strip-components","strip"],["stripComponents","strip"],["keep-newer","newer"],["keepNewer","newer"],["keep-newer-files","newer"],["keepNewerFiles","newer"],["k","keep"],["keep-existing","keep"],["keepExisting","keep"],["m","noMtime"],["no-mtime","noMtime"],["p","preserveOwner"],["L","follow"],["h","follow"],["onentry","onReadEntry"]]),As=s=>!!s.sync&&!!s.file,Is=s=>!s.sync&&!!s.file,Cs=s=>!!s.sync&&!s.file,ks=s=>!s.sync&&!s.file;var Fs=s=>!!s.file;var qr=s=>{let t=Xr.get(s);return t||s},re=(s={})=>{if(!s)return{};let t={};for(let[e,i]of Object.entries(s)){let r=qr(e);t[r]=i}return t.chmod===void 0&&t.noChmod===!1&&(t.chmod=!0),delete t.noChmod,t};var K=(s,t,e,i,r)=>Object.assign((n=[],o,h)=>{Array.isArray(n)&&(o=n,n={}),typeof o=="function"&&(h=o,o=void 0),o=o?Array.from(o):[];let a=re(n);if(r?.(a,o),As(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return s(a,o)}else if(Is(a)){let l=t(a,o);return h?l.then(()=>h(),h):l}else if(Cs(a)){if(typeof h=="function")throw new TypeError("callback not supported for sync tar functions");return e(a,o)}else if(ks(a)){if(typeof h=="function")throw new TypeError("callback only supported with file option");return i(a,o)}throw new Error("impossible options??")},{syncFile:s,asyncFile:t,syncNoFile:e,asyncNoFile:i,validate:r});import{EventEmitter as _n}from"events";import Pi from"assert";import{Buffer as Ot}from"buffer";import*as vs from"zlib";import Qr from"zlib";var Jr=Qr.constants||{ZLIB_VERNUM:4736},M=Object.freeze(Object.assign(Object.create(null),{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_VERSION_ERROR:-6,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,DEFLATE:1,INFLATE:2,GZIP:3,GUNZIP:4,DEFLATERAW:5,INFLATERAW:6,UNZIP:7,BROTLI_DECODE:8,BROTLI_ENCODE:9,Z_MIN_WINDOWBITS:8,Z_MAX_WINDOWBITS:15,Z_DEFAULT_WINDOWBITS:15,Z_MIN_CHUNK:64,Z_MAX_CHUNK:1/0,Z_DEFAULT_CHUNK:16384,Z_MIN_MEMLEVEL:1,Z_MAX_MEMLEVEL:9,Z_DEFAULT_MEMLEVEL:8,Z_MIN_LEVEL:-1,Z_MAX_LEVEL:9,Z_DEFAULT_LEVEL:-1,BROTLI_OPERATION_PROCESS:0,BROTLI_OPERATION_FLUSH:1,BROTLI_OPERATION_FINISH:2,BROTLI_OPERATION_EMIT_METADATA:3,BROTLI_MODE_GENERIC:0,BROTLI_MODE_TEXT:1,BROTLI_MODE_FONT:2,BROTLI_DEFAULT_MODE:0,BROTLI_MIN_QUALITY:0,BROTLI_MAX_QUALITY:11,BROTLI_DEFAULT_QUALITY:11,BROTLI_MIN_WINDOW_BITS:10,BROTLI_MAX_WINDOW_BITS:24,BROTLI_LARGE_MAX_WINDOW_BITS:30,BROTLI_DEFAULT_WINDOW:22,BROTLI_MIN_INPUT_BLOCK_BITS:16,BROTLI_MAX_INPUT_BLOCK_BITS:24,BROTLI_PARAM_MODE:0,BROTLI_PARAM_QUALITY:1,BROTLI_PARAM_LGWIN:2,BROTLI_PARAM_LGBLOCK:3,BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:4,BROTLI_PARAM_SIZE_HINT:5,BROTLI_PARAM_LARGE_WINDOW:6,BROTLI_PARAM_NPOSTFIX:7,BROTLI_PARAM_NDIRECT:8,BROTLI_DECODER_RESULT_ERROR:0,BROTLI_DECODER_RESULT_SUCCESS:1,BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:2,BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION:0,BROTLI_DECODER_PARAM_LARGE_WINDOW:1,BROTLI_DECODER_NO_ERROR:0,BROTLI_DECODER_SUCCESS:1,BROTLI_DECODER_NEEDS_MORE_INPUT:2,BROTLI_DECODER_NEEDS_MORE_OUTPUT:3,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:-1,BROTLI_DECODER_ERROR_FORMAT_RESERVED:-2,BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:-3,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:-4,BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:-5,BROTLI_DECODER_ERROR_FORMAT_CL_SPACE:-6,BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE:-7,BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT:-8,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1:-9,BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2:-10,BROTLI_DECODER_ERROR_FORMAT_TRANSFORM:-11,BROTLI_DECODER_ERROR_FORMAT_DICTIONARY:-12,BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS:-13,BROTLI_DECODER_ERROR_FORMAT_PADDING_1:-14,BROTLI_DECODER_ERROR_FORMAT_PADDING_2:-15,BROTLI_DECODER_ERROR_FORMAT_DISTANCE:-16,BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET:-19,BROTLI_DECODER_ERROR_INVALID_ARGUMENTS:-20,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES:-21,BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS:-22,BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP:-25,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1:-26,BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2:-27,BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES:-30,BROTLI_DECODER_ERROR_UNREACHABLE:-31},Jr));var jr=Ot.concat,Ms=Object.getOwnPropertyDescriptor(Ot,"concat"),tn=s=>s,Mi=Ms?.writable===!0||Ms?.set!==void 0?s=>{Ot.concat=s?tn:jr}:s=>{},Tt=Symbol("_superWrite"),Gt=class extends Error{code;errno;constructor(t,e){super("zlib: "+t.message,{cause:t}),this.code=t.code,this.errno=t.errno,this.code||(this.code="ZLIB_ERROR"),this.message="zlib: "+t.message,Error.captureStackTrace(this,e??this.constructor)}get name(){return"ZlibError"}},Bi=Symbol("flushFlag"),ne=class extends A{#t=!1;#i=!1;#s;#n;#r;#e;#o;get sawError(){return this.#t}get handle(){return this.#e}get flushFlag(){return this.#s}constructor(t,e){if(!t||typeof t!="object")throw new TypeError("invalid options for ZlibBase constructor");if(super(t),this.#s=t.flush??0,this.#n=t.finishFlush??0,this.#r=t.fullFlushFlag??0,typeof vs[e]!="function")throw new TypeError("Compression method not supported: "+e);try{this.#e=new vs[e](t)}catch(i){throw new Gt(i,this.constructor)}this.#o=i=>{this.#t||(this.#t=!0,this.close(),this.emit("error",i))},this.#e?.on("error",i=>this.#o(new Gt(i))),this.once("end",()=>this.close)}close(){this.#e&&(this.#e.close(),this.#e=void 0,this.emit("close"))}reset(){if(!this.#t)return Pi(this.#e,"zlib binding closed"),this.#e.reset?.()}flush(t){this.ended||(typeof t!="number"&&(t=this.#r),this.write(Object.assign(Ot.alloc(0),{[Bi]:t})))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&(e?this.write(t,e):this.write(t)),this.flush(this.#n),this.#i=!0,super.end(i)}get ended(){return this.#i}[Tt](t){return super.write(t)}write(t,e,i){if(typeof e=="function"&&(i=e,e="utf8"),typeof t=="string"&&(t=Ot.from(t,e)),this.#t)return;Pi(this.#e,"zlib binding closed");let r=this.#e._handle,n=r.close;r.close=()=>{};let o=this.#e.close;this.#e.close=()=>{},Mi(!0);let h;try{let l=typeof t[Bi]=="number"?t[Bi]:this.#s;h=this.#e._processChunk(t,l),Mi(!1)}catch(l){Mi(!1),this.#o(new Gt(l,this.write))}finally{this.#e&&(this.#e._handle=r,r.close=n,this.#e.close=o,this.#e.removeAllListeners("error"))}this.#e&&this.#e.on("error",l=>this.#o(new Gt(l,this.write)));let a;if(h)if(Array.isArray(h)&&h.length>0){let l=h[0];a=this[Tt](Ot.from(l));for(let c=1;c<h.length;c++)a=this[Tt](h[c])}else a=this[Tt](Ot.from(h));return i&&i(),a}},Pe=class extends ne{#t;#i;constructor(t,e){t=t||{},t.flush=t.flush||M.Z_NO_FLUSH,t.finishFlush=t.finishFlush||M.Z_FINISH,t.fullFlushFlag=M.Z_FULL_FLUSH,super(t,e),this.#t=t.level,this.#i=t.strategy}params(t,e){if(!this.sawError){if(!this.handle)throw new Error("cannot switch params when binding is closed");if(!this.handle.params)throw new Error("not supported in this implementation");if(this.#t!==t||this.#i!==e){this.flush(M.Z_SYNC_FLUSH),Pi(this.handle,"zlib binding closed");let i=this.handle.flush;this.handle.flush=(r,n)=>{typeof r=="function"&&(n=r,r=this.flushFlag),this.flush(r),n?.()};try{this.handle.params(t,e)}finally{this.handle.flush=i}this.handle&&(this.#t=t,this.#i=e)}}}};var ze=class extends Pe{#t;constructor(t){super(t,"Gzip"),this.#t=t&&!!t.portable}[Tt](t){return this.#t?(this.#t=!1,t[9]=255,super[Tt](t)):super[Tt](t)}};var Ue=class extends Pe{constructor(t){super(t,"Unzip")}},He=class extends ne{constructor(t,e){t=t||{},t.flush=t.flush||M.BROTLI_OPERATION_PROCESS,t.finishFlush=t.finishFlush||M.BROTLI_OPERATION_FINISH,t.fullFlushFlag=M.BROTLI_OPERATION_FLUSH,super(t,e)}},We=class extends He{constructor(t){super(t,"BrotliCompress")}},Ge=class extends He{constructor(t){super(t,"BrotliDecompress")}},Ze=class extends ne{constructor(t,e){t=t||{},t.flush=t.flush||M.ZSTD_e_continue,t.finishFlush=t.finishFlush||M.ZSTD_e_end,t.fullFlushFlag=M.ZSTD_e_flush,super(t,e)}},Ye=class extends Ze{constructor(t){super(t,"ZstdCompress")}},Ke=class extends Ze{constructor(t){super(t,"ZstdDecompress")}};import{posix as Zt}from"node:path";var Bs=(s,t)=>{if(Number.isSafeInteger(s))s<0?rn(s,t):sn(s,t);else throw Error("cannot encode number outside of javascript safe integer range");return t},sn=(s,t)=>{t[0]=128;for(var e=t.length;e>1;e--)t[e-1]=s&255,s=Math.floor(s/256)},rn=(s,t)=>{t[0]=255;var e=!1;s=s*-1;for(var i=t.length;i>1;i--){var r=s&255;s=Math.floor(s/256),e?t[i-1]=zs(r):r===0?t[i-1]=0:(e=!0,t[i-1]=Us(r))}},Ps=s=>{let t=s[0],e=t===128?on(s.subarray(1,s.length)):t===255?nn(s):null;if(e===null)throw Error("invalid base256 encoding");if(!Number.isSafeInteger(e))throw Error("parsed number outside of javascript safe integer range");return e},nn=s=>{for(var t=s.length,e=0,i=!1,r=t-1;r>-1;r--){var n=Number(s[r]),o;i?o=zs(n):n===0?o=n:(i=!0,o=Us(n)),o!==0&&(e-=o*Math.pow(256,t-r-1))}return e},on=s=>{for(var t=s.length,e=0,i=t-1;i>-1;i--){var r=Number(s[i]);r!==0&&(e+=r*Math.pow(256,t-i-1))}return e},zs=s=>(255^s)&255,Us=s=>(255^s)+1&255;var zi={};Mr(zi,{code:()=>Ve,isCode:()=>oe,isName:()=>an,name:()=>he});var oe=s=>he.has(s),an=s=>Ve.has(s),he=new Map([["0","File"],["","OldFile"],["1","Link"],["2","SymbolicLink"],["3","CharacterDevice"],["4","BlockDevice"],["5","Directory"],["6","FIFO"],["7","ContiguousFile"],["g","GlobalExtendedHeader"],["x","ExtendedHeader"],["A","SolarisACL"],["D","GNUDumpDir"],["I","Inode"],["K","NextFileHasLongLinkpath"],["L","NextFileHasLongPath"],["M","ContinuationFile"],["N","OldGnuLongPath"],["S","SparseFile"],["V","TapeVolumeHeader"],["X","OldExtendedHeader"]]),Ve=new Map(Array.from(he).map(s=>[s[1],s[0]]));var k=class{cksumValid=!1;needPax=!1;nullBlock=!1;block;path;mode;uid;gid;size;cksum;#t="Unsupported";linkpath;uname;gname;devmaj=0;devmin=0;atime;ctime;mtime;charset;comment;constructor(t,e=0,i,r){Buffer.isBuffer(t)?this.decode(t,e||0,i,r):t&&this.#i(t)}decode(t,e,i,r){if(e||(e=0),!t||!(t.length>=e+512))throw new Error("need 512 bytes for header");this.path=i?.path??xt(t,e,100),this.mode=i?.mode??r?.mode??at(t,e+100,8),this.uid=i?.uid??r?.uid??at(t,e+108,8),this.gid=i?.gid??r?.gid??at(t,e+116,8),this.size=i?.size??r?.size??at(t,e+124,12),this.mtime=i?.mtime??r?.mtime??Ui(t,e+136,12),this.cksum=at(t,e+148,12),r&&this.#i(r,!0),i&&this.#i(i);let n=xt(t,e+156,1);if(oe(n)&&(this.#t=n||"0"),this.#t==="0"&&this.path.slice(-1)==="/"&&(this.#t="5"),this.#t==="5"&&(this.size=0),this.linkpath=xt(t,e+157,100),t.subarray(e+257,e+265).toString()==="ustar\x0000")if(this.uname=i?.uname??r?.uname??xt(t,e+265,32),this.gname=i?.gname??r?.gname??xt(t,e+297,32),this.devmaj=i?.devmaj??r?.devmaj??at(t,e+329,8)??0,this.devmin=i?.devmin??r?.devmin??at(t,e+337,8)??0,t[e+475]!==0){let h=xt(t,e+345,155);this.path=h+"/"+this.path}else{let h=xt(t,e+345,130);h&&(this.path=h+"/"+this.path),this.atime=i?.atime??r?.atime??Ui(t,e+476,12),this.ctime=i?.ctime??r?.ctime??Ui(t,e+488,12)}let o=256;for(let h=e;h<e+148;h++)o+=t[h];for(let h=e+156;h<e+512;h++)o+=t[h];this.cksumValid=o===this.cksum,this.cksum===void 0&&o===256&&(this.nullBlock=!0)}#i(t,e=!1){Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="path"&&e||i==="linkpath"&&e||i==="global"))))}encode(t,e=0){if(t||(t=this.block=Buffer.alloc(512)),this.#t==="Unsupported"&&(this.#t="0"),!(t.length>=e+512))throw new Error("need 512 bytes for header");let i=this.ctime||this.atime?130:155,r=ln(this.path||"",i),n=r[0],o=r[1];this.needPax=!!r[2],this.needPax=Lt(t,e,100,n)||this.needPax,this.needPax=lt(t,e+100,8,this.mode)||this.needPax,this.needPax=lt(t,e+108,8,this.uid)||this.needPax,this.needPax=lt(t,e+116,8,this.gid)||this.needPax,this.needPax=lt(t,e+124,12,this.size)||this.needPax,this.needPax=Hi(t,e+136,12,this.mtime)||this.needPax,t[e+156]=Number(this.#t.codePointAt(0)),this.needPax=Lt(t,e+157,100,this.linkpath)||this.needPax,t.write("ustar\x0000",e+257,8),this.needPax=Lt(t,e+265,32,this.uname)||this.needPax,this.needPax=Lt(t,e+297,32,this.gname)||this.needPax,this.needPax=lt(t,e+329,8,this.devmaj)||this.needPax,this.needPax=lt(t,e+337,8,this.devmin)||this.needPax,this.needPax=Lt(t,e+345,i,o)||this.needPax,t[e+475]!==0?this.needPax=Lt(t,e+345,155,o)||this.needPax:(this.needPax=Lt(t,e+345,130,o)||this.needPax,this.needPax=Hi(t,e+476,12,this.atime)||this.needPax,this.needPax=Hi(t,e+488,12,this.ctime)||this.needPax);let h=256;for(let a=e;a<e+148;a++)h+=t[a];for(let a=e+156;a<e+512;a++)h+=t[a];return this.cksum=h,lt(t,e+148,8,this.cksum),this.cksumValid=!0,this.needPax}get type(){return this.#t==="Unsupported"?this.#t:he.get(this.#t)}get typeKey(){return this.#t}set type(t){let e=String(Ve.get(t));if(oe(e)||e==="Unsupported")this.#t=e;else if(oe(t))this.#t=t;else throw new TypeError("invalid entry type: "+t)}},ln=(s,t)=>{let i=s,r="",n,o=Zt.parse(s).root||".";if(Buffer.byteLength(i)<100)n=[i,r,!1];else{r=Zt.dirname(i),i=Zt.basename(i);do Buffer.byteLength(i)<=100&&Buffer.byteLength(r)<=t?n=[i,r,!1]:Buffer.byteLength(i)>100&&Buffer.byteLength(r)<=t?n=[i.slice(0,99),r,!0]:(i=Zt.join(Zt.basename(r),i),r=Zt.dirname(r));while(r!==o&&n===void 0);n||(n=[s.slice(0,99),"",!0])}return n},xt=(s,t,e)=>s.subarray(t,t+e).toString("utf8").replace(/\0.*/,""),Ui=(s,t,e)=>cn(at(s,t,e)),cn=s=>s===void 0?void 0:new Date(s*1e3),at=(s,t,e)=>Number(s[t])&128?Ps(s.subarray(t,t+e)):dn(s,t,e),fn=s=>isNaN(s)?void 0:s,dn=(s,t,e)=>fn(parseInt(s.subarray(t,t+e).toString("utf8").replace(/\0.*$/,"").trim(),8)),un={12:8589934591,8:2097151},lt=(s,t,e,i)=>i===void 0?!1:i>un[e]||i<0?(Bs(i,s.subarray(t,t+e)),!0):(mn(s,t,e,i),!1),mn=(s,t,e,i)=>s.write(pn(i,e),t,e,"ascii"),pn=(s,t)=>En(Math.floor(s).toString(8),t),En=(s,t)=>(s.length===t-1?s:new Array(t-s.length-1).join("0")+s+" ")+"\0",Hi=(s,t,e,i)=>i===void 0?!1:lt(s,t,e,i.getTime()/1e3),wn=new Array(156).join("\0"),Lt=(s,t,e,i)=>i===void 0?!1:(s.write(i+wn,t,e,"utf8"),i.length!==Buffer.byteLength(i)||i.length>e);import{basename as Sn}from"node:path";var ct=class s{atime;mtime;ctime;charset;comment;gid;uid;gname;uname;linkpath;dev;ino;nlink;path;size;mode;global;constructor(t,e=!1){this.atime=t.atime,this.charset=t.charset,this.comment=t.comment,this.ctime=t.ctime,this.dev=t.dev,this.gid=t.gid,this.global=e,this.gname=t.gname,this.ino=t.ino,this.linkpath=t.linkpath,this.mtime=t.mtime,this.nlink=t.nlink,this.path=t.path,this.size=t.size,this.uid=t.uid,this.uname=t.uname}encode(){let t=this.encodeBody();if(t==="")return Buffer.allocUnsafe(0);let e=Buffer.byteLength(t),i=512*Math.ceil(1+e/512),r=Buffer.allocUnsafe(i);for(let n=0;n<512;n++)r[n]=0;new k({path:("PaxHeader/"+Sn(this.path??"")).slice(0,99),mode:this.mode||420,uid:this.uid,gid:this.gid,size:e,mtime:this.mtime,type:this.global?"GlobalExtendedHeader":"ExtendedHeader",linkpath:"",uname:this.uname||"",gname:this.gname||"",devmaj:0,devmin:0,atime:this.atime,ctime:this.ctime}).encode(r),r.write(t,512,e,"utf8");for(let n=e+512;n<r.length;n++)r[n]=0;return r}encodeBody(){return this.encodeField("path")+this.encodeField("ctime")+this.encodeField("atime")+this.encodeField("dev")+this.encodeField("ino")+this.encodeField("nlink")+this.encodeField("charset")+this.encodeField("comment")+this.encodeField("gid")+this.encodeField("gname")+this.encodeField("linkpath")+this.encodeField("mtime")+this.encodeField("size")+this.encodeField("uid")+this.encodeField("uname")}encodeField(t){if(this[t]===void 0)return"";let e=this[t],i=e instanceof Date?e.getTime()/1e3:e,r=" "+(t==="dev"||t==="ino"||t==="nlink"?"SCHILY.":"")+t+"="+i+`
+`,n=Buffer.byteLength(r),o=Math.floor(Math.log(n)/Math.log(10))+1;return n+o>=Math.pow(10,o)&&(o+=1),o+n+r}static parse(t,e,i=!1){return new s(yn(Rn(t),e),i)}},yn=(s,t)=>t?Object.assign({},t,s):s,Rn=s=>s.replace(/\n$/,"").split(`
+`).reduce(gn,Object.create(null)),gn=(s,t)=>{let e=parseInt(t,10);if(e!==Buffer.byteLength(t)+1)return s;t=t.slice((e+" ").length);let i=t.split("="),r=i.shift();if(!r)return s;let n=r.replace(/^SCHILY\.(dev|ino|nlink)/,"$1"),o=i.join("=");return s[n]=/^([A-Z]+\.)?([mac]|birth|creation)time$/.test(n)?new Date(Number(o)*1e3):/^[0-9]+$/.test(o)?+o:o,s};var bn=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,f=bn!=="win32"?s=>s:s=>s&&s.replaceAll(/\\/g,"/");var Yt=class extends A{extended;globalExtended;header;startBlockSize;blockRemain;remain;type;meta=!1;ignore=!1;path;mode;uid;gid;uname;gname;size=0;mtime;atime;ctime;linkpath;dev;ino;nlink;invalid=!1;absolute;unsupported=!1;constructor(t,e,i){switch(super({}),this.pause(),this.extended=e,this.globalExtended=i,this.header=t,this.remain=t.size??0,this.startBlockSize=512*Math.ceil(this.remain/512),this.blockRemain=this.startBlockSize,this.type=t.type,this.type){case"File":case"OldFile":case"Link":case"SymbolicLink":case"CharacterDevice":case"BlockDevice":case"Directory":case"FIFO":case"ContiguousFile":case"GNUDumpDir":break;case"NextFileHasLongLinkpath":case"NextFileHasLongPath":case"OldGnuLongPath":case"GlobalExtendedHeader":case"ExtendedHeader":case"OldExtendedHeader":this.meta=!0;break;default:this.ignore=!0}if(!t.path)throw new Error("no path provided for tar.ReadEntry");this.path=f(t.path),this.mode=t.mode,this.mode&&(this.mode=this.mode&4095),this.uid=t.uid,this.gid=t.gid,this.uname=t.uname,this.gname=t.gname,this.size=this.remain,this.mtime=t.mtime,this.atime=t.atime,this.ctime=t.ctime,this.linkpath=t.linkpath?f(t.linkpath):void 0,this.uname=t.uname,this.gname=t.gname,e&&this.#t(e),i&&this.#t(i,!0)}write(t){let e=t.length;if(e>this.blockRemain)throw new Error("writing more to entry than is appropriate");let i=this.remain,r=this.blockRemain;return this.remain=Math.max(0,i-e),this.blockRemain=Math.max(0,r-e),this.ignore?!0:i>=e?super.write(t):super.write(t.subarray(0,i))}#t(t,e=!1){t.path&&(t.path=f(t.path)),t.linkpath&&(t.linkpath=f(t.linkpath)),Object.assign(this,Object.fromEntries(Object.entries(t).filter(([i,r])=>!(r==null||i==="path"&&e))))}};var Nt=(s,t,e,i={})=>{s.file&&(i.file=s.file),s.cwd&&(i.cwd=s.cwd),i.code=e instanceof Error&&e.code||t,i.tarCode=t,!s.strict&&i.recoverable!==!1?(e instanceof Error&&(i=Object.assign(e,i),e=e.message),s.emit("warn",t,e,i)):e instanceof Error?s.emit("error",Object.assign(e,i)):s.emit("error",Object.assign(new Error(`${t}: ${e}`),i))};var On=1024*1024,Ki=Buffer.from([31,139]),Vi=Buffer.from([40,181,47,253]),Tn=Math.max(Ki.length,Vi.length),B=Symbol("state"),Dt=Symbol("writeEntry"),et=Symbol("readEntry"),Wi=Symbol("nextEntry"),Hs=Symbol("processEntry"),V=Symbol("extendedHeader"),ae=Symbol("globalExtendedHeader"),ft=Symbol("meta"),Ws=Symbol("emitMeta"),p=Symbol("buffer"),it=Symbol("queue"),dt=Symbol("ended"),Gi=Symbol("emittedEnd"),At=Symbol("emit"),y=Symbol("unzip"),$e=Symbol("consumeChunk"),Xe=Symbol("consumeChunkSub"),Zi=Symbol("consumeBody"),Gs=Symbol("consumeMeta"),Zs=Symbol("consumeHeader"),le=Symbol("consuming"),Yi=Symbol("bufferConcat"),qe=Symbol("maybeEnd"),Kt=Symbol("writing"),ut=Symbol("aborted"),Qe=Symbol("onDone"),It=Symbol("sawValidEntry"),Je=Symbol("sawNullBlock"),je=Symbol("sawEOF"),Ys=Symbol("closeStream"),xn=()=>!0,st=class extends _n{file;strict;maxMetaEntrySize;filter;brotli;zstd;writable=!0;readable=!1;[it]=[];[p];[et];[Dt];[B]="begin";[ft]="";[V];[ae];[dt]=!1;[y];[ut]=!1;[It];[Je]=!1;[je]=!1;[Kt]=!1;[le]=!1;[Gi]=!1;constructor(t={}){super(),this.file=t.file||"",this.on(Qe,()=>{(this[B]==="begin"||this[It]===!1)&&this.warn("TAR_BAD_ARCHIVE","Unrecognized archive format")}),t.ondone?this.on(Qe,t.ondone):this.on(Qe,()=>{this.emit("prefinish"),this.emit("finish"),this.emit("end")}),this.strict=!!t.strict,this.maxMetaEntrySize=t.maxMetaEntrySize||On,this.filter=typeof t.filter=="function"?t.filter:xn;let e=t.file&&(t.file.endsWith(".tar.br")||t.file.endsWith(".tbr"));this.brotli=!(t.gzip||t.zstd)&&t.brotli!==void 0?t.brotli:e?void 0:!1;let i=t.file&&(t.file.endsWith(".tar.zst")||t.file.endsWith(".tzst"));this.zstd=!(t.gzip||t.brotli)&&t.zstd!==void 0?t.zstd:i?!0:void 0,this.on("end",()=>this[Ys]()),typeof t.onwarn=="function"&&this.on("warn",t.onwarn),typeof t.onReadEntry=="function"&&this.on("entry",t.onReadEntry)}warn(t,e,i={}){Nt(this,t,e,i)}[Zs](t,e){this[It]===void 0&&(this[It]=!1);let i;try{i=new k(t,e,this[V],this[ae])}catch(r){return this.warn("TAR_ENTRY_INVALID",r)}if(i.nullBlock)this[Je]?(this[je]=!0,this[B]==="begin"&&(this[B]="header"),this[At]("eof")):(this[Je]=!0,this[At]("nullBlock"));else if(this[Je]=!1,!i.cksumValid)this.warn("TAR_ENTRY_INVALID","checksum failure",{header:i});else if(!i.path)this.warn("TAR_ENTRY_INVALID","path is required",{header:i});else{let r=i.type;if(/^(Symbolic)?Link$/.test(r)&&!i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath required",{header:i});else if(!/^(Symbolic)?Link$/.test(r)&&!/^(Global)?ExtendedHeader$/.test(r)&&i.linkpath)this.warn("TAR_ENTRY_INVALID","linkpath forbidden",{header:i});else{let n=this[Dt]=new Yt(i,this[V],this[ae]);if(!this[It])if(n.remain){let o=()=>{n.invalid||(this[It]=!0)};n.on("end",o)}else this[It]=!0;n.meta?n.size>this.maxMetaEntrySize?(n.ignore=!0,this[At]("ignoredEntry",n),this[B]="ignore",n.resume()):n.size>0&&(this[ft]="",n.on("data",o=>this[ft]+=o),this[B]="meta"):(this[V]=void 0,n.ignore=n.ignore||!this.filter(n.path,n),n.ignore?(this[At]("ignoredEntry",n),this[B]=n.remain?"ignore":"header",n.resume()):(n.remain?this[B]="body":(this[B]="header",n.end()),this[et]?this[it].push(n):(this[it].push(n),this[Wi]())))}}}[Ys](){queueMicrotask(()=>this.emit("close"))}[Hs](t){let e=!0;if(!t)this[et]=void 0,e=!1;else if(Array.isArray(t)){let[i,...r]=t;this.emit(i,...r)}else this[et]=t,this.emit("entry",t),t.emittedEnd||(t.on("end",()=>this[Wi]()),e=!1);return e}[Wi](){do;while(this[Hs](this[it].shift()));if(this[it].length===0){let t=this[et];!t||t.flowing||t.size===t.remain?this[Kt]||this.emit("drain"):t.once("drain",()=>this.emit("drain"))}}[Zi](t,e){let i=this[Dt];if(!i)throw new Error("attempt to consume body without entry??");let r=i.blockRemain??0,n=r>=t.length&&e===0?t:t.subarray(e,e+r);return i.write(n),i.blockRemain||(this[B]="header",this[Dt]=void 0,i.end()),n.length}[Gs](t,e){let i=this[Dt],r=this[Zi](t,e);return!this[Dt]&&i&&this[Ws](i),r}[At](t,e,i){this[it].length===0&&!this[et]?this.emit(t,e,i):this[it].push([t,e,i])}[Ws](t){switch(this[At]("meta",this[ft]),t.type){case"ExtendedHeader":case"OldExtendedHeader":this[V]=ct.parse(this[ft],this[V],!1);break;case"GlobalExtendedHeader":this[ae]=ct.parse(this[ft],this[ae],!0);break;case"NextFileHasLongPath":case"OldGnuLongPath":{let e=this[V]??Object.create(null);this[V]=e,e.path=this[ft].replace(/\0.*/,"");break}case"NextFileHasLongLinkpath":{let e=this[V]||Object.create(null);this[V]=e,e.linkpath=this[ft].replace(/\0.*/,"");break}default:throw new Error("unknown meta: "+t.type)}}abort(t){this[ut]=!0,this.emit("abort",t),this.warn("TAR_ABORT",t,{recoverable:!1})}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this[ut])return i?.(),!1;if((this[y]===void 0||this.brotli===void 0&&this[y]===!1)&&t){if(this[p]&&(t=Buffer.concat([this[p],t]),this[p]=void 0),t.length<Tn)return this[p]=t,i?.(),!0;for(let a=0;this[y]===void 0&&a<Ki.length;a++)t[a]!==Ki[a]&&(this[y]=!1);let o=!1;if(this[y]===!1&&this.zstd!==!1){o=!0;for(let a=0;a<Vi.length;a++)if(t[a]!==Vi[a]){o=!1;break}}let h=this.brotli===void 0&&!o;if(this[y]===!1&&h)if(t.length<512)if(this[dt])this.brotli=!0;else return this[p]=t,i?.(),!0;else try{new k(t.subarray(0,512)),this.brotli=!1}catch{this.brotli=!0}if(this[y]===void 0||this[y]===!1&&(this.brotli||o)){let a=this[dt];this[dt]=!1,this[y]=this[y]===void 0?new Ue({}):o?new Ke({}):new Ge({}),this[y].on("data",c=>this[$e](c)),this[y].on("error",c=>this.abort(c)),this[y].on("end",()=>{this[dt]=!0,this[$e]()}),this[Kt]=!0;let l=!!this[y][a?"end":"write"](t);return this[Kt]=!1,i?.(),l}}this[Kt]=!0,this[y]?this[y].write(t):this[$e](t),this[Kt]=!1;let n=this[it].length>0?!1:this[et]?this[et].flowing:!0;return!n&&this[it].length===0&&this[et]?.once("drain",()=>this.emit("drain")),i?.(),n}[Yi](t){t&&!this[ut]&&(this[p]=this[p]?Buffer.concat([this[p],t]):t)}[qe](){if(this[dt]&&!this[Gi]&&!this[ut]&&!this[le]){this[Gi]=!0;let t=this[Dt];if(t&&t.blockRemain){let e=this[p]?this[p].length:0;this.warn("TAR_BAD_ARCHIVE",`Truncated input (needed ${t.blockRemain} more bytes, only ${e} available)`,{entry:t}),this[p]&&t.write(this[p]),t.end()}this[At](Qe)}}[$e](t){if(this[le]&&t)this[Yi](t);else if(!t&&!this[p])this[qe]();else if(t){if(this[le]=!0,this[p]){this[Yi](t);let e=this[p];this[p]=void 0,this[Xe](e)}else this[Xe](t);for(;this[p]&&this[p]?.length>=512&&!this[ut]&&!this[je];){let e=this[p];this[p]=void 0,this[Xe](e)}this[le]=!1}(!this[p]||this[dt])&&this[qe]()}[Xe](t){let e=0,i=t.length;for(;e+512<=i&&!this[ut]&&!this[je];)switch(this[B]){case"begin":case"header":this[Zs](t,e),e+=512;break;case"ignore":case"body":e+=this[Zi](t,e);break;case"meta":e+=this[Gs](t,e);break;default:throw new Error("invalid state: "+this[B])}e<i&&(this[p]=this[p]?Buffer.concat([t.subarray(e),this[p]]):t.subarray(e))}end(t,e,i){return typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e)),i&&this.once("finish",i),this[ut]||(this[y]?(t&&this[y].write(t),this[y].end()):(this[dt]=!0,(this.brotli===void 0||this.zstd===void 0)&&(t=t||Buffer.alloc(0)),t&&this.write(t),this[qe]())),this}};var mt=s=>{let t=s.length-1,e=-1;for(;t>-1&&s.charAt(t)==="/";)e=t,t--;return e===-1?s:s.slice(0,e)};var Dn=s=>{let t=s.onReadEntry;s.onReadEntry=t?e=>{t(e),e.resume()}:e=>e.resume()},$i=(s,t)=>{let e=new Map(t.map(n=>[mt(n),!0])),i=s.filter,r=(n,o="")=>{let h=o||Nn(n).root||".",a;if(n===h)a=!1;else{let l=e.get(n);a=l!==void 0?l:r(Ln(n),h)}return e.set(n,a),a};s.filter=i?(n,o)=>i(n,o)&&r(mt(n)):n=>r(mt(n))},An=s=>{let t=new st(s),e=s.file,i;try{i=Vt.openSync(e,"r");let r=Vt.fstatSync(i),n=s.maxReadSize||16*1024*1024;if(r.size<n){let o=Buffer.allocUnsafe(r.size),h=Vt.readSync(i,o,0,r.size,0);t.end(h===o.byteLength?o:o.subarray(0,h))}else{let o=0,h=Buffer.allocUnsafe(n);for(;o<r.size;){let a=Vt.readSync(i,h,0,n,o);if(a===0)break;o+=a,t.write(h.subarray(0,a))}t.end()}}finally{if(typeof i=="number")try{Vt.closeSync(i)}catch{}}},In=(s,t)=>{let e=new st(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("end",o),Vt.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},Ct=K(An,In,s=>new st(s),s=>new st(s),(s,t)=>{t?.length&&$i(s,t),s.noResume||Dn(s)});import ui from"fs";import $ from"fs";import Xs from"path";var Xi=(s,t,e)=>(s&=4095,e&&(s=(s|384)&-19),t&&(s&256&&(s|=64),s&32&&(s|=8),s&4&&(s|=1)),s);import{win32 as Cn}from"node:path";var{isAbsolute:kn,parse:Ks}=Cn,ce=s=>{let t="",e=Ks(s);for(;kn(s)||e.root;){let i=s.charAt(0)==="/"&&s.slice(0,4)!=="//?/"?"/":e.root;s=s.slice(i.length),t+=i,e=Ks(s)}return[t,s]};var ti=["|","<",">","?",":"],qi=ti.map(s=>String.fromCodePoint(61440+Number(s.codePointAt(0)))),Fn=new Map(ti.map((s,t)=>[s,qi[t]])),vn=new Map(qi.map((s,t)=>[s,ti[t]])),Qi=s=>ti.reduce((t,e)=>t.split(e).join(Fn.get(e)),s),Vs=s=>qi.reduce((t,e)=>t.split(e).join(vn.get(e)),s);var tr=(s,t)=>t?(s=f(s).replace(/^\.(\/|$)/,""),mt(t)+"/"+s):f(s),Mn=16*1024*1024,qs=Symbol("process"),Qs=Symbol("file"),Js=Symbol("directory"),ji=Symbol("symlink"),js=Symbol("hardlink"),fe=Symbol("header"),ei=Symbol("read"),ts=Symbol("lstat"),ii=Symbol("onlstat"),es=Symbol("onread"),is=Symbol("onreadlink"),ss=Symbol("openfile"),rs=Symbol("onopenfile"),pt=Symbol("close"),si=Symbol("mode"),ns=Symbol("awaitDrain"),Ji=Symbol("ondrain"),X=Symbol("prefix"),de=class extends A{path;portable;myuid=process.getuid&&process.getuid()||0;myuser=process.env.USER||"";maxReadSize;linkCache;statCache;preservePaths;cwd;strict;mtime;noPax;noMtime;prefix;fd;blockLen=0;blockRemain=0;buf;pos=0;remain=0;length=0;offset=0;win32;absolute;header;type;linkpath;stat;onWriteEntry;#t=!1;constructor(t,e={}){let i=re(e);super(),this.path=f(t),this.portable=!!i.portable,this.maxReadSize=i.maxReadSize||Mn,this.linkCache=i.linkCache||new Map,this.statCache=i.statCache||new Map,this.preservePaths=!!i.preservePaths,this.cwd=f(i.cwd||process.cwd()),this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.mtime=i.mtime,this.prefix=i.prefix?f(i.prefix):void 0,this.onWriteEntry=i.onWriteEntry,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let r=!1;if(!this.preservePaths){let[o,h]=ce(this.path);o&&typeof h=="string"&&(this.path=h,r=o)}this.win32=!!i.win32||process.platform==="win32",this.win32&&(this.path=Vs(this.path.replaceAll(/\\/g,"/")),t=t.replaceAll(/\\/g,"/")),this.absolute=f(i.absolute||Xs.resolve(this.cwd,t)),this.path===""&&(this.path="./"),r&&this.warn("TAR_ENTRY_INFO",`stripping ${r} from absolute path`,{entry:this,path:r+this.path});let n=this.statCache.get(this.absolute);n?this[ii](n):this[ts]()}warn(t,e,i={}){return Nt(this,t,e,i)}emit(t,...e){return t==="error"&&(this.#t=!0),super.emit(t,...e)}[ts](){$.lstat(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[ii](e)})}[ii](t){this.statCache.set(this.absolute,t),this.stat=t,t.isFile()||(t.size=0),this.type=Bn(t),this.emit("stat",t),this[qs]()}[qs](){switch(this.type){case"File":return this[Qs]();case"Directory":return this[Js]();case"SymbolicLink":return this[ji]();default:return this.end()}}[si](t){return Xi(t,this.type==="Directory",this.portable)}[X](t){return tr(t,this.prefix)}[fe](){if(!this.stat)throw new Error("cannot write header before stat");this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.onWriteEntry?.(this),this.header=new k({path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,mode:this[si](this.stat.mode),uid:this.portable?void 0:this.stat.uid,gid:this.portable?void 0:this.stat.gid,size:this.stat.size,mtime:this.noMtime?void 0:this.mtime||this.stat.mtime,type:this.type==="Unsupported"?void 0:this.type,uname:this.portable?void 0:this.stat.uid===this.myuid?this.myuser:"",atime:this.portable?void 0:this.stat.atime,ctime:this.portable?void 0:this.stat.ctime}),this.header.encode()&&!this.noPax&&super.write(new ct({atime:this.portable?void 0:this.header.atime,ctime:this.portable?void 0:this.header.ctime,gid:this.portable?void 0:this.header.gid,mtime:this.noMtime?void 0:this.mtime||this.header.mtime,path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,size:this.header.size,uid:this.portable?void 0:this.header.uid,uname:this.portable?void 0:this.header.uname,dev:this.portable?void 0:this.stat.dev,ino:this.portable?void 0:this.stat.ino,nlink:this.portable?void 0:this.stat.nlink}).encode());let t=this.header?.block;if(!t)throw new Error("failed to encode header");super.write(t)}[Js](){if(!this.stat)throw new Error("cannot create directory entry without stat");this.path.slice(-1)!=="/"&&(this.path+="/"),this.stat.size=0,this[fe](),this.end()}[ji](){$.readlink(this.absolute,(t,e)=>{if(t)return this.emit("error",t);this[is](e)})}[is](t){this.linkpath=f(t),this[fe](),this.end()}[js](t){if(!this.stat)throw new Error("cannot create link entry without stat");this.type="Link",this.linkpath=f(Xs.relative(this.cwd,t)),this.stat.size=0,this[fe](),this.end()}[Qs](){if(!this.stat)throw new Error("cannot create file entry without stat");if(this.stat.nlink>1){let t=`${this.stat.dev}:${this.stat.ino}`,e=this.linkCache.get(t);if(e?.indexOf(this.cwd)===0)return this[js](e);this.linkCache.set(t,this.absolute)}if(this[fe](),this.stat.size===0)return this.end();this[ss]()}[ss](){$.open(this.absolute,"r",(t,e)=>{if(t)return this.emit("error",t);this[rs](e)})}[rs](t){if(this.fd=t,this.#t)return this[pt]();if(!this.stat)throw new Error("should stat before calling onopenfile");this.blockLen=512*Math.ceil(this.stat.size/512),this.blockRemain=this.blockLen;let e=Math.min(this.blockLen,this.maxReadSize);this.buf=Buffer.allocUnsafe(e),this.offset=0,this.pos=0,this.remain=this.stat.size,this.length=this.buf.length,this[ei]()}[ei](){let{fd:t,buf:e,offset:i,length:r,pos:n}=this;if(t===void 0||e===void 0)throw new Error("cannot read file without first opening");$.read(t,e,i,r,n,(o,h)=>{if(o)return this[pt](()=>this.emit("error",o));this[es](h)})}[pt](t=()=>{}){this.fd!==void 0&&$.close(this.fd,t)}[es](t){if(t<=0&&this.remain>0){let r=Object.assign(new Error("encountered unexpected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(t>this.remain){let r=Object.assign(new Error("did not encounter expected EOF"),{path:this.absolute,syscall:"read",code:"EOF"});return this[pt](()=>this.emit("error",r))}if(!this.buf)throw new Error("should have created buffer prior to reading");if(t===this.remain)for(let r=t;r<this.length&&t<this.blockRemain;r++)this.buf[r+this.offset]=0,t++,this.remain++;let e=this.offset===0&&t===this.buf.length?this.buf:this.buf.subarray(this.offset,this.offset+t);this.write(e)?this[Ji]():this[ns](()=>this[Ji]())}[ns](t){this.once("drain",t)}write(t,e,i){if(typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8")),this.blockRemain<t.length){let r=Object.assign(new Error("writing more data than expected"),{path:this.absolute});return this.emit("error",r)}return this.remain-=t.length,this.blockRemain-=t.length,this.pos+=t.length,this.offset+=t.length,super.write(t,null,i)}[Ji](){if(!this.remain)return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),this[pt](t=>t?this.emit("error",t):this.end());if(!this.buf)throw new Error("buffer lost somehow in ONDRAIN");this.offset>=this.length&&(this.buf=Buffer.allocUnsafe(Math.min(this.blockRemain,this.buf.length)),this.offset=0),this.length=this.buf.length-this.offset,this[ei]()}},ri=class extends de{sync=!0;[ts](){this[ii]($.lstatSync(this.absolute))}[ji](){this[is]($.readlinkSync(this.absolute))}[ss](){this[rs]($.openSync(this.absolute,"r"))}[ei](){let t=!0;try{let{fd:e,buf:i,offset:r,length:n,pos:o}=this;if(e===void 0||i===void 0)throw new Error("fd and buf must be set in READ method");let h=$.readSync(e,i,r,n,o);this[es](h),t=!1}finally{if(t)try{this[pt](()=>{})}catch{}}}[ns](t){t()}[pt](t=()=>{}){this.fd!==void 0&&$.closeSync(this.fd),t()}},ni=class extends A{blockLen=0;blockRemain=0;buf=0;pos=0;remain=0;length=0;preservePaths;portable;strict;noPax;noMtime;readEntry;type;prefix;path;mode;uid;gid;uname;gname;header;mtime;atime;ctime;linkpath;size;onWriteEntry;warn(t,e,i={}){return Nt(this,t,e,i)}constructor(t,e={}){let i=re(e);super(),this.preservePaths=!!i.preservePaths,this.portable=!!i.portable,this.strict=!!i.strict,this.noPax=!!i.noPax,this.noMtime=!!i.noMtime,this.onWriteEntry=i.onWriteEntry,this.readEntry=t;let{type:r}=t;if(r==="Unsupported")throw new Error("writing entry that should be ignored");this.type=r,this.type==="Directory"&&this.portable&&(this.noMtime=!0),this.prefix=i.prefix,this.path=f(t.path),this.mode=t.mode!==void 0?this[si](t.mode):void 0,this.uid=this.portable?void 0:t.uid,this.gid=this.portable?void 0:t.gid,this.uname=this.portable?void 0:t.uname,this.gname=this.portable?void 0:t.gname,this.size=t.size,this.mtime=this.noMtime?void 0:i.mtime||t.mtime,this.atime=this.portable?void 0:t.atime,this.ctime=this.portable?void 0:t.ctime,this.linkpath=t.linkpath!==void 0?f(t.linkpath):void 0,typeof i.onwarn=="function"&&this.on("warn",i.onwarn);let n=!1;if(!this.preservePaths){let[h,a]=ce(this.path);h&&typeof a=="string"&&(this.path=a,n=h)}this.remain=t.size,this.blockRemain=t.startBlockSize,this.onWriteEntry?.(this),this.header=new k({path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,mode:this.mode,uid:this.portable?void 0:this.uid,gid:this.portable?void 0:this.gid,size:this.size,mtime:this.noMtime?void 0:this.mtime,type:this.type,uname:this.portable?void 0:this.uname,atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime}),n&&this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute path`,{entry:this,path:n+this.path}),this.header.encode()&&!this.noPax&&super.write(new ct({atime:this.portable?void 0:this.atime,ctime:this.portable?void 0:this.ctime,gid:this.portable?void 0:this.gid,mtime:this.noMtime?void 0:this.mtime,path:this[X](this.path),linkpath:this.type==="Link"&&this.linkpath!==void 0?this[X](this.linkpath):this.linkpath,size:this.size,uid:this.portable?void 0:this.uid,uname:this.portable?void 0:this.uname,dev:this.portable?void 0:this.readEntry.dev,ino:this.portable?void 0:this.readEntry.ino,nlink:this.portable?void 0:this.readEntry.nlink}).encode());let o=this.header?.block;if(!o)throw new Error("failed to encode header");super.write(o),t.pipe(this)}[X](t){return tr(t,this.prefix)}[si](t){return Xi(t,this.type==="Directory",this.portable)}write(t,e,i){typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,typeof e=="string"?e:"utf8"));let r=t.length;if(r>this.blockRemain)throw new Error("writing more to entry than is appropriate");return this.blockRemain-=r,super.write(t,i)}end(t,e,i){return this.blockRemain&&super.write(Buffer.alloc(this.blockRemain)),typeof t=="function"&&(i=t,e=void 0,t=void 0),typeof e=="function"&&(i=e,e=void 0),typeof t=="string"&&(t=Buffer.from(t,e??"utf8")),i&&this.once("finish",i),t?super.end(t,i):super.end(i),this}},Bn=s=>s.isFile()?"File":s.isDirectory()?"Directory":s.isSymbolicLink()?"SymbolicLink":"Unsupported";var oi=class s{tail;head;length=0;static create(t=[]){return new s(t)}constructor(t=[]){for(let e of t)this.push(e)}*[Symbol.iterator](){for(let t=this.head;t;t=t.next)yield t.value}removeNode(t){if(t.list!==this)throw new Error("removing node which does not belong to this list");let e=t.next,i=t.prev;return e&&(e.prev=i),i&&(i.next=e),t===this.head&&(this.head=e),t===this.tail&&(this.tail=i),this.length--,t.next=void 0,t.prev=void 0,t.list=void 0,e}unshiftNode(t){if(t===this.head)return;t.list&&t.list.removeNode(t);let e=this.head;t.list=this,t.next=e,e&&(e.prev=t),this.head=t,this.tail||(this.tail=t),this.length++}pushNode(t){if(t===this.tail)return;t.list&&t.list.removeNode(t);let e=this.tail;t.list=this,t.prev=e,e&&(e.next=t),this.tail=t,this.head||(this.head=t),this.length++}push(...t){for(let e=0,i=t.length;e<i;e++)zn(this,t[e]);return this.length}unshift(...t){for(var e=0,i=t.length;e<i;e++)Un(this,t[e]);return this.length}pop(){if(!this.tail)return;let t=this.tail.value,e=this.tail;return this.tail=this.tail.prev,this.tail?this.tail.next=void 0:this.head=void 0,e.list=void 0,this.length--,t}shift(){if(!this.head)return;let t=this.head.value,e=this.head;return this.head=this.head.next,this.head?this.head.prev=void 0:this.tail=void 0,e.list=void 0,this.length--,t}forEach(t,e){e=e||this;for(let i=this.head,r=0;i;r++)t.call(e,i.value,r,this),i=i.next}forEachReverse(t,e){e=e||this;for(let i=this.tail,r=this.length-1;i;r--)t.call(e,i.value,r,this),i=i.prev}get(t){let e=0,i=this.head;for(;i&&e<t;e++)i=i.next;if(e===t&&i)return i.value}getReverse(t){let e=0,i=this.tail;for(;i&&e<t;e++)i=i.prev;if(e===t&&i)return i.value}map(t,e){e=e||this;let i=new s;for(let r=this.head;r;)i.push(t.call(e,r.value,this)),r=r.next;return i}mapReverse(t,e){e=e||this;var i=new s;for(let r=this.tail;r;)i.push(t.call(e,r.value,this)),r=r.prev;return i}reduce(t,e){let i,r=this.head;if(arguments.length>1)i=e;else if(this.head)r=this.head.next,i=this.head.value;else throw new TypeError("Reduce of empty list with no initial value");for(var n=0;r;n++)i=t(i,r.value,n),r=r.next;return i}reduceReverse(t,e){let i,r=this.tail;if(arguments.length>1)i=e;else if(this.tail)r=this.tail.prev,i=this.tail.value;else throw new TypeError("Reduce of empty list with no initial value");for(let n=this.length-1;r;n--)i=t(i,r.value,n),r=r.prev;return i}toArray(){let t=new Array(this.length);for(let e=0,i=this.head;i;e++)t[e]=i.value,i=i.next;return t}toArrayReverse(){let t=new Array(this.length);for(let e=0,i=this.tail;i;e++)t[e]=i.value,i=i.prev;return t}slice(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.head,n=0;for(n=0;r&&n<t;n++)r=r.next;for(;r&&n<e;n++,r=r.next)i.push(r.value);return i}sliceReverse(t=0,e=this.length){e<0&&(e+=this.length),t<0&&(t+=this.length);let i=new s;if(e<t||e<0)return i;t<0&&(t=0),e>this.length&&(e=this.length);let r=this.length,n=this.tail;for(;n&&r>e;r--)n=n.prev;for(;n&&r>t;r--,n=n.prev)i.push(n.value);return i}splice(t,e=0,...i){t>this.length&&(t=this.length-1),t<0&&(t=this.length+t);let r=this.head;for(let o=0;r&&o<t;o++)r=r.next;let n=[];for(let o=0;r&&o<e;o++)n.push(r.value),r=this.removeNode(r);r?r!==this.tail&&(r=r.prev):r=this.tail;for(let o of i)r=Pn(this,r,o);return n}reverse(){let t=this.head,e=this.tail;for(let i=t;i;i=i.prev){let r=i.prev;i.prev=i.next,i.next=r}return this.head=e,this.tail=t,this}};function Pn(s,t,e){let i=t,r=t?t.next:s.head,n=new ue(e,i,r,s);return n.next===void 0&&(s.tail=n),n.prev===void 0&&(s.head=n),s.length++,n}function zn(s,t){s.tail=new ue(t,s.tail,void 0,s),s.head||(s.head=s.tail),s.length++}function Un(s,t){s.head=new ue(t,void 0,s.head,s),s.tail||(s.tail=s.head),s.length++}var ue=class{list;next;prev;value;constructor(t,e,i,r){this.list=r,this.value=t,e?(e.next=this,this.prev=e):this.prev=void 0,i?(i.prev=this,this.next=i):this.next=void 0}};import rr from"path";var mi=class{path;absolute;entry;stat;readdir;pending=!1;pendingLink=!1;ignore=!1;piped=!1;constructor(t,e){this.path=t||"./",this.absolute=e}},er=Buffer.alloc(1024),ai=Symbol("onStat"),me=Symbol("ended"),W=Symbol("queue"),pe=Symbol("queue"),Et=Symbol("current"),kt=Symbol("process"),Ee=Symbol("processing"),hi=Symbol("processJob"),G=Symbol("jobs"),os=Symbol("jobDone"),li=Symbol("addFSEntry"),ir=Symbol("addTarEntry"),ls=Symbol("stat"),cs=Symbol("readdir"),ci=Symbol("onreaddir"),fi=Symbol("pipe"),sr=Symbol("entry"),hs=Symbol("entryOpt"),di=Symbol("writeEntryClass"),nr=Symbol("write"),as=Symbol("ondrain"),wt=class extends A{sync=!1;opt;cwd;maxReadSize;preservePaths;strict;noPax;prefix;linkCache;statCache;file;portable;zip;readdirCache;noDirRecurse;follow;noMtime;mtime;filter;jobs;[di];onWriteEntry;[W];[pe]=new Map;[G]=0;[Ee]=!1;[me]=!1;constructor(t={}){if(super(),this.opt=t,this.file=t.file||"",this.cwd=t.cwd||process.cwd(),this.maxReadSize=t.maxReadSize,this.preservePaths=!!t.preservePaths,this.strict=!!t.strict,this.noPax=!!t.noPax,this.prefix=f(t.prefix||""),this.linkCache=t.linkCache||new Map,this.statCache=t.statCache||new Map,this.readdirCache=t.readdirCache||new Map,this.onWriteEntry=t.onWriteEntry,this[di]=de,typeof t.onwarn=="function"&&this.on("warn",t.onwarn),this.portable=!!t.portable,t.gzip||t.brotli||t.zstd){if((t.gzip?1:0)+(t.brotli?1:0)+(t.zstd?1:0)>1)throw new TypeError("gzip, brotli, zstd are mutually exclusive");if(t.gzip&&(typeof t.gzip!="object"&&(t.gzip={}),this.portable&&(t.gzip.portable=!0),this.zip=new ze(t.gzip)),t.brotli&&(typeof t.brotli!="object"&&(t.brotli={}),this.zip=new We(t.brotli)),t.zstd&&(typeof t.zstd!="object"&&(t.zstd={}),this.zip=new Ye(t.zstd)),!this.zip)throw new Error("impossible");let e=this.zip;e.on("data",i=>super.write(i)),e.on("end",()=>super.end()),e.on("drain",()=>this[as]()),this.on("resume",()=>e.resume())}else this.on("drain",this[as]);this.noDirRecurse=!!t.noDirRecurse,this.follow=!!t.follow,this.noMtime=!!t.noMtime,t.mtime&&(this.mtime=t.mtime),this.filter=typeof t.filter=="function"?t.filter:()=>!0,this[W]=new oi,this[G]=0,this.jobs=Number(t.jobs)||4,this[Ee]=!1,this[me]=!1}[nr](t){return super.write(t)}add(t){return this.write(t),this}end(t,e,i){return typeof t=="function"&&(i=t,t=void 0),typeof e=="function"&&(i=e,e=void 0),t&&this.add(t),this[me]=!0,this[kt](),i&&i(),this}write(t){if(this[me])throw new Error("write after end");return t instanceof Yt?this[ir](t):this[li](t),this.flowing}[ir](t){let e=f(rr.resolve(this.cwd,t.path));if(!this.filter(t.path,t))t.resume();else{let i=new mi(t.path,e);i.entry=new ni(t,this[hs](i)),i.entry.on("end",()=>this[os](i)),this[G]+=1,this[W].push(i)}this[kt]()}[li](t){let e=f(rr.resolve(this.cwd,t));this[W].push(new mi(t,e)),this[kt]()}[ls](t){t.pending=!0,this[G]+=1;let e=this.follow?"stat":"lstat";ui[e](t.absolute,(i,r)=>{t.pending=!1,this[G]-=1,i?this.emit("error",i):this[ai](t,r)})}[ai](t,e){if(this.statCache.set(t.absolute,e),t.stat=e,!this.filter(t.path,e))t.ignore=!0;else if(e.isFile()&&e.nlink>1&&!this.linkCache.get(`${e.dev}:${e.ino}`)&&!this.sync)if(t===this[Et])this[hi](t);else{let i=`${e.dev}:${e.ino}`,r=this[pe].get(i);r?r.push(t):this[pe].set(i,[t]),t.pendingLink=!0,t.pending=!0}this[kt]()}[cs](t){t.pending=!0,this[G]+=1,ui.readdir(t.absolute,(e,i)=>{if(t.pending=!1,this[G]-=1,e)return this.emit("error",e);this[ci](t,i)})}[ci](t,e){this.readdirCache.set(t.absolute,e),t.readdir=e,this[kt]()}[kt](){if(!this[Ee]){this[Ee]=!0;for(let t=this[W].head;t&&this[G]<this.jobs;t=t.next)if(this[hi](t.value),t.value.ignore){let e=t.next;this[W].removeNode(t),t.next=e}this[Ee]=!1,this[me]&&this[W].length===0&&this[G]===0&&(this.zip?this.zip.end(er):(super.write(er),super.end()))}}get[Et](){return this[W]&&this[W].head&&this[W].head.value}[os](t){this[W].shift(),this[G]-=1;let{stat:e}=t;if(e&&e.isFile()&&e.nlink>1){let i=`${e.dev}:${e.ino}`,r=this[pe].get(i);if(r){this[pe].delete(i);for(let n of r)n.pending=!1,this[hi](n)}}this[kt]()}[hi](t){if(t.pending&&t.pendingLink&&t===this[Et]&&(t.pending=!1,t.pendingLink=!1),!t.pending){if(t.entry){t===this[Et]&&!t.piped&&this[fi](t);return}if(!t.stat){let e=this.statCache.get(t.absolute);e?this[ai](t,e):this[ls](t)}if(t.stat&&!t.ignore){if(!this.noDirRecurse&&t.stat.isDirectory()&&!t.readdir){let e=this.readdirCache.get(t.absolute);if(e?this[ci](t,e):this[cs](t),!t.readdir)return}if(t.entry=this[sr](t),!t.entry){t.ignore=!0;return}t===this[Et]&&!t.piped&&this[fi](t)}}}[hs](t){return{onwarn:(e,i,r)=>this.warn(e,i,r),noPax:this.noPax,cwd:this.cwd,absolute:t.absolute,preservePaths:this.preservePaths,maxReadSize:this.maxReadSize,strict:this.strict,portable:this.portable,linkCache:this.linkCache,statCache:this.statCache,noMtime:this.noMtime,mtime:this.mtime,prefix:this.prefix,onWriteEntry:this.onWriteEntry}}[sr](t){this[G]+=1;try{return new this[di](t.path,this[hs](t)).on("end",()=>this[os](t)).on("error",i=>this.emit("error",i))}catch(e){this.emit("error",e)}}[as](){this[Et]&&this[Et].entry&&this[Et].entry.resume()}[fi](t){t.piped=!0,t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[li](o+r)});let e=t.entry,i=this.zip;if(!e)throw new Error("cannot pipe without source");i?e.on("data",r=>{i.write(r)||e.pause()}):e.on("data",r=>{super.write(r)||e.pause()})}pause(){return this.zip&&this.zip.pause(),super.pause()}warn(t,e,i={}){Nt(this,t,e,i)}},Ft=class extends wt{sync=!0;constructor(t){super(t),this[di]=ri}pause(){}resume(){}[ls](t){let e=this.follow?"statSync":"lstatSync";this[ai](t,ui[e](t.absolute))}[cs](t){this[ci](t,ui.readdirSync(t.absolute))}[fi](t){let e=t.entry,i=this.zip;if(t.readdir&&t.readdir.forEach(r=>{let n=t.path,o=n==="./"?"":n.replace(/\/*$/,"/");this[li](o+r)}),!e)throw new Error("Cannot pipe without source");i?e.on("data",r=>{i.write(r)}):e.on("data",r=>{super[nr](r)})}};var Hn=(s,t)=>{let e=new Ft(s),i=new Wt(s.file,{mode:s.mode||438});e.pipe(i),hr(e,t)},Wn=(s,t)=>{let e=new wt(s),i=new tt(s.file,{mode:s.mode||438});e.pipe(i);let r=new Promise((n,o)=>{i.on("error",o),i.on("close",n),e.on("error",o)});return ar(e,t).catch(n=>e.emit("error",n)),r},hr=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?Ct({file:or.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},ar=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await Ct({file:or.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>{s.add(i)}}):s.add(e);s.end()},Gn=(s,t)=>{let e=new Ft(s);return hr(e,t),e},Zn=(s,t)=>{let e=new wt(s);return ar(e,t).catch(i=>e.emit("error",i)),e},Yn=K(Hn,Wn,Gn,Zn,(s,t)=>{if(!t?.length)throw new TypeError("no paths specified to add to archive")});import kr from"node:fs";import ro from"node:assert";import{randomBytes as Cr}from"node:crypto";import u from"node:fs";import R from"node:path";import fr from"fs";var Kn=process.env.__FAKE_PLATFORM__||process.platform,dr=Kn==="win32",{O_CREAT:ur,O_NOFOLLOW:lr,O_TRUNC:mr,O_WRONLY:pr}=fr.constants,Er=Number(process.env.__FAKE_FS_O_FILENAME__)||fr.constants.UV_FS_O_FILEMAP||0,Vn=dr&&!!Er,$n=512*1024,Xn=Er|mr|ur|pr,cr=!dr&&typeof lr=="number"?lr|mr|ur|pr:null,fs=cr!==null?()=>cr:Vn?s=>s<$n?Xn:"w":()=>"w";import Ei from"node:fs";import we from"node:path";var ds=(s,t,e)=>{try{return Ei.lchownSync(s,t,e)}catch(i){if(i?.code!=="ENOENT")throw i}},pi=(s,t,e,i)=>{Ei.lchown(s,t,e,r=>{i(r&&r?.code!=="ENOENT"?r:null)})},qn=(s,t,e,i,r)=>{if(t.isDirectory())us(we.resolve(s,t.name),e,i,n=>{if(n)return r(n);let o=we.resolve(s,t.name);pi(o,e,i,r)});else{let n=we.resolve(s,t.name);pi(n,e,i,r)}},us=(s,t,e,i)=>{Ei.readdir(s,{withFileTypes:!0},(r,n)=>{if(r){if(r.code==="ENOENT")return i();if(r.code!=="ENOTDIR"&&r.code!=="ENOTSUP")return i(r)}if(r||!n.length)return pi(s,t,e,i);let o=n.length,h=null,a=l=>{if(!h){if(l)return i(h=l);if(--o===0)return pi(s,t,e,i)}};for(let l of n)qn(s,l,t,e,a)})},Qn=(s,t,e,i)=>{t.isDirectory()&&ms(we.resolve(s,t.name),e,i),ds(we.resolve(s,t.name),e,i)},ms=(s,t,e)=>{let i;try{i=Ei.readdirSync(s,{withFileTypes:!0})}catch(r){let n=r;if(n?.code==="ENOENT")return;if(n?.code==="ENOTDIR"||n?.code==="ENOTSUP")return ds(s,t,e);throw n}for(let r of i)Qn(s,r,t,e);return ds(s,t,e)};import F from"node:fs";import Jn from"node:fs/promises";import wi from"node:path";var Se=class extends Error{path;code;syscall="chdir";constructor(t,e){super(`${e}: Cannot cd into '${t}'`),this.path=t,this.code=e}get name(){return"CwdError"}};var St=class extends Error{path;symlink;syscall="symlink";code="TAR_SYMLINK_ERROR";constructor(t,e){super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"),this.symlink=t,this.path=e}get name(){return"SymlinkError"}};var jn=(s,t)=>{F.stat(s,(e,i)=>{(e||!i.isDirectory())&&(e=new Se(s,e?.code||"ENOTDIR")),t(e)})},wr=(s,t,e)=>{s=f(s);let i=t.umask??18,r=t.mode|448,n=(r&i)!==0,o=t.uid,h=t.gid,a=typeof o=="number"&&typeof h=="number"&&(o!==t.processUid||h!==t.processGid),l=t.preserve,c=t.unlink,d=f(t.cwd),S=(E,x)=>{E?e(E):x&&a?us(x,o,h,Le=>S(Le)):n?F.chmod(s,r,e):e()};if(s===d)return jn(s,S);if(l)return Jn.mkdir(s,{mode:r,recursive:!0}).then(E=>S(null,E??void 0),S);let N=f(wi.relative(d,s)).split("/");ps(d,N,r,c,d,void 0,S)},ps=(s,t,e,i,r,n,o)=>{if(t.length===0)return o(null,n);let h=t.shift(),a=f(wi.resolve(s+"/"+h));F.mkdir(a,e,Sr(a,t,e,i,r,n,o))},Sr=(s,t,e,i,r,n,o)=>h=>{h?F.lstat(s,(a,l)=>{if(a)a.path=a.path&&f(a.path),o(a);else if(l.isDirectory())ps(s,t,e,i,r,n,o);else if(i)F.unlink(s,c=>{if(c)return o(c);F.mkdir(s,e,Sr(s,t,e,i,r,n,o))});else{if(l.isSymbolicLink())return o(new St(s,s+"/"+t.join("/")));o(h)}}):(n=n||s,ps(s,t,e,i,r,n,o))},to=s=>{let t=!1,e;try{t=F.statSync(s).isDirectory()}catch(i){e=i?.code}finally{if(!t)throw new Se(s,e??"ENOTDIR")}},yr=(s,t)=>{s=f(s);let e=t.umask??18,i=t.mode|448,r=(i&e)!==0,n=t.uid,o=t.gid,h=typeof n=="number"&&typeof o=="number"&&(n!==t.processUid||o!==t.processGid),a=t.preserve,l=t.unlink,c=f(t.cwd),d=E=>{E&&h&&ms(E,n,o),r&&F.chmodSync(s,i)};if(s===c)return to(c),d();if(a)return d(F.mkdirSync(s,{mode:i,recursive:!0})??void 0);let T=f(wi.relative(c,s)).split("/"),N;for(let E=T.shift(),x=c;E&&(x+="/"+E);E=T.shift()){x=f(wi.resolve(x));try{F.mkdirSync(x,i),N=N||x}catch{let Le=F.lstatSync(x);if(Le.isDirectory())continue;if(l){F.unlinkSync(x),F.mkdirSync(x,i),N=N||x;continue}else if(Le.isSymbolicLink())return new St(x,x+"/"+T.join("/"))}}return d(N)};import{join as br}from"node:path";var Es=Object.create(null),Rr=1e4,$t=new Set,gr=s=>{$t.has(s)?$t.delete(s):Es[s]=s.normalize("NFD").toLocaleLowerCase("en").toLocaleUpperCase("en"),$t.add(s);let t=Es[s],e=$t.size-Rr;if(e>Rr/10){for(let i of $t)if($t.delete(i),delete Es[i],--e<=0)break}return t};var eo=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,io=eo==="win32",so=s=>s.split("/").slice(0,-1).reduce((e,i)=>{let r=e.at(-1);return r!==void 0&&(i=br(r,i)),e.push(i||"/"),e},[]),Si=class{#t=new Map;#i=new Map;#s=new Set;reserve(t,e){t=io?["win32 parallelization disabled"]:t.map(r=>mt(br(gr(r))));let i=new Set(t.map(r=>so(r)).reduce((r,n)=>r.concat(n)));this.#i.set(e,{dirs:i,paths:t});for(let r of t){let n=this.#t.get(r);n?n.push(e):this.#t.set(r,[e])}for(let r of i){let n=this.#t.get(r);if(!n)this.#t.set(r,[new Set([e])]);else{let o=n.at(-1);o instanceof Set?o.add(e):n.push(new Set([e]))}}return this.#r(e)}#n(t){let e=this.#i.get(t);if(!e)throw new Error("function does not have any path reservations");return{paths:e.paths.map(i=>this.#t.get(i)),dirs:[...e.dirs].map(i=>this.#t.get(i))}}check(t){let{paths:e,dirs:i}=this.#n(t);return e.every(r=>r&&r[0]===t)&&i.every(r=>r&&r[0]instanceof Set&&r[0].has(t))}#r(t){return this.#s.has(t)||!this.check(t)?!1:(this.#s.add(t),t(()=>this.#e(t)),!0)}#e(t){if(!this.#s.has(t))return!1;let e=this.#i.get(t);if(!e)throw new Error("invalid reservation");let{paths:i,dirs:r}=e,n=new Set;for(let o of i){let h=this.#t.get(o);if(!h||h?.[0]!==t)continue;let a=h[1];if(!a){this.#t.delete(o);continue}if(h.shift(),typeof a=="function")n.add(a);else for(let l of a)n.add(l)}for(let o of r){let h=this.#t.get(o),a=h?.[0];if(!(!h||!(a instanceof Set)))if(a.size===1&&h.length===1){this.#t.delete(o);continue}else if(a.size===1){h.shift();let l=h[0];typeof l=="function"&&n.add(l)}else a.delete(t)}return this.#s.delete(t),n.forEach(o=>this.#r(o)),!0}};var _r=()=>process.umask();var Or=Symbol("onEntry"),Rs=Symbol("checkFs"),Tr=Symbol("checkFs2"),gs=Symbol("isReusable"),P=Symbol("makeFs"),bs=Symbol("file"),_s=Symbol("directory"),Ri=Symbol("link"),xr=Symbol("symlink"),Lr=Symbol("hardlink"),Re=Symbol("ensureNoSymlink"),Nr=Symbol("unsupported"),Dr=Symbol("checkPath"),ws=Symbol("stripAbsolutePath"),yt=Symbol("mkdir"),O=Symbol("onError"),yi=Symbol("pending"),Ar=Symbol("pend"),Xt=Symbol("unpend"),Ss=Symbol("ended"),ys=Symbol("maybeClose"),Os=Symbol("skip"),ge=Symbol("doChown"),be=Symbol("uid"),_e=Symbol("gid"),Oe=Symbol("checkedCwd"),no=process.env.TESTING_TAR_FAKE_PLATFORM||process.platform,Te=no==="win32",oo=1024,ho=(s,t)=>{if(!Te)return u.unlink(s,t);let e=s+".DELETE."+Cr(16).toString("hex");u.rename(s,e,i=>{if(i)return t(i);u.unlink(e,t)})},ao=s=>{if(!Te)return u.unlinkSync(s);let t=s+".DELETE."+Cr(16).toString("hex");u.renameSync(s,t),u.unlinkSync(t)},Ir=(s,t,e)=>s!==void 0&&s===s>>>0?s:t!==void 0&&t===t>>>0?t:e,qt=class extends st{[Ss]=!1;[Oe]=!1;[yi]=0;reservations=new Si;transform;writable=!0;readable=!1;uid;gid;setOwner;preserveOwner;processGid;processUid;maxDepth;forceChown;win32;newer;keep;noMtime;preservePaths;unlink;cwd;strip;processUmask;umask;dmode;fmode;chmod;constructor(t={}){if(t.ondone=()=>{this[Ss]=!0,this[ys]()},super(t),this.transform=t.transform,this.chmod=!!t.chmod,typeof t.uid=="number"||typeof t.gid=="number"){if(typeof t.uid!="number"||typeof t.gid!="number")throw new TypeError("cannot set owner without number uid and gid");if(t.preserveOwner)throw new TypeError("cannot preserve owner in archive and also set owner explicitly");this.uid=t.uid,this.gid=t.gid,this.setOwner=!0}else this.uid=void 0,this.gid=void 0,this.setOwner=!1;this.preserveOwner=t.preserveOwner===void 0&&typeof t.uid!="number"?!!(process.getuid&&process.getuid()===0):!!t.preserveOwner,this.processUid=(this.preserveOwner||this.setOwner)&&process.getuid?process.getuid():void 0,this.processGid=(this.preserveOwner||this.setOwner)&&process.getgid?process.getgid():void 0,this.maxDepth=typeof t.maxDepth=="number"?t.maxDepth:oo,this.forceChown=t.forceChown===!0,this.win32=!!t.win32||Te,this.newer=!!t.newer,this.keep=!!t.keep,this.noMtime=!!t.noMtime,this.preservePaths=!!t.preservePaths,this.unlink=!!t.unlink,this.cwd=f(R.resolve(t.cwd||process.cwd())),this.strip=Number(t.strip)||0,this.processUmask=this.chmod?typeof t.processUmask=="number"?t.processUmask:_r():0,this.umask=typeof t.umask=="number"?t.umask:this.processUmask,this.dmode=t.dmode||511&~this.umask,this.fmode=t.fmode||438&~this.umask,this.on("entry",e=>this[Or](e))}warn(t,e,i={}){return(t==="TAR_BAD_ARCHIVE"||t==="TAR_ABORT")&&(i.recoverable=!1),super.warn(t,e,i)}[ys](){this[Ss]&&this[yi]===0&&(this.emit("prefinish"),this.emit("finish"),this.emit("end"))}[ws](t,e){let i=t[e],{type:r}=t;if(!i||this.preservePaths)return!0;let[n,o]=ce(i),h=o.replaceAll(/\\/g,"/").split("/");if(h.includes("..")||Te&&/^[a-z]:\.\.$/i.test(h[0]??"")){if(e==="path"||r==="Link")return this.warn("TAR_ENTRY_ERROR",`${e} contains '..'`,{entry:t,[e]:i}),!1;let a=R.posix.dirname(t.path),l=R.posix.normalize(R.posix.join(a,h.join("/")));if(l.startsWith("../")||l==="..")return this.warn("TAR_ENTRY_ERROR",`${e} escapes extraction directory`,{entry:t,[e]:i}),!1}return n&&(t[e]=String(o),this.warn("TAR_ENTRY_INFO",`stripping ${n} from absolute ${e}`,{entry:t,[e]:i})),!0}[Dr](t){let e=f(t.path),i=e.split("/");if(this.strip){if(i.length<this.strip)return!1;if(t.type==="Link"){let r=f(String(t.linkpath)).split("/");if(r.length>=this.strip)t.linkpath=r.slice(this.strip).join("/");else return!1}i.splice(0,this.strip),t.path=i.join("/")}if(isFinite(this.maxDepth)&&i.length>this.maxDepth)return this.warn("TAR_ENTRY_ERROR","path excessively deep",{entry:t,path:e,depth:i.length,maxDepth:this.maxDepth}),!1;if(!this[ws](t,"path")||!this[ws](t,"linkpath"))return!1;if(t.absolute=R.isAbsolute(t.path)?f(R.resolve(t.path)):f(R.resolve(this.cwd,t.path)),!this.preservePaths&&typeof t.absolute=="string"&&t.absolute.indexOf(this.cwd+"/")!==0&&t.absolute!==this.cwd)return this.warn("TAR_ENTRY_ERROR","path escaped extraction target",{entry:t,path:f(t.path),resolvedPath:t.absolute,cwd:this.cwd}),!1;if(t.absolute===this.cwd&&t.type!=="Directory"&&t.type!=="GNUDumpDir")return!1;if(this.win32){let{root:r}=R.win32.parse(String(t.absolute));t.absolute=r+Qi(String(t.absolute).slice(r.length));let{root:n}=R.win32.parse(t.path);t.path=n+Qi(t.path.slice(n.length))}return!0}[Or](t){if(!this[Dr](t))return t.resume();switch(ro.equal(typeof t.absolute,"string"),t.type){case"Directory":case"GNUDumpDir":t.mode&&(t.mode=t.mode|448);case"File":case"OldFile":case"ContiguousFile":case"Link":case"SymbolicLink":return this[Rs](t);default:return this[Nr](t)}}[O](t,e){t.name==="CwdError"?this.emit("error",t):(this.warn("TAR_ENTRY_ERROR",t,{entry:e}),this[Xt](),e.resume())}[yt](t,e,i){wr(f(t),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:e},i)}[ge](t){return this.forceChown||this.preserveOwner&&(typeof t.uid=="number"&&t.uid!==this.processUid||typeof t.gid=="number"&&t.gid!==this.processGid)||typeof this.uid=="number"&&this.uid!==this.processUid||typeof this.gid=="number"&&this.gid!==this.processGid}[be](t){return Ir(this.uid,t.uid,this.processUid)}[_e](t){return Ir(this.gid,t.gid,this.processGid)}[bs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=new tt(String(t.absolute),{flags:fs(t.size),mode:i,autoClose:!1});r.on("error",a=>{r.fd&&u.close(r.fd,()=>{}),r.write=()=>!0,this[O](a,t),e()});let n=1,o=a=>{if(a){r.fd&&u.close(r.fd,()=>{}),this[O](a,t),e();return}--n===0&&r.fd!==void 0&&u.close(r.fd,l=>{l?this[O](l,t):this[Xt](),e()})};r.on("finish",()=>{let a=String(t.absolute),l=r.fd;if(typeof l=="number"&&t.mtime&&!this.noMtime){n++;let c=t.atime||new Date,d=t.mtime;u.futimes(l,c,d,S=>S?u.utimes(a,c,d,T=>o(T&&S)):o())}if(typeof l=="number"&&this[ge](t)){n++;let c=this[be](t),d=this[_e](t);typeof c=="number"&&typeof d=="number"&&u.fchown(l,c,d,S=>S?u.chown(a,c,d,T=>o(T&&S)):o())}o()});let h=this.transform&&this.transform(t)||t;h!==t&&(h.on("error",a=>{this[O](a,t),e()}),t.pipe(h)),h.pipe(r)}[_s](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode;this[yt](String(t.absolute),i,r=>{if(r){this[O](r,t),e();return}let n=1,o=()=>{--n===0&&(e(),this[Xt](),t.resume())};t.mtime&&!this.noMtime&&(n++,u.utimes(String(t.absolute),t.atime||new Date,t.mtime,o)),this[ge](t)&&(n++,u.chown(String(t.absolute),Number(this[be](t)),Number(this[_e](t)),o)),o()})}[Nr](t){t.unsupported=!0,this.warn("TAR_ENTRY_UNSUPPORTED",`unsupported entry type: ${t.type}`,{entry:t}),t.resume()}[xr](t,e){let i=f(R.relative(this.cwd,R.resolve(R.dirname(String(t.absolute)),String(t.linkpath)))).split("/");this[Re](t,this.cwd,i,()=>this[Ri](t,String(t.linkpath),"symlink",e),r=>{this[O](r,t),e()})}[Lr](t,e){let i=f(R.resolve(this.cwd,String(t.linkpath))),r=f(String(t.linkpath)).split("/");this[Re](t,this.cwd,r,()=>this[Ri](t,i,"link",e),n=>{this[O](n,t),e()})}[Re](t,e,i,r,n){let o=i.shift();if(this.preservePaths||o===void 0)return r();let h=R.resolve(e,o);u.lstat(h,(a,l)=>{if(a)return r();if(l?.isSymbolicLink())return n(new St(h,R.resolve(h,i.join("/"))));this[Re](t,h,i,r,n)})}[Ar](){this[yi]++}[Xt](){this[yi]--,this[ys]()}[Os](t){this[Xt](),t.resume()}[gs](t,e){return t.type==="File"&&!this.unlink&&e.isFile()&&e.nlink<=1&&!Te}[Rs](t){this[Ar]();let e=[t.path];t.linkpath&&e.push(t.linkpath),this.reservations.reserve(e,i=>this[Tr](t,i))}[Tr](t,e){let i=h=>{e(h)},r=()=>{this[yt](this.cwd,this.dmode,h=>{if(h){this[O](h,t),i();return}this[Oe]=!0,n()})},n=()=>{if(t.absolute!==this.cwd){let h=f(R.dirname(String(t.absolute)));if(h!==this.cwd)return this[yt](h,this.dmode,a=>{if(a){this[O](a,t),i();return}o()})}o()},o=()=>{u.lstat(String(t.absolute),(h,a)=>{if(a&&(this.keep||this.newer&&a.mtime>(t.mtime??a.mtime))){this[Os](t),i();return}if(h||this[gs](t,a))return this[P](null,t,i);if(a.isDirectory()){if(t.type==="Directory"){let l=this.chmod&&t.mode&&(a.mode&4095)!==t.mode,c=d=>this[P](d??null,t,i);return l?u.chmod(String(t.absolute),Number(t.mode),c):c()}if(t.absolute!==this.cwd)return u.rmdir(String(t.absolute),l=>this[P](l??null,t,i))}if(t.absolute===this.cwd)return this[P](null,t,i);ho(String(t.absolute),l=>this[P](l??null,t,i))})};this[Oe]?n():r()}[P](t,e,i){if(t){this[O](t,e),i();return}switch(e.type){case"File":case"OldFile":case"ContiguousFile":return this[bs](e,i);case"Link":return this[Lr](e,i);case"SymbolicLink":return this[xr](e,i);case"Directory":case"GNUDumpDir":return this[_s](e,i)}}[Ri](t,e,i,r){u[i](e,String(t.absolute),n=>{n?this[O](n,t):(this[Xt](),t.resume()),r()})}},ye=s=>{try{return[null,s()]}catch(t){return[t,null]}},xe=class extends qt{sync=!0;[P](t,e){return super[P](t,e,()=>{})}[Rs](t){if(!this[Oe]){let n=this[yt](this.cwd,this.dmode);if(n)return this[O](n,t);this[Oe]=!0}if(t.absolute!==this.cwd){let n=f(R.dirname(String(t.absolute)));if(n!==this.cwd){let o=this[yt](n,this.dmode);if(o)return this[O](o,t)}}let[e,i]=ye(()=>u.lstatSync(String(t.absolute)));if(i&&(this.keep||this.newer&&i.mtime>(t.mtime??i.mtime)))return this[Os](t);if(e||this[gs](t,i))return this[P](null,t);if(i.isDirectory()){if(t.type==="Directory"){let o=this.chmod&&t.mode&&(i.mode&4095)!==t.mode,[h]=o?ye(()=>{u.chmodSync(String(t.absolute),Number(t.mode))}):[];return this[P](h,t)}let[n]=ye(()=>u.rmdirSync(String(t.absolute)));this[P](n,t)}let[r]=t.absolute===this.cwd?[]:ye(()=>ao(String(t.absolute)));this[P](r,t)}[bs](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.fmode,r=h=>{let a;try{u.closeSync(n)}catch(l){a=l}(h||a)&&this[O](h||a,t),e()},n;try{n=u.openSync(String(t.absolute),fs(t.size),i)}catch(h){return r(h)}let o=this.transform&&this.transform(t)||t;o!==t&&(o.on("error",h=>this[O](h,t)),t.pipe(o)),o.on("data",h=>{try{u.writeSync(n,h,0,h.length)}catch(a){r(a)}}),o.on("end",()=>{let h=null;if(t.mtime&&!this.noMtime){let a=t.atime||new Date,l=t.mtime;try{u.futimesSync(n,a,l)}catch(c){try{u.utimesSync(String(t.absolute),a,l)}catch{h=c}}}if(this[ge](t)){let a=this[be](t),l=this[_e](t);try{u.fchownSync(n,Number(a),Number(l))}catch(c){try{u.chownSync(String(t.absolute),Number(a),Number(l))}catch{h=h||c}}}r(h)})}[_s](t,e){let i=typeof t.mode=="number"?t.mode&4095:this.dmode,r=this[yt](String(t.absolute),i);if(r){this[O](r,t),e();return}if(t.mtime&&!this.noMtime)try{u.utimesSync(String(t.absolute),t.atime||new Date,t.mtime)}catch{}if(this[ge](t))try{u.chownSync(String(t.absolute),Number(this[be](t)),Number(this[_e](t)))}catch{}e(),t.resume()}[yt](t,e){try{return yr(f(t),{uid:this.uid,gid:this.gid,processUid:this.processUid,processGid:this.processGid,umask:this.processUmask,preserve:this.preservePaths,unlink:this.unlink,cwd:this.cwd,mode:e})}catch(i){return i}}[Re](t,e,i,r,n){if(this.preservePaths||i.length===0)return r();let o=e;for(let h of i){o=R.resolve(o,h);let[a,l]=ye(()=>u.lstatSync(o));if(a)return r();if(l.isSymbolicLink())return n(new St(o,R.resolve(e,i.join("/"))))}r()}[Ri](t,e,i,r){let n=`${i}Sync`;try{u[n](e,String(t.absolute)),r(),t.resume()}catch(o){return this[O](o,t)}}};var lo=s=>{let t=new xe(s),e=s.file,i=kr.statSync(e),r=s.maxReadSize||16*1024*1024;new Be(e,{readSize:r,size:i.size}).pipe(t)},co=(s,t)=>{let e=new qt(s),i=s.maxReadSize||16*1024*1024,r=s.file;return new Promise((o,h)=>{e.on("error",h),e.on("close",o),kr.stat(r,(a,l)=>{if(a)h(a);else{let c=new _t(r,{readSize:i,size:l.size});c.on("error",h),c.pipe(e)}})})},fo=K(lo,co,s=>new xe(s),s=>new qt(s),(s,t)=>{t?.length&&$i(s,t)});import v from"node:fs";import Fr from"node:path";var uo=(s,t)=>{let e=new Ft(s),i=!0,r,n;try{try{r=v.openSync(s.file,"r+")}catch(a){if(a?.code==="ENOENT")r=v.openSync(s.file,"w+");else throw a}let o=v.fstatSync(r),h=Buffer.alloc(512);t:for(n=0;n<o.size;n+=512){for(let c=0,d=0;c<512;c+=d){if(d=v.readSync(r,h,c,h.length-c,n+c),n===0&&h[0]===31&&h[1]===139)throw new Error("cannot append to compressed archives");if(!d)break t}let a=new k(h);if(!a.cksumValid)break;let l=512*Math.ceil((a.size||0)/512);if(n+l+512>o.size)break;n+=l,s.mtimeCache&&a.mtime&&s.mtimeCache.set(String(a.path),a.mtime)}i=!1,mo(s,e,n,r,t)}finally{if(i)try{v.closeSync(r)}catch{}}},mo=(s,t,e,i,r)=>{let n=new Wt(s.file,{fd:i,start:e});t.pipe(n),Eo(t,r)},po=(s,t)=>{t=Array.from(t);let e=new wt(s),i=(n,o,h)=>{let a=(T,N)=>{T?v.close(n,E=>h(T)):h(null,N)},l=0;if(o===0)return a(null,0);let c=0,d=Buffer.alloc(512),S=(T,N)=>{if(T||N===void 0)return a(T);if(c+=N,c<512&&N)return v.read(n,d,c,d.length-c,l+c,S);if(l===0&&d[0]===31&&d[1]===139)return a(new Error("cannot append to compressed archives"));if(c<512)return a(null,l);let E=new k(d);if(!E.cksumValid)return a(null,l);let x=512*Math.ceil((E.size??0)/512);if(l+x+512>o||(l+=x+512,l>=o))return a(null,l);s.mtimeCache&&E.mtime&&s.mtimeCache.set(String(E.path),E.mtime),c=0,v.read(n,d,0,512,l,S)};v.read(n,d,0,512,l,S)};return new Promise((n,o)=>{e.on("error",o);let h="r+",a=(l,c)=>{if(l&&l.code==="ENOENT"&&h==="r+")return h="w+",v.open(s.file,h,a);if(l||!c)return o(l);v.fstat(c,(d,S)=>{if(d)return v.close(c,()=>o(d));i(c,S.size,(T,N)=>{if(T)return o(T);let E=new tt(s.file,{fd:c,start:N});e.pipe(E),E.on("error",o),E.on("close",n),wo(e,t)})})};v.open(s.file,h,a)})},Eo=(s,t)=>{t.forEach(e=>{e.charAt(0)==="@"?Ct({file:Fr.resolve(s.cwd,e.slice(1)),sync:!0,noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e)}),s.end()},wo=async(s,t)=>{for(let e of t)e.charAt(0)==="@"?await Ct({file:Fr.resolve(String(s.cwd),e.slice(1)),noResume:!0,onReadEntry:i=>s.add(i)}):s.add(e);s.end()},vt=K(uo,po,()=>{throw new TypeError("file is required")},()=>{throw new TypeError("file is required")},(s,t)=>{if(!Fs(s))throw new TypeError("file is required");if(s.gzip||s.brotli||s.zstd||s.file.endsWith(".br")||s.file.endsWith(".tbr"))throw new TypeError("cannot append to compressed archives");if(!t?.length)throw new TypeError("no paths specified to add/replace")});var So=K(vt.syncFile,vt.asyncFile,vt.syncNoFile,vt.asyncNoFile,(s,t=[])=>{vt.validate?.(s,t),yo(s)}),yo=s=>{let t=s.filter;s.mtimeCache||(s.mtimeCache=new Map),s.filter=t?(e,i)=>t(e,i)&&!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0)):(e,i)=>!((s.mtimeCache?.get(e)??i.mtime??0)>(i.mtime??0))};export{k as Header,wt as Pack,mi as PackJob,Ft as PackSync,st as Parser,ct as Pax,Yt as ReadEntry,qt as Unpack,xe as UnpackSync,de as WriteEntry,ri as WriteEntrySync,ni as WriteEntryTar,Yn as c,Yn as create,fo as extract,$i as filesFilter,Ct as list,vt as r,vt as replace,Ct as t,zi as types,So as u,So as update,fo as x};
 //# sourceMappingURL=index.min.js.map
diff --git a/deps/npm/node_modules/tar/dist/esm/pack.js b/deps/npm/node_modules/tar/dist/esm/pack.js
index ed87ffd49b787c..6eae0ee73bda00 100644
--- a/deps/npm/node_modules/tar/dist/esm/pack.js
+++ b/deps/npm/node_modules/tar/dist/esm/pack.js
@@ -15,6 +15,7 @@ export class PackJob {
     stat;
     readdir;
     pending = false;
+    pendingLink = false;
     ignore = false;
     piped = false;
     constructor(path, absolute) {
@@ -31,6 +32,7 @@ const EOF = Buffer.alloc(1024);
 const ONSTAT = Symbol('onStat');
 const ENDED = Symbol('ended');
 const QUEUE = Symbol('queue');
+const PENDINGLINKS = Symbol('queue');
 const CURRENT = Symbol('current');
 const PROCESS = Symbol('process');
 const PROCESSING = Symbol('processing');
@@ -82,6 +84,7 @@ export class Pack extends Minipass {
     // class, but then we'd have to be tracking the tail of the queue the
     // whole time, and Yallist just does that for us anyway.
     [QUEUE];
+    [PENDINGLINKS] = new Map();
     [JOBS] = 0;
     [PROCESSING] = false;
     [ENDED] = false;
@@ -239,14 +242,26 @@ export class Pack extends Minipass {
         }
         else if (stat.isFile() &&
             stat.nlink > 1 &&
-            job === this[CURRENT] &&
             !this.linkCache.get(`${stat.dev}:${stat.ino}`) &&
             !this.sync) {
-            // if it's not filtered, and it's a new File entry,
-            // jump the queue in case any pending Link entries are about
-            // to try to link to it. This prevents a hardlink from coming ahead
-            // of its target in the archive.
-            this[PROCESSJOB](job);
+            // if it's not filtered, and it's a new File entry, and next anyway
+            // process right away in case any pending Link entries are about
+            // to try to link to it.
+            if (job === this[CURRENT]) {
+                this[PROCESSJOB](job);
+            }
+            else {
+                // if it's NOT the current entry, it needs to be deferred,
+                // so that the link target can be built first.
+                const key = `${stat.dev}:${stat.ino}`;
+                const pending = this[PENDINGLINKS].get(key);
+                if (pending)
+                    pending.push(job);
+                else
+                    this[PENDINGLINKS].set(key, [job]);
+                job.pendingLink = true;
+                job.pending = true;
+            }
         }
         this[PROCESS]();
     }
@@ -294,12 +309,31 @@ export class Pack extends Minipass {
     get [CURRENT]() {
         return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
     }
-    [JOBDONE](_job) {
+    [JOBDONE](job) {
         this[QUEUE].shift();
         this[JOBS] -= 1;
+        const { stat } = job;
+        if (stat && stat.isFile() && stat.nlink > 1) {
+            // might be a file with pending links
+            const key = `${stat.dev}:${stat.ino}`;
+            const pending = this[PENDINGLINKS].get(key);
+            if (pending) {
+                this[PENDINGLINKS].delete(key);
+                for (const job of pending) {
+                    job.pending = false;
+                    this[PROCESSJOB](job);
+                }
+            }
+        }
         this[PROCESS]();
     }
     [PROCESSJOB](job) {
+        if (job.pending && job.pendingLink && job === this[CURRENT]) {
+            // At least one of the links to this file are not being included
+            // in the tarball, so we need to just proceed.
+            job.pending = false;
+            job.pendingLink = false;
+        }
         if (job.pending) {
             return;
         }
diff --git a/deps/npm/node_modules/tar/package.json b/deps/npm/node_modules/tar/package.json
index 55d21bcf0b535d..2ad5841e328515 100644
--- a/deps/npm/node_modules/tar/package.json
+++ b/deps/npm/node_modules/tar/package.json
@@ -2,7 +2,7 @@
   "author": "Isaac Z. Schlueter",
   "name": "tar",
   "description": "tar for node",
-  "version": "7.5.13",
+  "version": "7.5.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/isaacs/node-tar.git"
@@ -38,13 +38,13 @@
     "events-to-array": "^2.0.3",
     "mutate-fs": "^2.1.1",
     "nock": "^13.5.4",
-    "oxlint": "^1.56.0",
-    "oxlint-tsgolint": "^0.17.0",
+    "oxlint": "^1.57.0",
+    "oxlint-tsgolint": "^0.17.3",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.2",
     "tap": "^21.6.2",
     "tshy": "^3.3.2",
-    "typedoc": "^0.28.17"
+    "typedoc": "^0.28.18"
   },
   "license": "BlueOak-1.0.0",
   "engines": {
diff --git a/deps/npm/package.json b/deps/npm/package.json
index 67186d5c05daa7..24c176130a2121 100644
--- a/deps/npm/package.json
+++ b/deps/npm/package.json
@@ -1,5 +1,5 @@
 {
-  "version": "11.13.0",
+  "version": "11.15.0",
   "name": "npm",
   "description": "a package manager for JavaScript",
   "workspaces": [
@@ -52,8 +52,8 @@
   },
   "dependencies": {
     "@isaacs/string-locale-compare": "^1.1.0",
-    "@npmcli/arborist": "^9.4.3",
-    "@npmcli/config": "^10.8.1",
+    "@npmcli/arborist": "^9.6.0",
+    "@npmcli/config": "^10.9.1",
     "@npmcli/fs": "^5.0.0",
     "@npmcli/map-workspaces": "^5.0.3",
     "@npmcli/metavuln-calculator": "^9.0.3",
@@ -71,18 +71,18 @@
     "fs-minipass": "^3.0.3",
     "glob": "^13.0.6",
     "graceful-fs": "^4.2.11",
-    "hosted-git-info": "^9.0.2",
+    "hosted-git-info": "^9.0.3",
     "ini": "^6.0.0",
     "init-package-json": "^8.2.5",
     "is-cidr": "^6.0.4",
     "json-parse-even-better-errors": "^5.0.0",
     "libnpmaccess": "^10.0.3",
-    "libnpmdiff": "^8.1.6",
-    "libnpmexec": "^10.2.6",
-    "libnpmfund": "^7.0.20",
+    "libnpmdiff": "^8.1.8",
+    "libnpmexec": "^10.2.8",
+    "libnpmfund": "^7.0.22",
     "libnpmorg": "^8.0.1",
-    "libnpmpack": "^9.1.6",
-    "libnpmpublish": "^11.1.3",
+    "libnpmpack": "^9.1.8",
+    "libnpmpublish": "^11.2.0",
     "libnpmsearch": "^9.0.1",
     "libnpmteam": "^8.0.2",
     "libnpmversion": "^8.0.3",
@@ -106,11 +106,11 @@
     "proc-log": "^6.1.0",
     "qrcode-terminal": "^0.12.0",
     "read": "^5.0.1",
-    "semver": "^7.7.4",
+    "semver": "^7.8.0",
     "spdx-expression-parse": "^4.0.0",
     "ssri": "^13.0.1",
     "supports-color": "^10.2.2",
-    "tar": "^7.5.13",
+    "tar": "^7.5.15",
     "text-table": "~0.2.0",
     "tiny-relative-date": "^2.0.2",
     "treeverse": "^3.0.0",
diff --git a/deps/npm/tap-snapshots/test/lib/commands/completion.js.test.cjs b/deps/npm/tap-snapshots/test/lib/commands/completion.js.test.cjs
index 43a99252d4200a..a5f0f6748f8d74 100644
--- a/deps/npm/tap-snapshots/test/lib/commands/completion.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/commands/completion.js.test.cjs
@@ -105,10 +105,16 @@ Array [
     --repo
     --environment
     --env
+    --allow-publish
+    --allow-stage-publish
+    --allow-staged-publish
     --dry-run
     --json
     --registry
     --yes
+    --no-allow-publish
+    --no-allow-stage-publish
+    --no-allow-staged-publish
     --no-dry-run
     --no-json
     --no-yes
@@ -123,10 +129,16 @@ Array [
     --project
     --environment
     --env
+    --allow-publish
+    --allow-stage-publish
+    --allow-staged-publish
     --dry-run
     --json
     --registry
     --yes
+    --no-allow-publish
+    --no-allow-stage-publish
+    --no-allow-staged-publish
     --no-dry-run
     --no-json
     --no-yes
diff --git a/deps/npm/tap-snapshots/test/lib/commands/config.js.test.cjs b/deps/npm/tap-snapshots/test/lib/commands/config.js.test.cjs
index 6617b3a0827f76..4a224a5cffbff8 100644
--- a/deps/npm/tap-snapshots/test/lib/commands/config.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/commands/config.js.test.cjs
@@ -16,7 +16,10 @@ exports[`test/lib/commands/config.js TAP config list --json > output matches sna
   "access": null,
   "all": false,
   "allow-same-version": false,
+  "allow-directory": "all",
+  "allow-file": "all",
   "allow-git": "all",
+  "allow-remote": "all",
   "also": null,
   "audit": true,
   "audit-level": null,
@@ -192,7 +195,10 @@ exports[`test/lib/commands/config.js TAP config list --long > output matches sna
 _auth = (protected)
 access = null
 all = false
+allow-directory = "all"
+allow-file = "all"
 allow-git = "all"
+allow-remote = "all"
 allow-same-version = false
 also = null
 audit = true
diff --git a/deps/npm/tap-snapshots/test/lib/commands/publish.js.test.cjs b/deps/npm/tap-snapshots/test/lib/commands/publish.js.test.cjs
index e7507118a28f50..2eda536c6bb33e 100644
--- a/deps/npm/tap-snapshots/test/lib/commands/publish.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/commands/publish.js.test.cjs
@@ -87,23 +87,25 @@ Array [
 
 exports[`test/lib/commands/publish.js TAP json > new package json 1`] = `
 {
-  "id": "@npmcli/test-package@1.0.0",
-  "name": "@npmcli/test-package",
-  "version": "1.0.0",
-  "size": "{size}",
-  "unpackedSize": 95,
-  "shasum": "{sha}",
-  "integrity": "{integrity}",
-  "filename": "npmcli-test-package-1.0.0.tgz",
-  "files": [
-    {
-      "path": "package.json",
-      "size": "{size}",
-      "mode": 420
-    }
-  ],
-  "entryCount": 1,
-  "bundled": []
+  "@npmcli/test-package": {
+    "id": "@npmcli/test-package@1.0.0",
+    "name": "@npmcli/test-package",
+    "version": "1.0.0",
+    "size": "{size}",
+    "unpackedSize": 95,
+    "shasum": "{sha}",
+    "integrity": "{integrity}",
+    "filename": "npmcli-test-package-1.0.0.tgz",
+    "files": [
+      {
+        "path": "package.json",
+        "size": "{size}",
+        "mode": 420
+      }
+    ],
+    "entryCount": 1,
+    "bundled": []
+  }
 }
 `
 
@@ -204,6 +206,7 @@ Object {
     "man/man1/npm-search.1",
     "man/man1/npm-set.1",
     "man/man1/npm-shrinkwrap.1",
+    "man/man1/npm-stage.1",
     "man/man1/npm-star.1",
     "man/man1/npm-stars.1",
     "man/man1/npm-start.1",
@@ -258,7 +261,7 @@ exports[`test/lib/commands/publish.js TAP no auth dry-run > must match snapshot
 
 exports[`test/lib/commands/publish.js TAP no auth dry-run > warns about auth being needed 1`] = `
 Array [
-  "This command requires you to be logged in to https://registry.npmjs.org/ (dry-run)",
+  "publish This command requires you to be logged in to https://registry.npmjs.org/ (dry-run)",
 ]
 `
 
diff --git a/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs b/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs
index 3db9e9d2473285..dfc170636ee500 100644
--- a/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/docs.js.test.cjs
@@ -149,6 +149,7 @@ Array [
   "search",
   "set",
   "shrinkwrap",
+  "stage",
   "star",
   "stars",
   "start",
@@ -217,6 +218,42 @@ upon by the current project.
 
 
 
+#### \`allow-directory\`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from directories. That
+is, dependencies that point to a directory instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+\`all\` allows any directories to be installed. \`none\` prevents any
+directories from being installed. \`root\` only allows directories defined in
+your project's package.json to be installed. Also allows directory
+dependencies to be used for other commands like \`npm view\`
+
+
+
+#### \`allow-file\`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to install dependencies from tarball files. That
+is, dependencies that point to a local tarball file instead of a version or
+semver range. Please note that this could leave your tree incomplete and
+some packages may not function as intended or designed. Changing this
+setting will not remove dependencies that are already installed.
+
+\`all\` allows any tarball file to be installed. \`none\` prevents any tarball
+file from being installed. \`root\` only allows tarball files defined in your
+project's package.json to be installed. Also allows tarball file
+dependencies to be used for other commands like \`npm view\`
+
+
+
 #### \`allow-git\`
 
 * Default: "all"
@@ -225,12 +262,31 @@ upon by the current project.
 Limits the ability for npm to fetch dependencies from git references. That
 is, dependencies that point to a git repo instead of a version or semver
 range. Please note that this could leave your tree incomplete and some
-packages may not function as intended or designed.
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
 
 \`all\` allows any git dependencies to be fetched and installed. \`none\`
 prevents any git dependencies from being fetched and installed. \`root\` only
 allows git dependencies defined in your project's package.json to be fetched
-installed. Also allows git dependencies to be fetched for other commands
+and installed. Also allows git dependencies to be fetched for other commands
+like \`npm view\`
+
+
+
+#### \`allow-remote\`
+
+* Default: "all"
+* Type: "all", "none", or "root"
+
+Limits the ability for npm to fetch dependencies from urls. That is,
+dependencies that point to a tarball url instead of a version or semver
+range. Please note that this could leave your tree incomplete and some
+packages may not function as intended or designed. Changing this setting
+will not remove dependencies that are already installed.
+
+\`all\` allows any url to be installed. \`none\` prevents any url from being
+installed. \`root\` only allows urls defined in your project's package.json to
+be installed. Also allows url dependencies to be used for other commands
 like \`npm view\`
 
 
@@ -292,7 +348,13 @@ If the requested version is a \`dist-tag\` and the given tag does not pass the
 will be used. For example, \`foo@latest\` might install \`foo@1.2\` even though
 \`latest\` is \`2.0\`.
 
-This config cannot be used with: \`min-release-age\`
+If \`before\` and \`min-release-age\` are both set in the same source, \`before\`
+wins (an explicit absolute date overrides a relative window). Across
+sources, the standard precedence applies (cli > env > project > user >
+global), so a higher-priority source can always relax or override a
+lower-priority one.
+
+
 
 #### \`bin-links\`
 
@@ -1146,9 +1208,11 @@ are no versions available for the current set of dependencies, the command
 will error.
 
 This flag is a complement to \`before\`, which accepts an exact date instead
-of a relative number of days.
-
-This config cannot be used with: \`before\`
+of a relative number of days. The two may coexist (e.g. \`min-release-age\` in
+your \`.npmrc\` is preserved when npm internally spawns a sub-process with
+\`--before\` while preparing a \`git:\` or \`github:\` dependency); when both
+apply, \`before\` wins within a single source and across sources the standard
+precedence rules apply.
 
 This value is not exported to the environment for child processes.
 
@@ -2259,7 +2323,10 @@ Array [
   "access",
   "all",
   "allow-same-version",
+  "allow-directory",
+  "allow-file",
   "allow-git",
+  "allow-remote",
   "also",
   "audit",
   "audit-level",
@@ -2436,7 +2503,10 @@ Array [
   "access",
   "all",
   "allow-same-version",
+  "allow-directory",
+  "allow-file",
   "allow-git",
+  "allow-remote",
   "also",
   "audit",
   "audit-level",
@@ -2617,7 +2687,10 @@ Object {
   "_auth": null,
   "access": null,
   "all": false,
+  "allowDirectory": "all",
+  "allowFile": "all",
   "allowGit": "all",
+  "allowRemote": "all",
   "allowSameVersion": false,
   "audit": true,
   "auditLevel": null,
@@ -3051,8 +3124,9 @@ Options:
 [--global-style] [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
 [--strict-peer-deps] [--foreground-scripts] [--ignore-scripts]
-[--allow-git <all|none|root>] [--no-audit] [--no-bin-links] [--no-fund]
-[--dry-run]
+[--allow-directory <all|none|root>] [--allow-file <all|none|root>]
+[--allow-git <all|none|root>] [--allow-remote <all|none|root>] [--no-audit]
+[--no-bin-links] [--no-fund] [--dry-run]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -3080,9 +3154,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -3126,7 +3209,10 @@ aliases: clean-install, ic, install-clean, isntall-clean
 #### \`strict-peer-deps\`
 #### \`foreground-scripts\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`bin-links\`
 #### \`fund\`
@@ -3223,8 +3309,10 @@ Options:
 [--global-style] [--strict-peer-deps] [--no-package-lock]
 [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
-[--ignore-scripts] [--allow-git <all|none|root>] [--no-audit] [--no-bin-links]
-[--no-fund] [--dry-run]
+[--ignore-scripts] [--allow-directory <all|none|root>]
+[--allow-file <all|none|root>] [--allow-git <all|none|root>]
+[--allow-remote <all|none|root>] [--no-audit] [--no-bin-links] [--no-fund]
+[--dry-run]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -3252,9 +3340,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -3298,7 +3395,10 @@ alias: ddp
 #### \`omit\`
 #### \`include\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`bin-links\`
 #### \`fund\`
@@ -3948,9 +4048,11 @@ Options:
 [--global-style] [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
 [--strict-peer-deps] [--prefer-dedupe] [--no-package-lock] [--package-lock-only]
-[--foreground-scripts] [--ignore-scripts] [--allow-git <all|none|root>]
-[--no-audit] [--before <date>|--min-release-age <days>] [--no-bin-links]
-[--no-fund] [--dry-run] [--cpu <cpu>] [--os <os>] [--libc <libc>]
+[--foreground-scripts] [--ignore-scripts] [--allow-directory <all|none|root>]
+[--allow-file <all|none|root>] [--allow-git <all|none|root>]
+[--allow-remote <all|none|root>] [--no-audit] [--before <date>]
+[--min-release-age <days>] [--no-bin-links] [--no-fund] [--dry-run] [--cpu <cpu>]
+[--os <os>] [--libc <libc>]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -3996,9 +4098,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -4063,7 +4174,10 @@ aliases: add, i, in, ins, inst, insta, instal, isnt, isnta, isntal, isntall
 #### \`package-lock-only\`
 #### \`foreground-scripts\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`before\`
 #### \`min-release-age\`
@@ -4090,8 +4204,9 @@ Options:
 [--global-style] [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
 [--strict-peer-deps] [--foreground-scripts] [--ignore-scripts]
-[--allow-git <all|none|root>] [--no-audit] [--no-bin-links] [--no-fund]
-[--dry-run]
+[--allow-directory <all|none|root>] [--allow-file <all|none|root>]
+[--allow-git <all|none|root>] [--allow-remote <all|none|root>] [--no-audit]
+[--no-bin-links] [--no-fund] [--dry-run]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -4119,9 +4234,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -4165,7 +4289,10 @@ aliases: cit, clean-install-test, sit
 #### \`strict-peer-deps\`
 #### \`foreground-scripts\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`bin-links\`
 #### \`fund\`
@@ -4189,9 +4316,11 @@ Options:
 [--global-style] [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
 [--strict-peer-deps] [--prefer-dedupe] [--no-package-lock] [--package-lock-only]
-[--foreground-scripts] [--ignore-scripts] [--allow-git <all|none|root>]
-[--no-audit] [--before <date>|--min-release-age <days>] [--no-bin-links]
-[--no-fund] [--dry-run] [--cpu <cpu>] [--os <os>] [--libc <libc>]
+[--foreground-scripts] [--ignore-scripts] [--allow-directory <all|none|root>]
+[--allow-file <all|none|root>] [--allow-git <all|none|root>]
+[--allow-remote <all|none|root>] [--no-audit] [--before <date>]
+[--min-release-age <days>] [--no-bin-links] [--no-fund] [--dry-run] [--cpu <cpu>]
+[--os <os>] [--libc <libc>]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -4237,9 +4366,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -4304,7 +4442,10 @@ alias: it
 #### \`package-lock-only\`
 #### \`foreground-scripts\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`before\`
 #### \`min-release-age\`
@@ -4333,8 +4474,10 @@ Options:
 [--global-style] [--strict-peer-deps] [--no-package-lock]
 [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
-[--ignore-scripts] [--allow-git <all|none|root>] [--no-audit] [--no-bin-links]
-[--no-fund] [--dry-run]
+[--ignore-scripts] [--allow-directory <all|none|root>]
+[--allow-file <all|none|root>] [--allow-git <all|none|root>]
+[--allow-remote <all|none|root>] [--no-audit] [--no-bin-links] [--no-fund]
+[--dry-run]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
 
@@ -4371,9 +4514,18 @@ Options:
   --ignore-scripts
     If true, npm does not run scripts specified in package.json files.
 
+  --allow-directory
+    Limits the ability for npm to install dependencies from directories.
+
+  --allow-file
+    Limits the ability for npm to install dependencies from tarball files.
+
   --allow-git
     Limits the ability for npm to fetch dependencies from git references.
 
+  --allow-remote
+    Limits the ability for npm to fetch dependencies from urls.
+
   --audit
     When "true" submit audit reports alongside the current npm command to the
 
@@ -4420,7 +4572,10 @@ alias: ln
 #### \`omit\`
 #### \`include\`
 #### \`ignore-scripts\`
+#### \`allow-directory\`
+#### \`allow-file\`
 #### \`allow-git\`
+#### \`allow-remote\`
 #### \`audit\`
 #### \`bin-links\`
 #### \`fund\`
@@ -4739,7 +4894,7 @@ npm outdated [<package-spec> ...]
 Options:
 [-a|--all] [--json] [-l|--long] [-p|--parseable] [-g|--global]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
-[--before <date>|--min-release-age <days>]
+[--before <date>] [--min-release-age <days>]
 
   -a|--all
     When running \`npm outdated\` and \`npm ls\`, setting \`--all\` will show
@@ -4762,6 +4917,9 @@ Options:
   --before
     If passed to \`npm install\`, will rebuild the npm tree such that only
 
+  --min-release-age
+    If set, npm will build the npm tree such that only versions that were
+
 
 Run "npm help outdated" for more info
 
@@ -5528,6 +5686,61 @@ Note: This command is unaware of workspaces.
 NO PARAMS
 `
 
+exports[`test/lib/docs.js TAP usage stage > must match snapshot 1`] = `
+Stage packages for publishing, deferring proof-of-presence (2FA) to a later point in time
+
+Usage:
+npm stage
+npm stage publish <package-spec>
+npm stage list [<package-spec>]
+npm stage view <stage-id>
+npm stage approve <stage-id>
+npm stage reject <stage-id>
+npm stage download <stage-id>
+
+Subcommands:
+  publish
+    Stage a package for publishing, deferring proof-of-presence (2FA) to a later point in time
+
+  list
+    List all staged package versions
+
+  view
+    View details of a specific staged package
+
+  approve
+    Approve a staged package, publishing it to the npm registry
+
+  reject
+    Reject a staged package, removing it from the registry
+
+  download
+    Download the tarball of a staged package for inspection
+
+Run "npm stage <subcommand> --help" for more info on a subcommand.
+
+Run "npm help stage" for more info
+
+\`\`\`bash
+npm stage
+\`\`\`
+
+Note: This command is unaware of workspaces.
+
+#### Synopsis
+#### Flags
+#### Synopsis
+#### Flags
+#### Synopsis
+#### Flags
+#### Synopsis
+#### Flags
+#### Synopsis
+#### Flags
+#### Synopsis
+#### Flags
+`
+
 exports[`test/lib/docs.js TAP usage star > must match snapshot 1`] = `
 Mark your favorite packages
 
@@ -5804,9 +6017,9 @@ exports[`test/lib/docs.js TAP usage trust > must match snapshot 1`] = `
 Create a trusted relationship between a package and a OIDC provider
 
 Usage:
-npm trust github [package] --file [--repo|--repository] [--env|--environment] [-y|--yes]
-npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [-y|--yes]
-npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [-y|--yes]
+npm trust github [package] --file [--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
+npm trust gitlab [package] --file [--project|--repo|--repository] [--env|--environment] [--allow-publish] [--allow-stage-publish] [-y|--yes]
+npm trust circleci [package] --org-id <uuid> --project-id <uuid> --pipeline-definition-id <uuid> --vcs-origin <origin> [--context-id <uuid>...] [--allow-publish] [--allow-stage-publish] [-y|--yes]
 npm trust list [package]
 npm trust revoke [package] --id=<trust-id>
 
@@ -6006,7 +6219,7 @@ Options:
 [--omit <dev|optional|peer> [--omit <dev|optional|peer> ...]]
 [--include <prod|dev|optional|peer> [--include <prod|dev|optional|peer> ...]]
 [--strict-peer-deps] [--no-package-lock] [--foreground-scripts]
-[--ignore-scripts] [--no-audit] [--before <date>|--min-release-age <days>]
+[--ignore-scripts] [--no-audit] [--before <date>] [--min-release-age <days>]
 [--no-bin-links] [--no-fund] [--dry-run]
 [-w|--workspace <workspace-name> [-w|--workspace <workspace-name> ...]]
 [--workspaces] [--include-workspace-root] [--install-links]
@@ -6050,6 +6263,9 @@ Options:
   --before
     If passed to \`npm install\`, will rebuild the npm tree such that only
 
+  --min-release-age
+    If set, npm will build the npm tree such that only versions that were
+
   --bin-links
     Tells npm to create symlinks (or \`.cmd\` shims on Windows) for package
 
diff --git a/deps/npm/tap-snapshots/test/lib/npm.js.test.cjs b/deps/npm/tap-snapshots/test/lib/npm.js.test.cjs
index 888af047882fa7..337095989e6638 100644
--- a/deps/npm/tap-snapshots/test/lib/npm.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/npm.js.test.cjs
@@ -38,7 +38,7 @@ All commands:
     link, ll, login, logout, ls, org, outdated, owner, pack,
     ping, pkg, prefix, profile, prune, publish, query, rebuild,
     repo, restart, root, run, sbom, search, set, shrinkwrap,
-    star, stars, start, stop, team, test, token, trust,
+    stage, star, stars, start, stop, team, test, token, trust,
     undeprecate, uninstall, unpublish, unstar, update, version,
     view, whoami
 
@@ -87,13 +87,13 @@ All commands:
     query, rebuild, repo,
     restart, root, run,
     sbom, search, set,
-    shrinkwrap, star, stars,
-    start, stop, team, test,
-    token, trust,
-    undeprecate, uninstall,
-    unpublish, unstar,
-    update, version, view,
-    whoami
+    shrinkwrap, stage, star,
+    stars, start, stop,
+    team, test, token,
+    trust, undeprecate,
+    uninstall, unpublish,
+    unstar, update, version,
+    view, whoami
 
 Specify configs in the ini-formatted file:
     {USERCONFIG}
@@ -140,13 +140,13 @@ All commands:
     query, rebuild, repo,
     restart, root, run,
     sbom, search, set,
-    shrinkwrap, star, stars,
-    start, stop, team, test,
-    token, trust,
-    undeprecate, uninstall,
-    unpublish, unstar,
-    update, version, view,
-    whoami
+    shrinkwrap, stage, star,
+    stars, start, stop,
+    team, test, token,
+    trust, undeprecate,
+    uninstall, unpublish,
+    unstar, update, version,
+    view, whoami
 
 Specify configs in the ini-formatted file:
     {USERCONFIG}
@@ -181,7 +181,7 @@ All commands:
     link, ll, login, logout, ls, org, outdated, owner, pack,
     ping, pkg, prefix, profile, prune, publish, query, rebuild,
     repo, restart, root, run, sbom, search, set, shrinkwrap,
-    star, stars, start, stop, team, test, token, trust,
+    stage, star, stars, start, stop, team, test, token, trust,
     undeprecate, uninstall, unpublish, unstar, update, version,
     view, whoami
 
@@ -230,13 +230,13 @@ All commands:
     query, rebuild, repo,
     restart, root, run,
     sbom, search, set,
-    shrinkwrap, star, stars,
-    start, stop, team, test,
-    token, trust,
-    undeprecate, uninstall,
-    unpublish, unstar,
-    update, version, view,
-    whoami
+    shrinkwrap, stage, star,
+    stars, start, stop,
+    team, test, token,
+    trust, undeprecate,
+    uninstall, unpublish,
+    unstar, update, version,
+    view, whoami
 
 Specify configs in the ini-formatted file:
     {USERCONFIG}
@@ -283,13 +283,13 @@ All commands:
     query, rebuild, repo,
     restart, root, run,
     sbom, search, set,
-    shrinkwrap, star, stars,
-    start, stop, team, test,
-    token, trust,
-    undeprecate, uninstall,
-    unpublish, unstar,
-    update, version, view,
-    whoami
+    shrinkwrap, stage, star,
+    stars, start, stop,
+    team, test, token,
+    trust, undeprecate,
+    uninstall, unpublish,
+    unstar, update, version,
+    view, whoami
 
 Specify configs in the ini-formatted file:
     {USERCONFIG}
@@ -335,8 +335,9 @@ All commands:
     query, rebuild, repo,
     restart, root, run, sbom,
     search, set, shrinkwrap,
-    star, stars, start, stop,
-    team, test, token, trust,
+    stage, star, stars,
+    start, stop, team, test,
+    token, trust,
     undeprecate, uninstall,
     unpublish, unstar,
     update, version, view,
@@ -375,7 +376,7 @@ All commands:
     link, ll, login, logout, ls, org, outdated, owner, pack,
     ping, pkg, prefix, profile, prune, publish, query, rebuild,
     repo, restart, root, run, sbom, search, set, shrinkwrap,
-    star, stars, start, stop, team, test, token, trust,
+    stage, star, stars, start, stop, team, test, token, trust,
     undeprecate, uninstall, unpublish, unstar, update, version,
     view, whoami
 
@@ -412,7 +413,7 @@ All commands:
     link, ll, login, logout, ls, org, outdated, owner, pack,
     ping, pkg, prefix, profile, prune, publish, query, rebuild,
     repo, restart, root, run, sbom, search, set, shrinkwrap,
-    star, stars, start, stop, team, test, token, trust,
+    stage, star, stars, start, stop, team, test, token, trust,
     undeprecate, uninstall, unpublish, unstar, update, version,
     view, whoami
 
@@ -449,7 +450,7 @@ All commands:
     link, ll, login, logout, ls, org, outdated, owner, pack,
     ping, pkg, prefix, profile, prune, publish, query, rebuild,
     repo, restart, root, run, sbom, search, set, shrinkwrap,
-    star, stars, start, stop, team, test, token, trust,
+    stage, star, stars, start, stop, team, test, token, trust,
     undeprecate, uninstall, unpublish, unstar, update, version,
     view, whoami
 
diff --git a/deps/npm/tap-snapshots/test/lib/utils/sbom-cyclonedx.js.test.cjs b/deps/npm/tap-snapshots/test/lib/utils/sbom-cyclonedx.js.test.cjs
index 8bc81cc4f69c15..124478bc829938 100644
--- a/deps/npm/tap-snapshots/test/lib/utils/sbom-cyclonedx.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/utils/sbom-cyclonedx.js.test.cjs
@@ -142,6 +142,66 @@ exports[`test/lib/utils/sbom-cyclonedx.js TAP node - with duplicate deps > must
 }
 `
 
+exports[`test/lib/utils/sbom-cyclonedx.js TAP node - with duplicate edges to same dep > must match snapshot 1`] = `
+{
+  "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "serialNumber": "urn:uuid:00000000-0000-0000-0000-000000000000",
+  "version": 1,
+  "metadata": {
+    "timestamp": "2020-01-01T00:00:00.000Z",
+    "lifecycles": [
+      {
+        "phase": "build"
+      }
+    ],
+    "tools": [
+      {
+        "vendor": "npm",
+        "name": "cli",
+        "version": "10.0.0 "
+      }
+    ],
+    "component": {
+      "bom-ref": "root@1.0.0",
+      "type": "library",
+      "name": "root",
+      "version": "1.0.0",
+      "scope": "required",
+      "author": "Author",
+      "purl": "pkg:npm/root@1.0.0",
+      "properties": [],
+      "externalReferences": []
+    }
+  },
+  "components": [
+    {
+      "bom-ref": "dep1@0.0.1",
+      "type": "library",
+      "name": "dep1",
+      "version": "0.0.1",
+      "scope": "required",
+      "purl": "pkg:npm/dep1@0.0.1",
+      "properties": [],
+      "externalReferences": []
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "root@1.0.0",
+      "dependsOn": [
+        "dep1@0.0.1"
+      ]
+    },
+    {
+      "ref": "dep1@0.0.1",
+      "dependsOn": []
+    }
+  ]
+}
+`
+
 exports[`test/lib/utils/sbom-cyclonedx.js TAP single node - application package type > must match snapshot 1`] = `
 {
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
diff --git a/deps/npm/tap-snapshots/test/lib/utils/sbom-spdx.js.test.cjs b/deps/npm/tap-snapshots/test/lib/utils/sbom-spdx.js.test.cjs
index 26931d78124a70..6adb6d26de1435 100644
--- a/deps/npm/tap-snapshots/test/lib/utils/sbom-spdx.js.test.cjs
+++ b/deps/npm/tap-snapshots/test/lib/utils/sbom-spdx.js.test.cjs
@@ -271,6 +271,73 @@ exports[`test/lib/utils/sbom-spdx.js TAP node - with duplicate deps > must match
 }
 `
 
+exports[`test/lib/utils/sbom-spdx.js TAP node - with duplicate edges to same dep > must match snapshot 1`] = `
+{
+  "spdxVersion": "SPDX-2.3",
+  "dataLicense": "CC0-1.0",
+  "SPDXID": "SPDXRef-DOCUMENT",
+  "name": "root@1.0.0",
+  "documentNamespace": "docns",
+  "creationInfo": {
+    "created": "2020-01-01T00:00:00.000Z",
+    "creators": [
+      "Tool: npm/cli-10.0.0 "
+    ]
+  },
+  "documentDescribes": [
+    "SPDXRef-Package-root-1.0.0"
+  ],
+  "packages": [
+    {
+      "name": "root",
+      "SPDXID": "SPDXRef-Package-root-1.0.0",
+      "versionInfo": "1.0.0",
+      "packageFileName": "",
+      "downloadLocation": "NOASSERTION",
+      "filesAnalyzed": false,
+      "homepage": "NOASSERTION",
+      "licenseDeclared": "NOASSERTION",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/root@1.0.0"
+        }
+      ]
+    },
+    {
+      "name": "dep1",
+      "SPDXID": "SPDXRef-Package-dep1-0.0.1",
+      "versionInfo": "0.0.1",
+      "packageFileName": "node_modules/dep1",
+      "downloadLocation": "NOASSERTION",
+      "filesAnalyzed": false,
+      "homepage": "NOASSERTION",
+      "licenseDeclared": "NOASSERTION",
+      "externalRefs": [
+        {
+          "referenceCategory": "PACKAGE-MANAGER",
+          "referenceType": "purl",
+          "referenceLocator": "pkg:npm/dep1@0.0.1"
+        }
+      ]
+    }
+  ],
+  "relationships": [
+    {
+      "spdxElementId": "SPDXRef-DOCUMENT",
+      "relatedSpdxElement": "SPDXRef-Package-root-1.0.0",
+      "relationshipType": "DESCRIBES"
+    },
+    {
+      "spdxElementId": "SPDXRef-Package-dep1-0.0.1",
+      "relatedSpdxElement": "SPDXRef-Package-root-1.0.0",
+      "relationshipType": "DEPENDENCY_OF"
+    }
+  ]
+}
+`
+
 exports[`test/lib/utils/sbom-spdx.js TAP single node - application package type > must match snapshot 1`] = `
 {
   "spdxVersion": "SPDX-2.3",
diff --git a/deps/npm/test/lib/commands/install.js b/deps/npm/test/lib/commands/install.js
index 584690b68b5c62..2aa56a3dcd1759 100644
--- a/deps/npm/test/lib/commands/install.js
+++ b/deps/npm/test/lib/commands/install.js
@@ -242,6 +242,7 @@ t.test('exec commands', async t => {
     const { npm } = await loadMockNpm(t, {
       config: {
         'allow-git': 'none',
+        audit: false,
       },
     })
     await t.rejects(
@@ -257,7 +258,8 @@ t.test('exec commands', async t => {
   t.test('allow-git=root refuses non-root git dependency', async t => {
     const { npm } = await loadMockNpm(t, {
       config: {
-        'allow-git': 'none',
+        'allow-git': 'root',
+        audit: false,
       },
       prefixDir: {
         'package.json': JSON.stringify({ name: '@npmcli/test-package', version: '1.0.0' }),
@@ -268,7 +270,129 @@ t.test('exec commands', async t => {
     })
     await t.rejects(
       npm.exec('install', ['./abbrev']),
-      /Fetching packages of type "git" have been disabled/
+      /Fetching non-root packages of type "git" have been disabled/
+    )
+  })
+
+  t.test('allow-directory=none blocks default symlink install', async t => {
+    const { npm } = await loadMockNpm(t, {
+      config: {
+        'allow-directory': 'none',
+        audit: false,
+      },
+      prefixDir: {
+        'package.json': JSON.stringify({
+          name: '@npmcli/test-package',
+          version: '1.0.0',
+          dependencies: { 'dir-dep': 'file:./dir-dep' },
+        }),
+        'dir-dep': {
+          'package.json': JSON.stringify({ name: 'dir-dep', version: '1.0.0' }),
+        },
+      },
+    })
+    await t.rejects(
+      npm.exec('install', []),
+      {
+        code: 'EALLOWDIRECTORY',
+        message: 'Fetching packages of type "directory" have been disabled',
+      }
+    )
+  })
+
+  t.test('allow-directory=root permits top-level directory dependency', async t => {
+    const { npm } = await loadMockNpm(t, {
+      config: {
+        'allow-directory': 'root',
+        audit: false,
+      },
+      prefixDir: {
+        'package.json': JSON.stringify({
+          name: '@npmcli/test-package',
+          version: '1.0.0',
+          dependencies: { 'dir-dep': 'file:./dir-dep' },
+        }),
+        'dir-dep': {
+          'package.json': JSON.stringify({ name: 'dir-dep', version: '1.0.0' }),
+        },
+      },
+    })
+    await npm.exec('install', [])
+    const installedPkg = require(path.join(npm.prefix, 'node_modules', 'dir-dep', 'package.json'))
+    t.equal(installedPkg.name, 'dir-dep', 'dir-dep is installed and readable through node_modules')
+  })
+
+  t.test('allow-git=root soft-skips transitive optional git dependency', async t => {
+    const { npm } = await loadMockNpm(t, {
+      config: {
+        'allow-git': 'root',
+        audit: false,
+      },
+      prefixDir: {
+        'package.json': JSON.stringify({ name: '@npmcli/test-package', version: '1.0.0' }),
+        abbrev: {
+          'package.json': JSON.stringify({
+            name: 'abbrev',
+            version: '1.0.0',
+            optionalDependencies: { npm: 'npm/npm' },
+          }),
+        },
+      },
+    })
+    await npm.exec('install', ['./abbrev'])
+    t.ok(
+      fs.existsSync(path.join(npm.prefix, 'node_modules', 'abbrev', 'package.json')),
+      'abbrev (the legitimate parent) is installed'
+    )
+    t.notOk(
+      fs.existsSync(path.join(npm.prefix, 'node_modules', 'npm')),
+      'optional transitive git dep is silently skipped'
+    )
+  })
+
+  t.test('allow-remote=none does not block registry tarballs', async t => {
+    const { npm, registry } = await loadMockNpm(t, {
+      config: {
+        'allow-remote': 'none',
+        audit: false,
+      },
+      prefixDir: {
+        'package.json': JSON.stringify({
+          ...packageJson,
+          dependencies: { abbrev: '^1.0.0' },
+        }),
+        abbrev,
+      },
+    })
+    const manifest = registry.manifest({ name: 'abbrev' })
+    await registry.package({ manifest })
+    await registry.tarball({
+      manifest: manifest.versions['1.0.0'],
+      tarball: path.join(npm.prefix, 'abbrev'),
+    })
+    await npm.exec('install', [])
+    const installed = require(path.join(npm.prefix, 'node_modules', 'abbrev', 'package.json'))
+    t.equal(installed.name, 'abbrev', 'registry dep is installed despite allow-remote=none')
+  })
+
+  t.test('allow-remote=none still blocks a user-supplied remote URL', async t => {
+    const { npm } = await loadMockNpm(t, {
+      config: {
+        'allow-remote': 'none',
+        audit: false,
+      },
+      prefixDir: {
+        'package.json': JSON.stringify({
+          name: '@npmcli/test-package',
+          version: '1.0.0',
+          dependencies: { abbrev: 'https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz' },
+        }),
+      },
+    })
+    await t.rejects(
+      npm.exec('install', []),
+      { code: 'EALLOWREMOTE' },
+      'user-supplied remote URL is still blocked'
     )
   })
 })
diff --git a/deps/npm/test/lib/commands/stage/approve.js b/deps/npm/test/lib/commands/stage/approve.js
new file mode 100644
index 00000000000000..d62ea04d431014
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/approve.js
@@ -0,0 +1,72 @@
+const t = require('tap')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm.js')
+const MockRegistry = require('@npmcli/mock-registry')
+
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+const stageId = '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f'
+
+t.test('approves a staged package', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post(`/-/stage/${stageId}/approve`)
+    .reply(201, { message: 'Package version approved and published successfully.' })
+  await npm.exec('stage', ['approve', stageId])
+  t.match(joinedOutput(), /approved and published successfully/)
+})
+
+t.test('throws usageError without stage-id', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['approve']), {
+    code: 'EUSAGE',
+  })
+})
+
+t.test('throws on invalid uuid', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['approve', 'not-a-uuid']), {
+    message: /stage-id must be a valid UUID/,
+  })
+})
+
+t.test('throws on 404 (stage-id not found)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post(`/-/stage/${stageId}/approve`)
+    .reply(404, { error: 'Not found' })
+  await t.rejects(npm.exec('stage', ['approve', stageId]), {
+    statusCode: 404,
+  })
+})
+
+t.test('throws on 403 (not an owner)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post(`/-/stage/${stageId}/approve`)
+    .reply(403, { error: 'You do not have permission to approve this package' })
+  await t.rejects(npm.exec('stage', ['approve', stageId]), {
+    statusCode: 403,
+  })
+})
diff --git a/deps/npm/test/lib/commands/stage/download.js b/deps/npm/test/lib/commands/stage/download.js
new file mode 100644
index 00000000000000..807c1282edc863
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/download.js
@@ -0,0 +1,139 @@
+const t = require('tap')
+const fs = require('node:fs')
+const path = require('node:path')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm.js')
+const MockRegistry = require('@npmcli/mock-registry')
+const mockGlobals = require('@npmcli/mock-globals')
+const libpack = require('libnpmpack')
+
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+const stageId = '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f'
+
+t.test('downloads a staged tarball', async t => {
+  const { npm, joinedOutput, prefix } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: '@npmcli/test-package',
+        version: '1.0.0',
+      }),
+      'index.js': 'module.exports = 42',
+    },
+  })
+  const tarballData = await libpack(prefix)
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageId}/tarball`)
+    .reply(200, tarballData, { 'content-type': 'application/octet-stream' })
+
+  mockGlobals(t, { 'process.cwd': () => prefix })
+
+  await npm.exec('stage', ['download', stageId])
+  const out = joinedOutput()
+  const expectedFilename = `npmcli-test-package-1.0.0-${stageId}.tgz`
+  t.match(out, expectedFilename)
+  t.ok(fs.existsSync(path.join(prefix, expectedFilename)))
+})
+
+t.test('downloads with --json', async t => {
+  const { npm, joinedOutput, prefix } = await loadMockNpm(t, {
+    config: { ...authConfig, json: true },
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: '@npmcli/test-package',
+        version: '1.0.0',
+      }),
+    },
+  })
+  const tarballData = await libpack(prefix)
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageId}/tarball`)
+    .reply(200, tarballData, { 'content-type': 'application/octet-stream' })
+
+  mockGlobals(t, { 'process.cwd': () => prefix })
+
+  await npm.exec('stage', ['download', stageId])
+  const out = joinedOutput()
+  t.notMatch(out, `npmcli-test-package-1.0.0-${stageId}.tgz`)
+  const expectedFilename = `npmcli-test-package-1.0.0-${stageId}.tgz`
+  t.ok(fs.existsSync(path.join(prefix, expectedFilename)))
+})
+
+t.test('throws usageError without stage-id', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['download']), {
+    code: 'EUSAGE',
+  })
+})
+
+t.test('throws on invalid uuid', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['download', 'not-a-uuid']), {
+    message: /stage-id must be a valid UUID/,
+  })
+})
+
+t.test('throws on 404 (stage-id not found)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageId}/tarball`)
+    .reply(404, { error: 'Not found' })
+  await t.rejects(npm.exec('stage', ['download', stageId]), {
+    statusCode: 404,
+  })
+})
+
+t.test('throws on 403 (not an owner)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageId}/tarball`)
+    .reply(403, { error: 'You do not have permission to download this package' })
+  await t.rejects(npm.exec('stage', ['download', stageId]), {
+    statusCode: 403,
+  })
+})
+
+t.test('throws when tarball has no package.json', async t => {
+  const { npm, prefix } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {},
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  // Empty tar (two 512-byte zero blocks) has no entries
+  registry.nock.get(`/-/stage/${stageId}/tarball`)
+    .reply(200, Buffer.alloc(1024), { 'content-type': 'application/octet-stream' })
+
+  mockGlobals(t, { 'process.cwd': () => prefix })
+
+  await t.rejects(npm.exec('stage', ['download', stageId]), {
+    message: /Could not read package.json from tarball/,
+  })
+})
diff --git a/deps/npm/test/lib/commands/stage/index.js b/deps/npm/test/lib/commands/stage/index.js
new file mode 100644
index 00000000000000..bd81c7aab5e42e
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/index.js
@@ -0,0 +1,332 @@
+const t = require('tap')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm')
+const MockRegistry = require('@npmcli/mock-registry')
+const path = require('node:path')
+const fs = require('node:fs')
+
+const pkg = '@npmcli/test-package'
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+
+const pkgJson = {
+  name: pkg,
+  description: 'npm test package',
+  version: '1.0.0',
+}
+
+t.test('stages a package from cwd', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\+ @npmcli\/test-package@1\.0\.0 \(staged\)/)
+})
+
+t.test('stages with --dry-run', async t => {
+  const { npm, joinedOutput, logs } = await loadMockNpm(t, {
+    config: { ...authConfig, 'dry-run': true },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  await npm.exec('stage', ['publish'])
+  t.ok(logs.notice.some(n => /Staging to .* \(dry-run\)/.test(n)))
+  t.match(joinedOutput(), /\+ @npmcli\/test-package@1\.0\.0 \(staged\)/)
+})
+
+t.test('stages with --json', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, json: true },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  const out = JSON.parse(joinedOutput())
+  t.equal(out[pkg].name, pkg)
+  t.equal(out[pkg].version, '1.0.0')
+})
+
+t.test('stages with --json includes stageId', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, json: true },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  const stageId = 'f8e7a45b-7a5f-4f31-8e6d-9dd1c6ef38c0'
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, { stageId })
+  await npm.exec('stage', ['publish'])
+  const out = JSON.parse(joinedOutput())
+  t.equal(out[pkg].name, pkg)
+  t.equal(out[pkg].stageId, stageId)
+})
+
+t.test('completion returns subcommands', async t => {
+  const Stage = require('../../../../lib/commands/stage/index.js')
+  const res = await Stage.completion({ conf: { argv: { remain: ['npm', 'stage'] } } })
+  t.strictSame(res, ['publish', 'list', 'view', 'approve', 'reject', 'download'])
+})
+
+t.test('completion returns empty for subcommand', async t => {
+  const Stage = require('../../../../lib/commands/stage/index.js')
+  const res = await Stage.completion({ conf: { argv: { remain: ['npm', 'stage', 'publish'] } } })
+  t.strictSame(res, [])
+})
+
+t.test('throws on invalid semver tag', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig, tag: '1.0.0' },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  await t.rejects(npm.exec('stage', ['publish']), {
+    message: /Tag name must not be a valid SemVer range/,
+  })
+})
+
+t.test('throws ENEEDAUTH with no credentials', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: {},
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  await t.rejects(npm.exec('stage', ['publish']), {
+    code: 'ENEEDAUTH',
+  })
+})
+
+t.test('warns on --dry-run with no credentials', async t => {
+  const { npm, logs } = await loadMockNpm(t, {
+    config: { 'dry-run': true },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  await npm.exec('stage', ['publish'])
+  t.match(logs.warn, [/requires you to be logged in.*\(dry-run\)/])
+})
+
+t.test('stages a package with positional arg', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish', '.'])
+  t.match(joinedOutput(), /\+ @npmcli\/test-package@1\.0\.0 \(staged\)/)
+})
+
+t.test('respects ignore-scripts', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, 'ignore-scripts': true },
+    prefixDir: {
+      'package.json': JSON.stringify({
+        ...pkgJson,
+        scripts: {
+          prepublishOnly: 'exit 1',
+          publish: 'exit 1',
+          postpublish: 'exit 1',
+        },
+      }),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\(staged\)/)
+})
+
+t.test('foreground-scripts can be set to false', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, 'foreground-scripts': false },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\(staged\)/)
+})
+
+t.test('runs lifecycle scripts', async t => {
+  const { npm, prefix } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify({
+        ...pkgJson,
+        scripts: {
+          prepublishOnly: 'touch scripts-prepublishonly',
+          publish: 'touch scripts-publish',
+          postpublish: 'touch scripts-postpublish',
+        },
+      }),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.equal(fs.existsSync(path.join(prefix, 'scripts-prepublishonly')), true)
+  t.equal(fs.existsSync(path.join(prefix, 'scripts-publish')), true)
+  t.equal(fs.existsSync(path.join(prefix, 'scripts-postpublish')), true)
+})
+
+t.test('respects publishConfig', async t => {
+  const alternateRegistry = 'https://other.registry.npmjs.org'
+  const { npm, joinedOutput, logs } = await loadMockNpm(t, {
+    config: {
+      [`${alternateRegistry.slice(6)}/:_authToken`]: 'test-other-token',
+    },
+    prefixDir: {
+      'package.json': JSON.stringify({
+        ...pkgJson,
+        publishConfig: {
+          registry: alternateRegistry,
+          other: 'unknown-key',
+        },
+      }),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: alternateRegistry,
+    authorization: 'test-other-token',
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\(staged\)/)
+  t.match(logs.warn, [/Unknown publishConfig/])
+})
+
+t.test('warns about auto-corrected package.json errors', async t => {
+  const { npm, logs } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: pkg,
+        version: '1.0.0',
+        repository: 'github:user/repo',
+      }),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.ok(logs.warn.some(w => /auto-corrected/.test(w)))
+  t.ok(logs.warn.some(w => /errors corrected/.test(w)))
+})
+
+t.test('stages with basic auth (username)', async t => {
+  const basic = Buffer.from('test-user:test-password').toString('base64')
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: {
+      '//registry.npmjs.org/:username': 'test-user',
+      '//registry.npmjs.org/:_password': Buffer.from('test-password').toString('base64'),
+    },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    basic,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\(staged\)/)
+})
+
+t.test('stages with cert auth', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: {
+      '//registry.npmjs.org/:certfile': '/path/to/cert',
+      '//registry.npmjs.org/:keyfile': '/path/to/key',
+    },
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, {})
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /\(staged\)/)
+})
+
+t.test('throws EPRIVATE for private packages', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify({ ...pkgJson, private: true }),
+    },
+  })
+  await t.rejects(npm.exec('stage', ['publish']), {
+    code: 'EPRIVATE',
+  })
+})
+
+t.test('outputs stageId when returned', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: authConfig,
+    prefixDir: {
+      'package.json': JSON.stringify(pkgJson),
+    },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.post('/-/stage/package/@npmcli%2ftest-package').reply(201, { stageId: 'abc-123' })
+  await npm.exec('stage', ['publish'])
+  t.match(joinedOutput(), /staged with id abc-123/)
+})
diff --git a/deps/npm/test/lib/commands/stage/list.js b/deps/npm/test/lib/commands/stage/list.js
new file mode 100644
index 00000000000000..e66680db8277f2
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/list.js
@@ -0,0 +1,147 @@
+const t = require('tap')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm.js')
+const MockRegistry = require('@npmcli/mock-registry')
+
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+
+const stageItems = [
+  {
+    id: '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f',
+    packageName: '@npmcli/example-package',
+    version: '1.2.3',
+    tag: 'latest',
+    createdAt: '2026-03-16T09:00:00.000Z',
+    actor: 'octocat',
+    actorType: 'user',
+    shasum: '4f7f5f1d5bcf2f72f6e4d6c4f3b2812d8a2f6c19',
+  },
+  {
+    id: 'f8e7a45b-7a5f-4f31-8e6d-9dd1c6ef38c0',
+    packageName: 'example-lib',
+    version: '0.4.0',
+    tag: 'next',
+    createdAt: '2026-03-15T18:22:11.000Z',
+    actor: 'npm-bot',
+    actorType: 'trusted automation',
+    shasum: '8eb3b4e9b6e3d0d2c86be1e6d4f43f4be62e80ad',
+  },
+]
+
+t.test('lists all staged packages', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get('/-/stage?page=0&perPage=100')
+    .reply(200, { items: stageItems, page: 0, perPage: 100, total: 2 })
+  await npm.exec('stage', ['list'])
+  const out = joinedOutput()
+  t.match(out, 'package name: @npmcli/example-package')
+  t.match(out, 'package name: example-lib')
+  t.match(out, 'version: 1.2.3')
+  t.match(out, 'version: 0.4.0')
+})
+
+t.test('lists with package filter', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get('/-/stage?page=0&perPage=100&package=%40npmcli%2Fexample-package')
+    .reply(200, { items: [stageItems[0]], page: 0, perPage: 100, total: 1 })
+  await npm.exec('stage', ['list', '@npmcli/example-package'])
+  const out = joinedOutput()
+  t.match(out, '@npmcli/example-package')
+  t.notMatch(out, 'example-lib')
+})
+
+t.test('lists with --json', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, json: true },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get('/-/stage?page=0&perPage=100')
+    .reply(200, { items: stageItems, page: 0, perPage: 100, total: 2 })
+  await npm.exec('stage', ['list'])
+  const out = JSON.parse(joinedOutput())
+  t.equal(out.length, 2)
+  t.equal(out[0].packageName, '@npmcli/example-package')
+  t.equal(out[0].id, '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f', 'uuid id is not redacted')
+})
+
+t.test('shows message when no packages', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get('/-/stage?page=0&perPage=100')
+    .reply(200, { items: [], page: 0, perPage: 100, total: 0 })
+  await npm.exec('stage', ['list'])
+  t.match(joinedOutput(), 'No staged packages found.')
+})
+
+t.test('shows filtered message when no packages with filter', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get('/-/stage?page=0&perPage=100&package=nonexistent')
+    .reply(200, { items: [], page: 0, perPage: 100, total: 0 })
+  await npm.exec('stage', ['list', 'nonexistent'])
+  t.match(joinedOutput(), 'No staged versions of package name "nonexistent".')
+})
+
+t.test('throws on version specifier', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  await t.rejects(npm.exec('stage', ['list', 'area@1.0.0']), {
+    code: 'EUSAGE',
+  })
+})
+
+t.test('paginates through multiple pages', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  // page 0: 100 items, total 101
+  const page0Items = Array.from({ length: 100 }, (_, i) => ({
+    ...stageItems[0],
+    id: `id-${i}`,
+    version: `1.0.${i}`,
+  }))
+  registry.nock.get('/-/stage?page=0&perPage=100')
+    .reply(200, { items: page0Items, page: 0, perPage: 100, total: 101 })
+  registry.nock.get('/-/stage?page=1&perPage=100')
+    .reply(200, { items: [stageItems[1]], page: 1, perPage: 100, total: 101 })
+  await npm.exec('stage', ['list'])
+  const out = joinedOutput()
+  t.match(out, 'version: 1.0.0')
+  t.match(out, 'version: 0.4.0')
+})
diff --git a/deps/npm/test/lib/commands/stage/reject.js b/deps/npm/test/lib/commands/stage/reject.js
new file mode 100644
index 00000000000000..d021075a245230
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/reject.js
@@ -0,0 +1,72 @@
+const t = require('tap')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm.js')
+const MockRegistry = require('@npmcli/mock-registry')
+
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+const stageId = '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f'
+
+t.test('rejects a staged package', async t => {
+  const { npm, joinedOutput, logs } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.delete(`/-/stage/${stageId}`).reply(204)
+  await npm.exec('stage', ['reject', stageId])
+  t.match(joinedOutput(), /has been rejected/)
+  t.match(logs.warn, [/permanently delete/])
+})
+
+t.test('throws usageError without stage-id', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['reject']), {
+    code: 'EUSAGE',
+  })
+})
+
+t.test('throws on invalid uuid', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['reject', 'not-a-uuid']), {
+    message: /stage-id must be a valid UUID/,
+  })
+})
+
+t.test('throws on 404 (stage-id not found)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.delete(`/-/stage/${stageId}`)
+    .reply(404, { error: 'Not found' })
+  await t.rejects(npm.exec('stage', ['reject', stageId]), {
+    statusCode: 404,
+  })
+})
+
+t.test('throws on 403 (not an owner)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: { ...authConfig, otp: '123456' },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.delete(`/-/stage/${stageId}`)
+    .reply(403, { error: 'You do not have permission to reject this package' })
+  await t.rejects(npm.exec('stage', ['reject', stageId]), {
+    statusCode: 403,
+  })
+})
diff --git a/deps/npm/test/lib/commands/stage/view.js b/deps/npm/test/lib/commands/stage/view.js
new file mode 100644
index 00000000000000..604caf98fb23b0
--- /dev/null
+++ b/deps/npm/test/lib/commands/stage/view.js
@@ -0,0 +1,100 @@
+const t = require('tap')
+const { load: loadMockNpm } = require('../../../fixtures/mock-npm.js')
+const MockRegistry = require('@npmcli/mock-registry')
+
+const token = 'test-auth-token'
+const authConfig = { '//registry.npmjs.org/:_authToken': token }
+
+const stageItem = {
+  id: '1de6f3db-2ed9-4d72-b3dd-8f0e2b474a2f',
+  packageName: '@npmcli/example-package',
+  version: '1.2.3',
+  tag: 'latest',
+  createdAt: '2026-03-16T09:00:00.000Z',
+  actor: 'octocat',
+  actorType: 'user',
+  shasum: '4f7f5f1d5bcf2f72f6e4d6c4f3b2812d8a2f6c19',
+}
+
+t.test('views a staged package', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageItem.id}`).reply(200, stageItem)
+  await npm.exec('stage', ['view', stageItem.id])
+  const out = joinedOutput()
+  t.match(out, /id:/)
+  t.match(out, 'package name: @npmcli/example-package')
+  t.match(out, 'version: 1.2.3')
+})
+
+t.test('views with --json', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: { ...authConfig, json: true },
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageItem.id}`).reply(200, stageItem)
+  await npm.exec('stage', ['view', stageItem.id])
+  const out = JSON.parse(joinedOutput())
+  t.ok(out.id)
+  t.equal(out.packageName, '@npmcli/example-package')
+})
+
+t.test('throws usageError without stage-id', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['view']), {
+    code: 'EUSAGE',
+  })
+})
+
+t.test('throws on invalid uuid', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  await t.rejects(npm.exec('stage', ['view', 'not-a-uuid']), {
+    message: /stage-id must be a valid UUID/,
+  })
+})
+
+t.test('throws on 404 (stage-id not found)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageItem.id}`)
+    .reply(404, { error: 'Not found' })
+  await t.rejects(npm.exec('stage', ['view', stageItem.id]), {
+    statusCode: 404,
+  })
+})
+
+t.test('throws on 403 (not an owner)', async t => {
+  const { npm } = await loadMockNpm(t, {
+    config: authConfig,
+  })
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: token,
+  })
+  registry.nock.get(`/-/stage/${stageItem.id}`)
+    .reply(403, { error: 'You do not have permission to view this package' })
+  await t.rejects(npm.exec('stage', ['view', stageItem.id]), {
+    statusCode: 403,
+  })
+})
diff --git a/deps/npm/test/lib/commands/trust/circleci.js b/deps/npm/test/lib/commands/trust/circleci.js
index 1ceec9a6e5845f..51211785c57484 100644
--- a/deps/npm/test/lib/commands/trust/circleci.js
+++ b/deps/npm/test/lib/commands/trust/circleci.js
@@ -44,6 +44,7 @@ t.test('circleci with all options provided', async t => {
     '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
     '--vcs-origin', 'github.com/owner/repo',
     '--context-id', '123e4567-e89b-12d3-a456-426614174000',
+    '--allow-publish',
   ])
 })
 
@@ -85,6 +86,7 @@ t.test('circleci without optional context-id', async t => {
     '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
     '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
     '--vcs-origin', 'github.com/owner/repo',
+    '--allow-publish',
   ])
 })
 
@@ -128,6 +130,7 @@ t.test('circleci with multiple context-ids', async t => {
     '--vcs-origin', 'github.com/owner/repo',
     '--context-id', '123e4567-e89b-12d3-a456-426614174000',
     '--context-id', 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
+    '--allow-publish',
   ])
 })
 
@@ -152,6 +155,7 @@ t.test('circleci missing required org-id', async t => {
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /org-id is required/ }
   )
@@ -178,6 +182,7 @@ t.test('circleci missing required project-id', async t => {
       '--org-id', '550e8400-e29b-41d4-a716-446655440000',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /project-id is required/ }
   )
@@ -204,6 +209,7 @@ t.test('circleci missing required pipeline-definition-id', async t => {
       '--org-id', '550e8400-e29b-41d4-a716-446655440000',
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--vcs-origin', 'github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /pipeline-definition-id is required/ }
   )
@@ -230,6 +236,7 @@ t.test('circleci missing required vcs-origin', async t => {
       '--org-id', '550e8400-e29b-41d4-a716-446655440000',
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+      '--allow-publish',
     ]),
     { message: /vcs-origin is required/ }
   )
@@ -257,6 +264,7 @@ t.test('circleci with invalid org-id uuid format', async t => {
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /org-id must be a valid UUID/ }
   )
@@ -284,6 +292,7 @@ t.test('circleci with invalid vcs-origin format', async t => {
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'invalid-format',
+      '--allow-publish',
     ]),
     { message: /vcs-origin must be in format 'provider\/owner\/repo'/ }
   )
@@ -311,6 +320,7 @@ t.test('circleci with vcs-origin containing scheme prefix', async t => {
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'https://github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /vcs-origin must not include a scheme/ }
   )
@@ -336,6 +346,7 @@ t.test('circleci missing package name', async t => {
       '--project-id', '7c9e6679-7425-40de-944b-e07fc1f90ae7',
       '--pipeline-definition-id', '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
       '--vcs-origin', 'github.com/owner/repo',
+      '--allow-publish',
     ]),
     { message: /Package name must be specified either as an argument or in package.json file/ }
   )
diff --git a/deps/npm/test/lib/commands/trust/github.js b/deps/npm/test/lib/commands/trust/github.js
index a2b16d272bde15..6cc65bff354d00 100644
--- a/deps/npm/test/lib/commands/trust/github.js
+++ b/deps/npm/test/lib/commands/trust/github.js
@@ -35,7 +35,7 @@ t.test('github with all options provided', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'owner/repo', '--environment', 'production'])
+  await npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'owner/repo', '--environment', 'production', '--allow-publish'])
 })
 
 t.test('github with invalid repository format', async t => {
@@ -61,7 +61,7 @@ t.test('github with invalid repository format', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'invalid']),
+    npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'invalid', '--allow-publish']),
     { message: /must be specified in the format owner\/repository/ }
   )
 })
@@ -89,7 +89,7 @@ t.test('github with file as path', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--yes', '--file', '.github/workflows/ci.yml', '--repository', 'owner/repo']),
+    npm.exec('trust', ['github', packageName, '--yes', '--file', '.github/workflows/ci.yml', '--repository', 'owner/repo', '--allow-publish']),
     { message: /must be just a file not a path/ }
   )
 })
@@ -124,7 +124,7 @@ t.test('github without environment', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'owner/repo'])
+  await npm.exec('trust', ['github', packageName, '--yes', '--file', 'workflow.yml', '--repository', 'owner/repo', '--allow-publish'])
 })
 
 t.test('bodyToOptions with all fields', t => {
diff --git a/deps/npm/test/lib/commands/trust/gitlab.js b/deps/npm/test/lib/commands/trust/gitlab.js
index 0b60196830c5f7..16f3804f978962 100644
--- a/deps/npm/test/lib/commands/trust/gitlab.js
+++ b/deps/npm/test/lib/commands/trust/gitlab.js
@@ -35,7 +35,7 @@ t.test('gitlab with all options provided', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'group/subgroup/repo', '--environment', 'production'])
+  await npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'group/subgroup/repo', '--environment', 'production', '--allow-publish'])
 })
 
 t.test('gitlab with invalid project format', async t => {
@@ -61,7 +61,7 @@ t.test('gitlab with invalid project format', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'invalid']),
+    npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'invalid', '--allow-publish']),
     { message: /must be specified in the format/ }
   )
 })
@@ -89,7 +89,7 @@ t.test('gitlab with file as path', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab/ci.yml', '--project', 'group/repo']),
+    npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab/ci.yml', '--project', 'group/repo', '--allow-publish']),
     { message: /must be just a file not a path/ }
   )
 })
@@ -124,7 +124,7 @@ t.test('gitlab without environment', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'group/repo'])
+  await npm.exec('trust', ['gitlab', packageName, '--yes', '--file', '.gitlab-ci.yml', '--project', 'group/repo', '--allow-publish'])
 })
 
 t.test('bodyToOptions with all fields', t => {
diff --git a/deps/npm/test/lib/trust-cmd.js b/deps/npm/test/lib/trust-cmd.js
index f0c52aadbd2c4a..57d70702818a52 100644
--- a/deps/npm/test/lib/trust-cmd.js
+++ b/deps/npm/test/lib/trust-cmd.js
@@ -32,7 +32,7 @@ t.test('trust-cmd via trust github with read function called', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 })
 
 t.test('trust-cmd via trust github with all options', async t => {
@@ -57,7 +57,77 @@ t.test('trust-cmd via trust github with all options', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli', '--environment', 'production'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli', '--environment', 'production'])
+})
+
+t.test('trust-cmd via trust github with --allow-stage-publish', async t => {
+  const { npm } = await loadMockNpm(t, {
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: packageName,
+        version: '1.0.0',
+      }),
+    },
+    config: {
+      '//registry.npmjs.org/:_authToken': 'test-auth-token',
+      yes: true,
+    },
+  })
+
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: 'test-auth-token',
+  })
+
+  registry.trustCreate({ packageName })
+
+  await npm.exec('trust', ['github', '--allow-stage-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+})
+
+t.test('trust-cmd via trust github with --allow-staged-publish alias', async t => {
+  const { npm } = await loadMockNpm(t, {
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: packageName,
+        version: '1.0.0',
+      }),
+    },
+    config: {
+      '//registry.npmjs.org/:_authToken': 'test-auth-token',
+      yes: true,
+    },
+  })
+
+  const registry = new MockRegistry({
+    tap: t,
+    registry: npm.config.get('registry'),
+    authorization: 'test-auth-token',
+  })
+
+  registry.trustCreate({ packageName })
+
+  await npm.exec('trust', ['github', '--allow-staged-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+})
+
+t.test('trust-cmd via trust github missing permissions', async t => {
+  const { npm } = await loadMockNpm(t, {
+    prefixDir: {
+      'package.json': JSON.stringify({
+        name: packageName,
+        version: '1.0.0',
+      }),
+    },
+    config: {
+      '//registry.npmjs.org/:_authToken': 'test-auth-token',
+      yes: true,
+    },
+  })
+
+  await t.rejects(
+    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    { message: /At least one permission flag is required/ }
+  )
 })
 
 t.test('trust-cmd via trust github infers from package.json', async t => {
@@ -91,7 +161,7 @@ t.test('trust-cmd via trust github infers from package.json', async t => {
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', '--yes', '--file', 'workflow.yml'])
+  await npm.exec('trust', ['github', '--allow-publish', '--yes', '--file', 'workflow.yml'])
 })
 
 t.test('trust-cmd via trust github with dry-run', async t => {
@@ -108,7 +178,7 @@ t.test('trust-cmd via trust github with dry-run', async t => {
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 
   t.ok(joinedOutput().includes('Establishing trust'), 'shows notice about establishing trust')
 })
@@ -122,7 +192,7 @@ t.test('trust-cmd via trust github missing package name', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: /Package name must be specified/ },
     'throws when no package name'
   )
@@ -141,7 +211,7 @@ t.test('trust-cmd via trust github missing file', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--repository', 'npm/cli']),
     { message: /must be specified with the file option/ },
     'throws when no file'
   )
@@ -160,7 +230,7 @@ t.test('trust-cmd via trust github invalid file extension', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.txt', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.txt', '--repository', 'npm/cli']),
     { message: /must end in \.yml or \.yaml/ },
     'throws when file has wrong extension'
   )
@@ -179,7 +249,7 @@ t.test('trust-cmd via trust github missing repository', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml']),
     { message: /must be specified with repository option/ },
     'throws when no repository'
   )
@@ -200,7 +270,7 @@ t.test('trust-cmd via trust github with custom registry warning', async t => {
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 
   t.ok(logs.warn.some(l => l.includes('may not support trusted publishing')), 'warns about custom registry')
 })
@@ -220,7 +290,7 @@ t.test('trust-cmd via trust github with --json', async t => {
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 
   const output = joinedOutput()
   t.ok(output.includes(packageName), 'JSON output includes package name')
@@ -250,7 +320,7 @@ t.test('trust-cmd via trust github with user confirmation no', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: 'User cancelled operation' },
     'throws when user declines'
   )
@@ -271,7 +341,7 @@ t.test('trust-cmd via trust github with --no-yes', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: 'User cancelled operation' },
     'throws when --no-yes flag is set'
   )
@@ -300,7 +370,7 @@ t.test('trust-cmd via trust github with invalid answer', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: 'User cancelled operation' },
     'throws when user gives invalid answer'
   )
@@ -336,7 +406,7 @@ t.test('trust-cmd via trust github with user confirmation Y uppercase', async t
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 })
 
 t.test('trust-cmd via trust github with user enters empty string', async t => {
@@ -362,7 +432,7 @@ t.test('trust-cmd via trust github with user enters empty string', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: 'User cancelled operation' },
     'throws when user enters empty string'
   )
@@ -383,7 +453,7 @@ t.test('trust-cmd via trust github with mismatched repo type', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', '--file', 'workflow.yml']),
+    npm.exec('trust', ['github', '--allow-publish', '--file', 'workflow.yml']),
     { message: /Repository in package.json is not a GitHub repository/ },
     'throws when repository type does not match provider'
   )
@@ -404,7 +474,7 @@ t.test('trust-cmd via trust github with mismatched repo type but flag provided',
     },
   })
 
-  await npm.exec('trust', ['github', '--file', 'workflow.yml', '--repository', 'owner/new-repo'])
+  await npm.exec('trust', ['github', '--allow-publish', '--file', 'workflow.yml', '--repository', 'owner/new-repo'])
 
   t.ok(logs.warn.some(l => l.includes('Repository in package.json is not a GitHub repository')), 'warns about repository type mismatch')
 })
@@ -424,7 +494,7 @@ t.test('trust-cmd via trust github with different repo in package.json', async t
     },
   })
 
-  await npm.exec('trust', ['github', '--file', 'workflow.yml', '--repository', 'owner/new-repo'])
+  await npm.exec('trust', ['github', '--allow-publish', '--file', 'workflow.yml', '--repository', 'owner/new-repo'])
 
   t.ok(logs.warn.some(l => l.includes('differs from provided')), 'warns about repository mismatch')
 })
@@ -459,7 +529,7 @@ t.test('trust-cmd via trust github with user confirmation yes spelled out', asyn
 
   registry.trustCreate({ packageName })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 })
 
 t.test('trust-cmd via trust github showing response with id and type', async t => {
@@ -500,7 +570,7 @@ t.test('trust-cmd via trust github showing response with id and type', async t =
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 
   const output = joinedOutput()
   t.ok(output.includes('type:'), 'output shows type field')
@@ -520,7 +590,7 @@ t.test('trust-cmd via trust github missing repository when package name differs'
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml']),
     { message: /must be specified with repository option/ },
     'throws when no repository and package name differs'
   )
@@ -619,7 +689,7 @@ t.test('trust-cmd via trust github showing fromPackageJson indicator', async t =
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml'])
 
   const output = joinedOutput()
   t.ok(output.includes('from package.json'), 'output shows fromPackageJson indicator')
@@ -663,7 +733,7 @@ t.test('trust-cmd via trust github showing URLs for fields', async t => {
     },
   })
 
-  await npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
+  await npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli'])
 
   const output = joinedOutput()
   t.match(output, /https:\/\/github\.com\/npm\/cli\b/, 'output shows repository URL')
@@ -684,7 +754,7 @@ t.test('trust-cmd via trust github with yes=false flag', async t => {
   })
 
   await t.rejects(
-    npm.exec('trust', ['github', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
+    npm.exec('trust', ['github', '--allow-publish', packageName, '--file', 'workflow.yml', '--repository', 'npm/cli']),
     { message: /User cancelled operation/ },
     'throws when yes is explicitly false'
   )
@@ -846,3 +916,28 @@ t.test('TrustCommand - logOptions with urls but all values are null', async t =>
   t.ok(output.includes('file'), 'shows file field')
   t.notOk(output.includes('Links to verify manually'), 'does not show links header when all urls are null')
 })
+
+t.test('formatPermissions with unknown permission falls back to raw value', t => {
+  const result = TrustCommand.formatPermissions(['unknownPermission'])
+  t.equal(result, 'unknownPermission', 'returns raw value for unknown permission')
+  t.end()
+})
+
+t.test('displayResponseBody with empty body', async t => {
+  const { npm, joinedOutput } = await loadMockNpm(t, {
+    config: {
+      '//registry.npmjs.org/:_authToken': 'test-auth-token',
+    },
+  })
+
+  class TestTrustCmd extends TrustCommand {
+    static name = 'test'
+    static description = 'Test command'
+  }
+
+  const cmd = new TestTrustCmd(npm)
+  cmd.displayResponseBody({ body: [], packageName: '@npmcli/test-package' })
+
+  const output = joinedOutput()
+  t.match(output, /No trust configurations found/, 'shows no configurations message')
+})
diff --git a/deps/npm/test/lib/utils/display.js b/deps/npm/test/lib/utils/display.js
index 89c4a855028490..b33ab69a365944 100644
--- a/deps/npm/test/lib/utils/display.js
+++ b/deps/npm/test/lib/utils/display.js
@@ -271,6 +271,35 @@ t.test('Display.clean', async (t) => {
   }
 })
 
+t.test('json output redacts by default', async t => {
+  // Do not set redact: false globally in the json flush path of display.js.
+  // If a command needs unredacted output (e.g. UUIDs), pass
+  // { [META]: true, redact: false } at the call site via output.standard().
+  const { META } = require('proc-log')
+  const { output, outputs, clearOutput } = await mockDisplay(t)
+
+  output.buffer({
+    url: 'https://registry.npmjs.org/',
+    id: '550e8400-e29b-41d4-a716-446655440000',
+  })
+  output.flush({ [META]: true, json: true })
+
+  t.equal(outputs.length, 1, 'one output')
+  const parsed = JSON.parse(outputs[0])
+  t.equal(parsed.id, '***', 'uuid values are redacted in json output')
+
+  // commands that need unredacted output should use output.standard
+  // with redact: false at the call site instead of disabling globally
+  clearOutput()
+  output.standard(
+    JSON.stringify({ id: '550e8400-e29b-41d4-a716-446655440000' }, null, 2),
+    { [META]: true, redact: false }
+  )
+  const inlineParsed = JSON.parse(outputs[0])
+  t.equal(inlineParsed.id, '550e8400-e29b-41d4-a716-446655440000',
+    'inline redact: false preserves uuid values')
+})
+
 t.test('prompt functionality', async t => {
   t.test('regular prompt completion works', async t => {
     const { input } = await mockDisplay(t)
diff --git a/deps/npm/test/lib/utils/key-values.js b/deps/npm/test/lib/utils/key-values.js
new file mode 100644
index 00000000000000..5e61f9e55fe596
--- /dev/null
+++ b/deps/npm/test/lib/utils/key-values.js
@@ -0,0 +1,84 @@
+const t = require('tap')
+const { logObject, logStageItem, defaultPredicate } = require('../../../lib/utils/key-values.js')
+const { load: loadMockNpm } = require('../../fixtures/mock-npm.js')
+
+t.test('defaultPredicate skips null and undefined', t => {
+  const chalk = { green: v => v }
+  t.equal(defaultPredicate('k', null, chalk), null)
+  t.equal(defaultPredicate('k', undefined, chalk), null)
+  t.equal(defaultPredicate('k', 'val', chalk), 'val')
+  t.end()
+})
+
+t.test('logObject json mode', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logObject({ a: 1, b: 2 }, { chalk, json: true })
+  const out = JSON.parse(joinedOutput())
+  t.same(out, { a: 1, b: 2 })
+})
+
+t.test('logObject skips null values with default predicate', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logObject({ a: 'yes', b: null, c: 'also' }, { chalk })
+  const out = joinedOutput()
+  t.match(out, /a: yes/)
+  t.match(out, /c: also/)
+  t.notMatch(out, /b:/)
+})
+
+t.test('logStageItem includes extra properties', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logStageItem({
+    id: 'abc',
+    packageName: 'pkg',
+    version: '1.0.0',
+    tag: 'latest',
+    createdAt: '2026-01-01',
+    actor: 'user',
+    actorType: 'human',
+    shasum: 'sha1',
+    extra: 'bonus',
+  }, { chalk })
+  const out = joinedOutput()
+  t.match(out, /extra: bonus/)
+  t.match(out, /package name: pkg/)
+})
+
+t.test('logObject with custom predicate', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logObject({ a: 'one', b: 'two' }, {
+    chalk,
+    predicate: (key, value) => `[${value}]`,
+  })
+  const out = joinedOutput()
+  t.match(out, /a: \[one\]/)
+  t.match(out, /b: \[two\]/)
+})
+
+t.test('logStageItem without actorType shows actor alone', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logStageItem({
+    id: 'abc',
+    packageName: 'pkg',
+    version: '1.0.0',
+    tag: 'latest',
+    createdAt: '2026-01-01',
+    actor: 'user',
+    shasum: 'sha1',
+  }, { chalk })
+  const out = joinedOutput()
+  t.match(out, /staged by: user/)
+  t.notMatch(out, /\(/)
+})
+
+t.test('logObject with all values skipped produces no output', async t => {
+  const { joinedOutput } = await loadMockNpm(t)
+  const chalk = { cyan: v => v, green: v => v }
+  logObject({ a: null, b: undefined }, { chalk })
+  t.equal(joinedOutput(), '')
+})
diff --git a/deps/npm/test/lib/utils/sbom-cyclonedx.js b/deps/npm/test/lib/utils/sbom-cyclonedx.js
index fc30130f1fae72..ea569d41c57d8b 100644
--- a/deps/npm/test/lib/utils/sbom-cyclonedx.js
+++ b/deps/npm/test/lib/utils/sbom-cyclonedx.js
@@ -291,6 +291,25 @@ t.test('node - with duplicate deps', t => {
   t.end()
 })
 
+t.test('node - with duplicate edges to same dep', t => {
+  // A node can have multiple outgoing edges resolving to the same
+  // `name@version` (e.g. a direct `dep1: ^1` plus an alias
+  // `dep1-aliased: npm:dep1@^1`). The resulting `dependsOn` array must
+  // still contain each ref at most once, since CycloneDX 1.5 requires
+  // unique items.
+  const node = {
+    ...root,
+    edgesOut: [
+      { to: dep1 },
+      { to: dep1 },
+    ],
+  }
+  const res = cyclonedxOutput({ npm, nodes: [node, dep1] })
+  t.same(res.dependencies[0].dependsOn, ['dep1@0.0.1'])
+  t.matchSnapshot(JSON.stringify(res))
+  t.end()
+})
+
 // Check that all of the generated test snapshots validate against the CycloneDX schema
 t.test('schema validation', t => {
   // Load schemas
diff --git a/deps/npm/test/lib/utils/sbom-spdx.js b/deps/npm/test/lib/utils/sbom-spdx.js
index cdeb68218ee332..d2599b0824510c 100644
--- a/deps/npm/test/lib/utils/sbom-spdx.js
+++ b/deps/npm/test/lib/utils/sbom-spdx.js
@@ -256,6 +256,27 @@ t.test('node - with duplicate deps', t => {
   t.end()
 })
 
+t.test('node - with duplicate edges to same dep', t => {
+  // A node can have multiple outgoing edges resolving to the same
+  // `name@version` of the same edge type (e.g. a direct `dep1: ^1` plus an
+  // alias `dep1-aliased: npm:dep1@^1`). The resulting relationships must
+  // still be unique per (source, target, type) triple.
+  const node = { ...root,
+    edgesOut: [
+      { to: dep1 },
+      { to: dep1 },
+    ] }
+  const res = spdxOutput({ npm, nodes: [node, dep1] })
+  const depRels = res.relationships.filter(
+    r => r.spdxElementId === 'SPDXRef-Package-dep1-0.0.1'
+      && r.relatedSpdxElement === 'SPDXRef-Package-root-1.0.0'
+      && r.relationshipType === 'DEPENDENCY_OF'
+  )
+  t.equal(depRels.length, 1)
+  t.matchSnapshot(JSON.stringify(res))
+  t.end()
+})
+
 // Check that all of the generated test snapshots validate against the SPDX schema
 t.test('schema validation', t => {
   const ajv = new Ajv()
diff --git a/deps/npm/test/lib/utils/tar.js b/deps/npm/test/lib/utils/tar.js
index 85a95e57766855..3eff023ccec999 100644
--- a/deps/npm/test/lib/utils/tar.js
+++ b/deps/npm/test/lib/utils/tar.js
@@ -109,6 +109,20 @@ t.test('should log tarball contents with unicode', async (t) => {
   t.end()
 })
 
+t.test('logTar with json and no key emits bare tarball object', async (t) => {
+  const buffered = []
+  const logTar = tmock(t, '{LIB}/utils/tar.js', {
+    'proc-log': {
+      log: { notice: () => {} },
+      output: { buffer: (data) => buffered.push(data) },
+    },
+  }).logTar
+
+  const tarball = { name: 'my-pkg', version: '1.0.0' }
+  logTar(tarball, { json: true })
+  t.strictSame(buffered, [tarball], 'buffers the bare tarball when key is omitted')
+})
+
 t.test('should getContents of a tarball with only a package.json', async (t) => {
   const testDir = t.testdir({
     'package.json': JSON.stringify({

From a7d544697ad037e2d0054309851d1af948bb72e8 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Fri, 22 May 2026 18:14:47 -0700
Subject: [PATCH 81/83] stream: propagate abort reason in share and broadcast

Pass signal.reason to the multi-consumer cancel paths so signal abort
is reported as AbortError instead of clean iterator completion.

Also make detached share consumers rethrow a stored source error when
they resume after cancellation, preserving the abort reason for pending
pulls.

Fixes: https://github.com/nodejs/node/issues/63357

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63358
Fixes: https://github.com/nodejs/node/issues/63357
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/streams/iter/broadcast.js        |  6 +-
 lib/internal/streams/iter/share.js            |  7 +-
 .../test-stream-iter-broadcast-from.js        | 22 +++---
 test/parallel/test-stream-iter-share-async.js | 76 ++++++++++++++++---
 4 files changed, 87 insertions(+), 24 deletions(-)

diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js
index 7b6fc3525d122f..e6a404729d6e0b 100644
--- a/lib/internal/streams/iter/broadcast.js
+++ b/lib/internal/streams/iter/broadcast.js
@@ -686,6 +686,10 @@ function wireBroadcastWriteSignal(entry, signal, resolve, reject, self) {
   signal.addEventListener('abort', onAbort, { __proto__: null, once: true });
 }
 
+function onBroadcastCancel(broadcastImpl, signal) {
+  onSignalAbort(signal, () => broadcastImpl.cancel(signal.reason));
+}
+
 // =============================================================================
 // Public API
 // =============================================================================
@@ -720,7 +724,7 @@ function broadcast(options = { __proto__: null }) {
   broadcastImpl.setWriter(writer);
 
   if (signal) {
-    onSignalAbort(signal, () => broadcastImpl.cancel());
+    onBroadcastCancel(broadcastImpl, signal);
   }
 
   return { __proto__: null, writer, broadcast: broadcastImpl };
diff --git a/lib/internal/streams/iter/share.js b/lib/internal/streams/iter/share.js
index 0160bc7eace009..3cd24409222712 100644
--- a/lib/internal/streams/iter/share.js
+++ b/lib/internal/streams/iter/share.js
@@ -144,6 +144,7 @@ class ShareImpl {
             // cursor must re-pull rather than terminating prematurely.
             for (;;) {
               if (state.detached) {
+                if (self.#sourceError) throw self.#sourceError;
                 return { __proto__: null, done: true, value: undefined };
               }
 
@@ -628,6 +629,10 @@ class SyncShareImpl {
   }
 }
 
+function onShareCancel(shareImpl, signal) {
+  onSignalAbort(signal, () => shareImpl.cancel(signal.reason));
+}
+
 // =============================================================================
 // Public API
 // =============================================================================
@@ -657,7 +662,7 @@ function share(source, options = { __proto__: null }) {
   const shareImpl = new ShareImpl(normalized, opts);
 
   if (signal) {
-    onSignalAbort(signal, () => shareImpl.cancel());
+    onShareCancel(shareImpl, signal);
   }
 
   return shareImpl;
diff --git a/test/parallel/test-stream-iter-broadcast-from.js b/test/parallel/test-stream-iter-broadcast-from.js
index 2f17b1a7de92fa..c7458dee19ad64 100644
--- a/test/parallel/test-stream-iter-broadcast-from.js
+++ b/test/parallel/test-stream-iter-broadcast-from.js
@@ -70,11 +70,12 @@ async function testAbortSignal() {
 
   ac.abort();
 
-  const batches = [];
-  for await (const batch of consumer) {
-    batches.push(batch);
-  }
-  assert.strictEqual(batches.length, 0);
+  await assert.rejects(async () => {
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of consumer) {
+      assert.fail('Should not reach here');
+    }
+  }, { name: 'AbortError' });
 }
 
 async function testAlreadyAbortedSignal() {
@@ -84,11 +85,12 @@ async function testAlreadyAbortedSignal() {
   const { broadcast: bc } = broadcast({ signal: ac.signal });
   const consumer = bc.push();
 
-  const batches = [];
-  for await (const batch of consumer) {
-    batches.push(batch);
-  }
-  assert.strictEqual(batches.length, 0);
+  await assert.rejects(async () => {
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of consumer) {
+      assert.fail('Should not reach here');
+    }
+  }, { name: 'AbortError' });
 }
 
 // =============================================================================
diff --git a/test/parallel/test-stream-iter-share-async.js b/test/parallel/test-stream-iter-share-async.js
index 86b0eb9b273a34..076fe0a4037aa0 100644
--- a/test/parallel/test-stream-iter-share-async.js
+++ b/test/parallel/test-stream-iter-share-async.js
@@ -134,16 +134,66 @@ async function testShareCancelWithReason() {
 
 async function testShareAbortSignal() {
   const ac = new AbortController();
-  const shared = share(from('data'), { signal: ac.signal });
-  const consumer = shared.pull();
+  const reason = new Error('share aborted');
+  const enc = new TextEncoder();
+  async function* source() {
+    yield [enc.encode('a')];
+    yield [enc.encode('b')];
+  }
+  const shared = share(source(), {
+    highWaterMark: 1,
+    backpressure: 'block',
+    signal: ac.signal,
+  });
+  const fast = shared.pull()[Symbol.asyncIterator]();
+  shared.pull();
+
+  await fast.next();
+  const read = fast.next();
+  const rejected = assert.rejects(read, (error) => error === reason);
+  ac.abort(reason);
+
+  await rejected;
+}
+
+async function testShareAbortSignalWhileSourcePullPending() {
+  const ac = new AbortController();
+  const {
+    promise: resumePromise,
+    resolve: resume,
+  } = Promise.withResolvers();
+  const {
+    promise: sourceStartedPromise,
+    resolve: sourceStarted,
+  } = Promise.withResolvers();
+
+  const source = {
+    __proto__: null,
+    [Symbol.asyncIterator]() {
+      return {
+        __proto__: null,
+        async next() {
+          sourceStarted();
+          await resumePromise;
+          return { __proto__: null, done: true, value: undefined };
+        },
+      };
+    },
+  };
+
+  const shared = share(source, { signal: ac.signal });
+  const iter1 = shared.pull()[Symbol.asyncIterator]();
+  const iter2 = shared.pull()[Symbol.asyncIterator]();
+  const read1 = iter1.next();
+  const read2 = iter2.next();
+  const rejected1 = assert.rejects(read1, { name: 'AbortError' });
+  const rejected2 = assert.rejects(read2, { name: 'AbortError' });
 
+  await sourceStartedPromise;
   ac.abort();
+  resume();
 
-  const batches = [];
-  for await (const batch of consumer) {
-    batches.push(batch);
-  }
-  assert.strictEqual(batches.length, 0);
+  await Promise.all([rejected1, rejected2]);
 }
 
 async function testShareAlreadyAborted() {
@@ -153,11 +203,12 @@ async function testShareAlreadyAborted() {
   const shared = share(from('data'), { signal: ac.signal });
   const consumer = shared.pull();
 
-  const batches = [];
-  for await (const batch of consumer) {
-    batches.push(batch);
-  }
-  assert.strictEqual(batches.length, 0);
+  await assert.rejects(async () => {
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of consumer) {
+      assert.fail('Should not reach here');
+    }
+  }, { name: 'AbortError' });
 }
 
 // =============================================================================
@@ -273,6 +324,7 @@ Promise.all([
   testShareCancelMidIteration(),
   testShareCancelWithReason(),
   testShareAbortSignal(),
+  testShareAbortSignalWhileSourcePullPending(),
   testShareAlreadyAborted(),
   testShareSourceError(),
   testShareLateJoiningConsumer(),

From 8d3245e551eb98f910119595a7c9103eae7744a4 Mon Sep 17 00:00:00 2001
From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com>
Date: Fri, 22 May 2026 20:18:56 -0700
Subject: [PATCH 82/83] stream: avoid duplicate writes in toWritable

PushWriter can return false after accepting a chunk when block
backpressure is active. Teach the classic Writable adapter to treat
that case as accepted backpressure instead of retrying through the
async write path.

Fixes: https://github.com/nodejs/node/issues/63359

Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: https://github.com/nodejs/node/pull/63360
Fixes: https://github.com/nodejs/node/issues/63359
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/streams/iter/classic.js          | 51 ++++++++++++++++---
 lib/internal/streams/iter/push.js             | 12 +++++
 lib/internal/streams/iter/types.js            | 13 +++++
 .../test-stream-iter-writable-from.js         | 49 ++++++++++++++++++
 4 files changed, 119 insertions(+), 6 deletions(-)

diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js
index fd5f811ea52d97..73c6bc48b954c8 100644
--- a/lib/internal/streams/iter/classic.js
+++ b/lib/internal/streams/iter/classic.js
@@ -57,6 +57,7 @@ const {
 const {
   toAsyncStreamable: kToAsyncStreamable,
   kValidatedSource,
+  kSyncWriteAccepted,
   drainableProtocol,
 } = require('internal/streams/iter/types');
 
@@ -764,13 +765,41 @@ function toWritable(writer) {
   const hasEndSync = hasEnd &&
                      typeof writer.endSync === 'function';
   const hasFail = typeof writer.fail === 'function';
+  const hasSyncWriteAccepted =
+    typeof writer[kSyncWriteAccepted] === 'function';
 
-  // Try-sync-first pattern: attempt the synchronous method and
-  // fall back to the async method if it returns false (indicating
-  // the sync path was not accepted) or throws. When the sync path
-  // succeeds, the callback is deferred via queueMicrotask to
-  // preserve the async resolution contract that Writable internals
-  // expect from _write/_writev/_final callbacks.
+  function syncWriteAccepted() {
+    return hasSyncWriteAccepted && writer[kSyncWriteAccepted]();
+  }
+
+  function finishAfterSyncBackpressure(cb) {
+    let ondrain;
+    try {
+      if (typeof writer[drainableProtocol] === 'function') {
+        ondrain = writer[drainableProtocol]();
+      }
+    } catch (err) {
+      cb(err);
+      return;
+    }
+    if (ondrain !== null && ondrain !== undefined) {
+      PromisePrototypeThen(ondrain, (drained) => {
+        if (drained === false) {
+          cb(new ERR_INVALID_STATE.TypeError('Stream closed by consumer'));
+          return;
+        }
+        cb();
+      }, cb);
+      return;
+    }
+    queueMicrotask(cb);
+  }
+
+  // Try-sync-first pattern: attempt the synchronous method and fall back to the
+  // async method if it returns false without accepting the data, or if it
+  // throws. When the sync path succeeds, the callback is deferred via
+  // queueMicrotask to preserve the async resolution contract that Writable
+  // internals expect from _write/_writev/_final callbacks.
 
   function _write(chunk, encoding, cb) {
     const bytes = typeof chunk === 'string' ?
@@ -781,6 +810,11 @@ function toWritable(writer) {
           queueMicrotask(cb);
           return;
         }
+        if (syncWriteAccepted()) {
+          // The chunk was accepted; false only signaled backpressure.
+          finishAfterSyncBackpressure(cb);
+          return;
+        }
       } catch {
         // Sync path threw -- fall through to async.
       }
@@ -805,6 +839,11 @@ function toWritable(writer) {
           queueMicrotask(cb);
           return;
         }
+        if (syncWriteAccepted()) {
+          // The chunks were accepted; false only signaled backpressure.
+          finishAfterSyncBackpressure(cb);
+          return;
+        }
       } catch {
         // Sync path threw -- fall through to async.
       }
diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js
index c5b12663f83c24..1c367ff02bae71 100644
--- a/lib/internal/streams/iter/push.js
+++ b/lib/internal/streams/iter/push.js
@@ -32,6 +32,7 @@ const {
 
 const {
   drainableProtocol,
+  kSyncWriteAccepted,
   kSyncWriteAcceptedOnFalse,
 } = require('internal/streams/iter/types');
 
@@ -545,11 +546,16 @@ class PushQueue {
 
 class PushWriter {
   #queue;
+  #syncWriteAccepted = false;
 
   constructor(queue) {
     this.#queue = queue;
   }
 
+  [kSyncWriteAccepted]() {
+    return this.#syncWriteAccepted;
+  }
+
   [drainableProtocol]() {
     const desired = this.desiredSize;
     if (desired === null) return null;
@@ -589,6 +595,7 @@ class PushWriter {
   }
 
   writeSync(chunk) {
+    this.#syncWriteAccepted = false;
     const bytes = toUint8Array(chunk);
     const result = this.#queue.writeSync([bytes]);
     if (!result && this.#queue.backpressurePolicy === 'block' &&
@@ -596,12 +603,15 @@ class PushWriter {
       // Block policy: force-enqueue and return false as backpressure signal.
       // Data IS accepted; false tells caller to slow down.
       this.#queue.forceEnqueue([bytes]);
+      this.#syncWriteAccepted = true;
       return false;
     }
+    this.#syncWriteAccepted = result;
     return result;
   }
 
   writevSync(chunks) {
+    this.#syncWriteAccepted = false;
     if (!ArrayIsArray(chunks)) {
       throw new ERR_INVALID_ARG_TYPE('chunks', 'Array', chunks);
     }
@@ -610,8 +620,10 @@ class PushWriter {
     if (!result && this.#queue.backpressurePolicy === 'block' &&
         this.#queue.desiredSize === 0) {
       this.#queue.forceEnqueue(bytes);
+      this.#syncWriteAccepted = true;
       return false;
     }
+    this.#syncWriteAccepted = result;
     return result;
   }
 
diff --git a/lib/internal/streams/iter/types.js b/lib/internal/streams/iter/types.js
index 71112b1515c081..e72972d91ad243 100644
--- a/lib/internal/streams/iter/types.js
+++ b/lib/internal/streams/iter/types.js
@@ -64,11 +64,24 @@ const kValidatedTransform = Symbol('kValidatedTransform');
  */
 const kValidatedSource = Symbol('kValidatedSource');
 
+/**
+ * Internal sentinel for writers whose sync write methods can return false
+ * after accepting data as a backpressure signal.
+ */
+const kSyncWriteAccepted = Symbol('kSyncWriteAccepted');
+
+/**
+ * Internal sentinel for writers whose sync write methods may return false
+ * after accepting data when backpressure is applied. Such writers must expose
+ * desiredSize so callers can distinguish accepted backpressure from a sync
+ * write that was not performed.
+ */
 const kSyncWriteAcceptedOnFalse = Symbol('kSyncWriteAcceptedOnFalse');
 
 module.exports = {
   broadcastProtocol,
   drainableProtocol,
+  kSyncWriteAccepted,
   kSyncWriteAcceptedOnFalse,
   kValidatedSource,
   kValidatedTransform,
diff --git a/test/parallel/test-stream-iter-writable-from.js b/test/parallel/test-stream-iter-writable-from.js
index fd922c5cf99537..51dc465b45d148 100644
--- a/test/parallel/test-stream-iter-writable-from.js
+++ b/test/parallel/test-stream-iter-writable-from.js
@@ -335,6 +335,53 @@ async function testRoundTrip() {
   assert.strictEqual(result, data);
 }
 
+// =============================================================================
+// PushWriter writeSync false accepted as backpressure is not retried
+// =============================================================================
+
+async function testPushWriterBlockBackpressureNoDuplicate() {
+  const { writer, readable } = push({ highWaterMark: 1, backpressure: 'block' });
+  const writable = toWritable(writer);
+
+  await new Promise((resolve, reject) => {
+    writable.write('a', (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+
+  writable.write('b');
+  writable.end();
+
+  const result = await text(readable);
+  assert.strictEqual(result, 'ab');
+}
+
+// =============================================================================
+// PushWriter writevSync false accepted as backpressure is not retried
+// =============================================================================
+
+async function testPushWriterBlockBackpressureWritevNoDuplicate() {
+  const { writer, readable } = push({ highWaterMark: 1, backpressure: 'block' });
+  const writable = toWritable(writer);
+
+  await new Promise((resolve, reject) => {
+    writable.write('a', (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+
+  writable.cork();
+  writable.write('b');
+  writable.write('c');
+  writable.uncork();
+  writable.end();
+
+  const result = await text(readable);
+  assert.strictEqual(result, 'abc');
+}
+
 // =============================================================================
 // Multiple sequential writes
 // =============================================================================
@@ -590,6 +637,8 @@ Promise.all([
   testWriteThrowsSyncPropagation(),
   testEndThrowsSyncPropagation(),
   testRoundTrip(),
+  testPushWriterBlockBackpressureNoDuplicate(),
+  testPushWriterBlockBackpressureWritevNoDuplicate(),
   testSequentialWrites(),
   testSyncCallbackDeferred(),
   testMinimalWriter(),

From e665005cc290f4ca443956d5204955f5b31ff8db Mon Sep 17 00:00:00 2001
From: Premiermoney <devjava21@proton.me>
Date: Sat, 23 May 2026 08:54:19 -0400
Subject: [PATCH 83/83] Create node.js.yml

Signed-off-by: Premiermoney <devjava21@proton.me>
---
 .github/workflows/node.js.yml | 52 +++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 .github/workflows/node.js.yml

diff --git a/.github/workflows/node.js.yml b/.github/workflows/node.js.yml
new file mode 100644
index 00000000000000..b3c9c1b527b802
--- /dev/null
+++ b/.github/workflows/node.js.yml
@@ -0,0 +1,52 @@
+# Docker has specific installation instructions for each operating system.
+# Please refer to the official documentation at https://docker.com/get-started/
+
+# Pull the Node.js Docker image:
+docker pull node:26-slim
+
+# Create a Node.js container and start a Shell session:
+docker run -it --rm --entrypoint sh node:26-slim
+
+# Verify the Node.js version:
+node -v # Should print "v26.2.0".
+
+# Install Corepack:
+npm install -g corepack
+
+# Download and install pnpm:
+corepack enable pnpm
+
+# Verify pnpm version:
+pnpm -v
+
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test