@ggui-ai/ui-gen 0.20.0 → 0.22.0

package/dist/evaluation/index.js

@@ -1,59 +1,26 @@
-import { readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, unlinkSync, existsSync, rm, createReadStream, createWriteStream } from 'fs';
-import 'fs/promises';
-import { tmpdir } from 'os';
-import { resolve, dirname, join, basename } from 'path';
-import { Readable } from 'stream';
-import { pipeline } from 'stream/promises';
-import { createBrotliDecompress, createUnzip } from 'zlib';
-import { fileURLToPath } from 'url';
 import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
+import { anthropicRejectsForcedToolChoice, normalizeAnthropicModelId, listContractGadgets, HOOK_NAME_RE, STDLIB_GADGETS_PACKAGE, isRecord, anthropicRejectsSamplingParams, APP_GENERATION_PROFILE_BOUNDS } from '@ggui-ai/protocol';
 import Anthropic from '@anthropic-ai/sdk';
 import { z } from 'zod';
 import { LUCIDE_ICON_NAMES, maxWidth } from '@ggui-ai/design';
-import { listContractGadgets, HOOK_NAME_RE, STDLIB_GADGETS_PACKAGE, APP_GENERATION_PROFILE_BOUNDS } from '@ggui-ai/protocol';
 import { createHash } from 'crypto';
 import { build } from 'esbuild';
 import { getCssTokens, composeThemeCss, fillFitRule } from '@ggui-ai/design/rendering';
+import { readFileSync, readdirSync, statSync, mkdtempSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { resolve, relative, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import { tmpdir } from 'os';
 
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  __defProp(target, "default", { value: mod, enumerable: true }) ,
-  mod
-));
 
 // src/adapters/openrouter/types.ts
 var OpenRouterError;
@@ -132,3287 +99,38 @@ var init_client = __esm({
         if (!response.ok) {
           const errorBody = await response.json().catch(() => ({ error: { message: response.statusText } }));
           const message = errorBody.error?.message ?? response.statusText;
-          throw new OpenRouterError(message, response.status, void 0, response.headers);
-        }
-        if (!response.body) {
-          throw new OpenRouterError("No response body for streaming request", 500);
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-              const trimmed = line.trim();
-              if (!trimmed || trimmed.startsWith(":")) continue;
-              if (trimmed === "data: [DONE]") return;
-              if (!trimmed.startsWith("data: ")) continue;
-              const json = trimmed.slice("data: ".length);
-              try {
-                yield JSON.parse(json);
-              } catch {
-              }
-            }
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-    };
-  }
-});
-
-// ../../node_modules/events-universal/default.js
-var require_default = __commonJS({
-  "../../node_modules/events-universal/default.js"(exports, module) {
-    module.exports = __require("events");
-  }
-});
-
-// ../../node_modules/fast-fifo/fixed-size.js
-var require_fixed_size = __commonJS({
-  "../../node_modules/fast-fifo/fixed-size.js"(exports, module) {
-    module.exports = class FixedFIFO {
-      constructor(hwm) {
-        if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
-        this.buffer = new Array(hwm);
-        this.mask = hwm - 1;
-        this.top = 0;
-        this.btm = 0;
-        this.next = null;
-      }
-      clear() {
-        this.top = this.btm = 0;
-        this.next = null;
-        this.buffer.fill(void 0);
-      }
-      push(data) {
-        if (this.buffer[this.top] !== void 0) return false;
-        this.buffer[this.top] = data;
-        this.top = this.top + 1 & this.mask;
-        return true;
-      }
-      shift() {
-        const last = this.buffer[this.btm];
-        if (last === void 0) return void 0;
-        this.buffer[this.btm] = void 0;
-        this.btm = this.btm + 1 & this.mask;
-        return last;
-      }
-      peek() {
-        return this.buffer[this.btm];
-      }
-      isEmpty() {
-        return this.buffer[this.btm] === void 0;
-      }
-    };
-  }
-});
-
-// ../../node_modules/fast-fifo/index.js
-var require_fast_fifo = __commonJS({
-  "../../node_modules/fast-fifo/index.js"(exports, module) {
-    var FixedFIFO = require_fixed_size();
-    module.exports = class FastFIFO {
-      constructor(hwm) {
-        this.hwm = hwm || 16;
-        this.head = new FixedFIFO(this.hwm);
-        this.tail = this.head;
-        this.length = 0;
-      }
-      clear() {
-        this.head = this.tail;
-        this.head.clear();
-        this.length = 0;
-      }
-      push(val) {
-        this.length++;
-        if (!this.head.push(val)) {
-          const prev = this.head;
-          this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-          this.head.push(val);
-        }
-      }
-      shift() {
-        if (this.length !== 0) this.length--;
-        const val = this.tail.shift();
-        if (val === void 0 && this.tail.next) {
-          const next = this.tail.next;
-          this.tail.next = null;
-          this.tail = next;
-          return this.tail.shift();
-        }
-        return val;
-      }
-      peek() {
-        const val = this.tail.peek();
-        if (val === void 0 && this.tail.next) return this.tail.next.peek();
-        return val;
-      }
-      isEmpty() {
-        return this.length === 0;
-      }
-    };
-  }
-});
-
-// ../../node_modules/b4a/index.js
-var require_b4a = __commonJS({
-  "../../node_modules/b4a/index.js"(exports, module) {
-    function isBuffer(value) {
-      return Buffer.isBuffer(value) || value instanceof Uint8Array;
-    }
-    function isEncoding(encoding) {
-      return Buffer.isEncoding(encoding);
-    }
-    function alloc(size, fill2, encoding) {
-      return Buffer.alloc(size, fill2, encoding);
-    }
-    function allocUnsafe(size) {
-      return Buffer.allocUnsafe(size);
-    }
-    function allocUnsafeSlow(size) {
-      return Buffer.allocUnsafeSlow(size);
-    }
-    function byteLength(string, encoding) {
-      return Buffer.byteLength(string, encoding);
-    }
-    function compare(a, b) {
-      return Buffer.compare(a, b);
-    }
-    function concat(buffers, totalLength) {
-      return Buffer.concat(buffers, totalLength);
-    }
-    function copy(source, target, targetStart, start, end) {
-      return toBuffer(source).copy(target, targetStart, start, end);
-    }
-    function equals(a, b) {
-      return toBuffer(a).equals(b);
-    }
-    function fill(buffer, value, offset, end, encoding) {
-      return toBuffer(buffer).fill(value, offset, end, encoding);
-    }
-    function from(value, encodingOrOffset, length) {
-      return Buffer.from(value, encodingOrOffset, length);
-    }
-    function includes(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).includes(value, byteOffset, encoding);
-    }
-    function indexOf(buffer, value, byfeOffset, encoding) {
-      return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
-    }
-    function lastIndexOf(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
-    }
-    function swap16(buffer) {
-      return toBuffer(buffer).swap16();
-    }
-    function swap32(buffer) {
-      return toBuffer(buffer).swap32();
-    }
-    function swap64(buffer) {
-      return toBuffer(buffer).swap64();
-    }
-    function toBuffer(buffer) {
-      if (Buffer.isBuffer(buffer)) return buffer;
-      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    }
-    function toString(buffer, encoding, start, end) {
-      return toBuffer(buffer).toString(encoding, start, end);
-    }
-    function write(buffer, string, offset, length, encoding) {
-      return toBuffer(buffer).write(string, offset, length, encoding);
-    }
-    function readDoubleBE(buffer, offset) {
-      return toBuffer(buffer).readDoubleBE(offset);
-    }
-    function readDoubleLE(buffer, offset) {
-      return toBuffer(buffer).readDoubleLE(offset);
-    }
-    function readFloatBE(buffer, offset) {
-      return toBuffer(buffer).readFloatBE(offset);
-    }
-    function readFloatLE(buffer, offset) {
-      return toBuffer(buffer).readFloatLE(offset);
-    }
-    function readInt32BE(buffer, offset) {
-      return toBuffer(buffer).readInt32BE(offset);
-    }
-    function readInt32LE(buffer, offset) {
-      return toBuffer(buffer).readInt32LE(offset);
-    }
-    function readUInt32BE(buffer, offset) {
-      return toBuffer(buffer).readUInt32BE(offset);
-    }
-    function readUInt32LE(buffer, offset) {
-      return toBuffer(buffer).readUInt32LE(offset);
-    }
-    function writeDoubleBE(buffer, value, offset) {
-      return toBuffer(buffer).writeDoubleBE(value, offset);
-    }
-    function writeDoubleLE(buffer, value, offset) {
-      return toBuffer(buffer).writeDoubleLE(value, offset);
-    }
-    function writeFloatBE(buffer, value, offset) {
-      return toBuffer(buffer).writeFloatBE(value, offset);
-    }
-    function writeFloatLE(buffer, value, offset) {
-      return toBuffer(buffer).writeFloatLE(value, offset);
-    }
-    function writeInt32BE(buffer, value, offset) {
-      return toBuffer(buffer).writeInt32BE(value, offset);
-    }
-    function writeInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeInt32LE(value, offset);
-    }
-    function writeUInt32BE(buffer, value, offset) {
-      return toBuffer(buffer).writeUInt32BE(value, offset);
-    }
-    function writeUInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeUInt32LE(value, offset);
-    }
-    module.exports = {
-      isBuffer,
-      isEncoding,
-      alloc,
-      allocUnsafe,
-      allocUnsafeSlow,
-      byteLength,
-      compare,
-      concat,
-      copy,
-      equals,
-      fill,
-      from,
-      includes,
-      indexOf,
-      lastIndexOf,
-      swap16,
-      swap32,
-      swap64,
-      toBuffer,
-      toString,
-      write,
-      readDoubleBE,
-      readDoubleLE,
-      readFloatBE,
-      readFloatLE,
-      readInt32BE,
-      readInt32LE,
-      readUInt32BE,
-      readUInt32LE,
-      writeDoubleBE,
-      writeDoubleLE,
-      writeFloatBE,
-      writeFloatLE,
-      writeInt32BE,
-      writeInt32LE,
-      writeUInt32BE,
-      writeUInt32LE
-    };
-  }
-});
-
-// ../../node_modules/text-decoder/lib/pass-through-decoder.js
-var require_pass_through_decoder = __commonJS({
-  "../../node_modules/text-decoder/lib/pass-through-decoder.js"(exports, module) {
-    var b4a = require_b4a();
-    module.exports = class PassThroughDecoder {
-      constructor(encoding) {
-        this.encoding = encoding;
-      }
-      get remaining() {
-        return 0;
-      }
-      decode(data) {
-        return b4a.toString(data, this.encoding);
-      }
-      flush() {
-        return "";
-      }
-    };
-  }
-});
-
-// ../../node_modules/text-decoder/lib/utf8-decoder.js
-var require_utf8_decoder = __commonJS({
-  "../../node_modules/text-decoder/lib/utf8-decoder.js"(exports, module) {
-    var b4a = require_b4a();
-    module.exports = class UTF8Decoder {
-      constructor() {
-        this._reset();
-      }
-      get remaining() {
-        return this.bytesSeen;
-      }
-      decode(data) {
-        if (data.byteLength === 0) return "";
-        if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) {
-          this.bytesSeen = trailingBytesSeen(data);
-          return b4a.toString(data, "utf8");
-        }
-        let result = "";
-        let start = 0;
-        if (this.bytesNeeded > 0) {
-          while (start < data.byteLength) {
-            const byte = data[start];
-            if (byte < this.lowerBoundary || byte > this.upperBoundary) {
-              result += "\uFFFD";
-              this._reset();
-              break;
-            }
-            this.lowerBoundary = 128;
-            this.upperBoundary = 191;
-            this.codePoint = this.codePoint << 6 | byte & 63;
-            this.bytesSeen++;
-            start++;
-            if (this.bytesSeen === this.bytesNeeded) {
-              result += String.fromCodePoint(this.codePoint);
-              this._reset();
-              break;
-            }
-          }
-          if (this.bytesNeeded > 0) return result;
-        }
-        const trailing = trailingIncomplete(data, start);
-        const end = data.byteLength - trailing;
-        if (end > start) result += b4a.toString(data, "utf8", start, end);
-        for (let i = end; i < data.byteLength; i++) {
-          const byte = data[i];
-          if (this.bytesNeeded === 0) {
-            if (byte <= 127) {
-              this.bytesSeen = 0;
-              result += String.fromCharCode(byte);
-            } else if (byte >= 194 && byte <= 223) {
-              this.bytesNeeded = 2;
-              this.bytesSeen = 1;
-              this.codePoint = byte & 31;
-            } else if (byte >= 224 && byte <= 239) {
-              if (byte === 224) this.lowerBoundary = 160;
-              else if (byte === 237) this.upperBoundary = 159;
-              this.bytesNeeded = 3;
-              this.bytesSeen = 1;
-              this.codePoint = byte & 15;
-            } else if (byte >= 240 && byte <= 244) {
-              if (byte === 240) this.lowerBoundary = 144;
-              else if (byte === 244) this.upperBoundary = 143;
-              this.bytesNeeded = 4;
-              this.bytesSeen = 1;
-              this.codePoint = byte & 7;
-            } else {
-              this.bytesSeen = 1;
-              result += "\uFFFD";
-            }
-            continue;
-          }
-          if (byte < this.lowerBoundary || byte > this.upperBoundary) {
-            result += "\uFFFD";
-            i--;
-            this._reset();
-            continue;
-          }
-          this.lowerBoundary = 128;
-          this.upperBoundary = 191;
-          this.codePoint = this.codePoint << 6 | byte & 63;
-          this.bytesSeen++;
-          if (this.bytesSeen === this.bytesNeeded) {
-            result += String.fromCodePoint(this.codePoint);
-            this._reset();
-          }
-        }
-        return result;
-      }
-      flush() {
-        const result = this.bytesNeeded > 0 ? "\uFFFD" : "";
-        this._reset();
-        return result;
-      }
-      _reset() {
-        this.codePoint = 0;
-        this.bytesNeeded = 0;
-        this.bytesSeen = 0;
-        this.lowerBoundary = 128;
-        this.upperBoundary = 191;
-      }
-    };
-    function trailingIncomplete(data, start) {
-      const len = data.byteLength;
-      if (len <= start) return 0;
-      const limit = Math.max(start, len - 4);
-      let i = len - 1;
-      while (i > limit && (data[i] & 192) === 128) i--;
-      if (i < start) return 0;
-      const byte = data[i];
-      let needed;
-      if (byte <= 127) return 0;
-      if (byte >= 194 && byte <= 223) needed = 2;
-      else if (byte >= 224 && byte <= 239) needed = 3;
-      else if (byte >= 240 && byte <= 244) needed = 4;
-      else return 0;
-      const available = len - i;
-      return available < needed ? available : 0;
-    }
-    function trailingBytesSeen(data) {
-      const len = data.byteLength;
-      if (len === 0) return 0;
-      const last = data[len - 1];
-      if (last <= 127) return 0;
-      if ((last & 192) !== 128) return 1;
-      const limit = Math.max(0, len - 4);
-      let i = len - 2;
-      while (i >= limit && (data[i] & 192) === 128) i--;
-      if (i < 0) return 1;
-      const first = data[i];
-      let needed;
-      if (first >= 194 && first <= 223) needed = 2;
-      else if (first >= 224 && first <= 239) needed = 3;
-      else if (first >= 240 && first <= 244) needed = 4;
-      else return 1;
-      if (len - i !== needed) return 1;
-      if (needed >= 3) {
-        const second = data[i + 1];
-        if (first === 224 && second < 160) return 1;
-        if (first === 237 && second > 159) return 1;
-        if (first === 240 && second < 144) return 1;
-        if (first === 244 && second > 143) return 1;
-      }
-      return 0;
-    }
-  }
-});
-
-// ../../node_modules/text-decoder/index.js
-var require_text_decoder = __commonJS({
-  "../../node_modules/text-decoder/index.js"(exports, module) {
-    var PassThroughDecoder = require_pass_through_decoder();
-    var UTF8Decoder = require_utf8_decoder();
-    module.exports = class TextDecoder {
-      constructor(encoding = "utf8") {
-        this.encoding = normalizeEncoding(encoding);
-        switch (this.encoding) {
-          case "utf8":
-            this.decoder = new UTF8Decoder();
-            break;
-          case "utf16le":
-          case "base64":
-            throw new Error("Unsupported encoding: " + this.encoding);
-          default:
-            this.decoder = new PassThroughDecoder(this.encoding);
-        }
-      }
-      get remaining() {
-        return this.decoder.remaining;
-      }
-      push(data) {
-        if (typeof data === "string") return data;
-        return this.decoder.decode(data);
-      }
-      // For Node.js compatibility
-      write(data) {
-        return this.push(data);
-      }
-      end(data) {
-        let result = "";
-        if (data) result = this.push(data);
-        result += this.decoder.flush();
-        return result;
-      }
-    };
-    function normalizeEncoding(encoding) {
-      encoding = encoding.toLowerCase();
-      switch (encoding) {
-        case "utf8":
-        case "utf-8":
-          return "utf8";
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return "utf16le";
-        case "latin1":
-        case "binary":
-          return "latin1";
-        case "base64":
-        case "ascii":
-        case "hex":
-          return encoding;
-        default:
-          throw new Error("Unknown encoding: " + encoding);
-      }
-    }
-  }
-});
-
-// ../../node_modules/streamx/lib/errors.js
-var require_errors = __commonJS({
-  "../../node_modules/streamx/lib/errors.js"(exports, module) {
-    module.exports = class StreamError extends Error {
-      constructor(msg, code, fn = StreamError) {
-        super(msg);
-        this.code = code;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, fn);
-        }
-      }
-      static isStreamDestroyed(err) {
-        return err && err.code === "STREAM_DESTROYED";
-      }
-      static isPrematureClose(err) {
-        return err && err.code === "PREMATURE_CLOSE";
-      }
-      static isAborted(err) {
-        return err && err.code === "ABORTED";
-      }
-      static isBadArgument(err) {
-        return err && err.code === "BAD_ARGUMENT";
-      }
-      get name() {
-        return "StreamError";
-      }
-      static STREAM_DESTROYED() {
-        return new StreamError("Stream was destroyed", "STREAM_DESTROYED", StreamError.STREAM_DESTROYED);
-      }
-      static PREMATURE_CLOSE(msg = "Premature close") {
-        return new StreamError(msg, "PREMATURE_CLOSE", StreamError.PREMATURE_CLOSE);
-      }
-      static ABORTED() {
-        return new StreamError("Stream aborted", "ABORTED", StreamError.ABORTED);
-      }
-      static BAD_ARGUMENT(msg = "Bad argument") {
-        return new StreamError(msg, "BAD_ARGUMENT", StreamError.BAD_ARGUMENT);
-      }
-    };
-  }
-});
-
-// ../../node_modules/streamx/index.js
-var require_streamx = __commonJS({
-  "../../node_modules/streamx/index.js"(exports, module) {
-    var { EventEmitter } = require_default();
-    var FIFO = require_fast_fifo();
-    var TextDecoder2 = require_text_decoder();
-    var StreamError = require_errors();
-    var qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask;
-    var MAX = (1 << 29) - 1;
-    var OPENING = 1;
-    var PREDESTROYING = 2;
-    var DESTROYING = 4;
-    var DESTROYED = 8;
-    var NOT_OPENING = MAX ^ OPENING;
-    var NOT_PREDESTROYING = MAX ^ PREDESTROYING;
-    var READ_ACTIVE = 1 << 4;
-    var READ_UPDATING = 2 << 4;
-    var READ_PRIMARY = 4 << 4;
-    var READ_QUEUED = 8 << 4;
-    var READ_RESUMED = 16 << 4;
-    var READ_PIPE_DRAINED = 32 << 4;
-    var READ_ENDING = 64 << 4;
-    var READ_EMIT_DATA = 128 << 4;
-    var READ_EMIT_READABLE = 256 << 4;
-    var READ_EMITTED_READABLE = 512 << 4;
-    var READ_DONE = 1024 << 4;
-    var READ_NEXT_TICK = 2048 << 4;
-    var READ_NEEDS_PUSH = 4096 << 4;
-    var READ_READ_AHEAD = 8192 << 4;
-    var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
-    var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH;
-    var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
-    var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
-    var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD;
-    var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
-    var READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
-    var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
-    var READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
-    var READ_PAUSED = MAX ^ READ_RESUMED;
-    var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
-    var READ_NOT_ENDING = MAX ^ READ_ENDING;
-    var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
-    var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
-    var READ_NOT_UPDATING = MAX ^ READ_UPDATING;
-    var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD;
-    var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD;
-    var WRITE_ACTIVE = 1 << 18;
-    var WRITE_UPDATING = 2 << 18;
-    var WRITE_PRIMARY = 4 << 18;
-    var WRITE_QUEUED = 8 << 18;
-    var WRITE_UNDRAINED = 16 << 18;
-    var WRITE_DONE = 32 << 18;
-    var WRITE_EMIT_DRAIN = 64 << 18;
-    var WRITE_NEXT_TICK = 128 << 18;
-    var WRITE_WRITING = 256 << 18;
-    var WRITE_FINISHING = 512 << 18;
-    var WRITE_CORKED = 1024 << 18;
-    var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING);
-    var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
-    var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING);
-    var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
-    var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
-    var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
-    var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING;
-    var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED;
-    var ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
-    var NOT_ACTIVE = MAX ^ ACTIVE;
-    var DONE = READ_DONE | WRITE_DONE;
-    var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
-    var OPEN_STATUS = DESTROY_STATUS | OPENING;
-    var AUTO_DESTROY = DESTROY_STATUS | DONE;
-    var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
-    var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
-    var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
-    var IS_OPENING = OPEN_STATUS | TICKING;
-    var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
-    var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
-    var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
-    var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
-    var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD;
-    var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
-    var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY;
-    var READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING;
-    var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
-    var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
-    var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
-    var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
-    var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED;
-    var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
-    var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING;
-    var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
-    var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
-    var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
-    var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS;
-    var asyncIterator = Symbol.asyncIterator || /* @__PURE__ */ Symbol("asyncIterator");
-    var WritableState = class {
-      constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
-        this.stream = stream;
-        this.queue = new FIFO();
-        this.highWaterMark = highWaterMark;
-        this.buffered = 0;
-        this.error = null;
-        this.pipeline = null;
-        this.drains = null;
-        this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
-        this.map = mapWritable || map;
-        this.afterWrite = afterWrite.bind(this);
-        this.afterUpdateNextTick = updateWriteNT.bind(this);
-      }
-      get ending() {
-        return (this.stream._duplexState & WRITE_FINISHING) !== 0;
-      }
-      get ended() {
-        return (this.stream._duplexState & WRITE_DONE) !== 0;
-      }
-      push(data) {
-        if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false;
-        if (this.map !== null) data = this.map(data);
-        this.buffered += this.byteLength(data);
-        this.queue.push(data);
-        if (this.buffered < this.highWaterMark) {
-          this.stream._duplexState |= WRITE_QUEUED;
-          return true;
-        }
-        this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
-        return false;
-      }
-      shift() {
-        const data = this.queue.shift();
-        this.buffered -= this.byteLength(data);
-        if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED;
-        return data;
-      }
-      end(data) {
-        if (typeof data === "function") {
-          this.stream.once("finish", data);
-        } else if (data !== void 0 && data !== null) {
-          this.push(data);
-        }
-        this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
-      }
-      autoBatch(data, cb) {
-        const buffer = [];
-        const stream = this.stream;
-        buffer.push(data);
-        while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
-          buffer.push(stream._writableState.shift());
-        }
-        if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null);
-        stream._writev(buffer, cb);
-      }
-      update() {
-        const stream = this.stream;
-        stream._duplexState |= WRITE_UPDATING;
-        do {
-          while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
-            const data = this.shift();
-            stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
-            stream._write(data, this.afterWrite);
-          }
-          if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
-        } while (this.continueUpdate() === true);
-        stream._duplexState &= WRITE_NOT_UPDATING;
-      }
-      updateNonPrimary() {
-        const stream = this.stream;
-        if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
-          stream._duplexState = stream._duplexState | WRITE_ACTIVE;
-          stream._final(afterFinal.bind(this));
-          return;
-        }
-        if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
-          if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
-            stream._duplexState |= ACTIVE;
-            stream._destroy(afterDestroy.bind(this));
-          }
-          return;
-        }
-        if ((stream._duplexState & IS_OPENING) === OPENING) {
-          stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
-          stream._open(afterOpen.bind(this));
-        }
-      }
-      continueUpdate() {
-        if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false;
-        this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
-        return true;
-      }
-      updateCallback() {
-        if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) {
-          this.update();
-        } else {
-          this.updateNextTick();
-        }
-      }
-      updateNextTick() {
-        if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
-        this.stream._duplexState |= WRITE_NEXT_TICK;
-        if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-      }
-    };
-    var ReadableState = class {
-      constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
-        this.stream = stream;
-        this.queue = new FIFO();
-        this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
-        this.buffered = 0;
-        this.readAhead = highWaterMark > 0;
-        this.error = null;
-        this.pipeline = null;
-        this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
-        this.map = mapReadable || map;
-        this.pipeTo = null;
-        this.afterRead = afterRead.bind(this);
-        this.afterUpdateNextTick = updateReadNT.bind(this);
-      }
-      get ending() {
-        return (this.stream._duplexState & READ_ENDING) !== 0;
-      }
-      get ended() {
-        return (this.stream._duplexState & READ_DONE) !== 0;
-      }
-      pipe(pipeTo, cb) {
-        if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT("Can only pipe to one destination");
-        if (typeof cb !== "function") cb = null;
-        this.stream._duplexState |= READ_PIPE_DRAINED;
-        this.pipeTo = pipeTo;
-        this.pipeline = new Pipeline(this.stream, pipeTo, cb);
-        if (cb) this.stream.on("error", noop);
-        if (isStreamx(pipeTo)) {
-          pipeTo._writableState.pipeline = this.pipeline;
-          if (cb) pipeTo.on("error", noop);
-          pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
-        } else {
-          const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
-          const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
-          pipeTo.on("error", onerror);
-          pipeTo.on("close", onclose);
-          pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
-        }
-        pipeTo.on("drain", afterDrain.bind(this));
-        this.stream.emit("piping", pipeTo);
-        pipeTo.emit("pipe", this.stream);
-      }
-      push(data) {
-        const stream = this.stream;
-        if (data === null) {
-          this.highWaterMark = 0;
-          stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
-          return false;
-        }
-        if (this.map !== null) {
-          data = this.map(data);
-          if (data === null) {
-            stream._duplexState &= READ_PUSHED;
-            return this.buffered < this.highWaterMark;
-          }
-        }
-        this.buffered += this.byteLength(data);
-        this.queue.push(data);
-        stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
-        return this.buffered < this.highWaterMark;
-      }
-      shift() {
-        const data = this.queue.shift();
-        this.buffered -= this.byteLength(data);
-        if (this.buffered === 0) {
-          this.stream._duplexState &= READ_NOT_QUEUED;
-        }
-        return data;
-      }
-      unshift(data) {
-        const pending = [this.map !== null ? this.map(data) : data];
-        while (this.buffered > 0) pending.push(this.shift());
-        for (let i = 0; i < pending.length - 1; i++) {
-          const data2 = pending[i];
-          this.buffered += this.byteLength(data2);
-          this.queue.push(data2);
-        }
-        this.push(pending[pending.length - 1]);
-      }
-      read() {
-        const stream = this.stream;
-        if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
-          const data = this.shift();
-          if (this.pipeTo !== null && this.pipeTo.write(data) === false) {
-            stream._duplexState &= READ_PIPE_NOT_DRAINED;
-          }
-          if ((stream._duplexState & READ_EMIT_DATA) !== 0) {
-            stream.emit("data", data);
-          }
-          return data;
-        }
-        if (this.readAhead === false) {
-          stream._duplexState |= READ_READ_AHEAD;
-          this.updateNextTick();
-        }
-        return null;
-      }
-      drain() {
-        const stream = this.stream;
-        while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
-          const data = this.shift();
-          if (this.pipeTo !== null && this.pipeTo.write(data) === false) {
-            stream._duplexState &= READ_PIPE_NOT_DRAINED;
-          }
-          if ((stream._duplexState & READ_EMIT_DATA) !== 0) {
-            stream.emit("data", data);
-          }
-        }
-      }
-      update() {
-        const stream = this.stream;
-        stream._duplexState |= READ_UPDATING;
-        do {
-          this.drain();
-          while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {
-            stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
-            stream._read(this.afterRead);
-            this.drain();
-          }
-          if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
-            stream._duplexState |= READ_EMITTED_READABLE;
-            stream.emit("readable");
-          }
-          if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) {
-            this.updateNonPrimary();
-          }
-        } while (this.continueUpdate() === true);
-        stream._duplexState &= READ_NOT_UPDATING;
-      }
-      updateNonPrimary() {
-        const stream = this.stream;
-        if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
-          stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
-          stream.emit("end");
-          if ((stream._duplexState & AUTO_DESTROY) === DONE) {
-            stream._duplexState |= DESTROYING;
-          }
-          if (this.pipeTo !== null) {
-            this.pipeTo.end();
-          }
-        }
-        if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
-          if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
-            stream._duplexState |= ACTIVE;
-            stream._destroy(afterDestroy.bind(this));
-          }
-          return;
-        }
-        if ((stream._duplexState & IS_OPENING) === OPENING) {
-          stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
-          stream._open(afterOpen.bind(this));
-        }
-      }
-      continueUpdate() {
-        if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false;
-        this.stream._duplexState &= READ_NOT_NEXT_TICK;
-        return true;
-      }
-      updateCallback() {
-        if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) {
-          this.update();
-        } else {
-          this.updateNextTick();
-        }
-      }
-      updateNextTickIfOpen() {
-        if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return;
-        this.stream._duplexState |= READ_NEXT_TICK;
-        if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-      }
-      updateNextTick() {
-        if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return;
-        this.stream._duplexState |= READ_NEXT_TICK;
-        if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick);
-      }
-    };
-    var TransformState = class {
-      constructor(stream) {
-        this.data = null;
-        this.afterTransform = afterTransform.bind(stream);
-        this.afterFinal = null;
-      }
-    };
-    var Pipeline = class {
-      constructor(src, dst, cb) {
-        this.from = src;
-        this.to = dst;
-        this.afterPipe = cb;
-        this.error = null;
-        this.pipeToFinished = false;
-      }
-      finished() {
-        this.pipeToFinished = true;
-      }
-      done(stream, err) {
-        if (err) this.error = err;
-        if (stream === this.to) {
-          this.to = null;
-          if (this.from !== null) {
-            if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
-              this.from.destroy(this.error || StreamError.PREMATURE_CLOSE("Writable stream closed"));
-            }
-            return;
-          }
-        }
-        if (stream === this.from) {
-          this.from = null;
-          if (this.to !== null) {
-            if ((stream._duplexState & READ_DONE) === 0) {
-              this.to.destroy(this.error || StreamError.PREMATURE_CLOSE("Readable stream closed"));
-            }
-            return;
-          }
-        }
-        if (this.afterPipe !== null) this.afterPipe(this.error);
-        this.to = this.from = this.afterPipe = null;
-      }
-    };
-    function afterDrain() {
-      this.stream._duplexState |= READ_PIPE_DRAINED;
-      this.updateCallback();
-    }
-    function afterFinal(err) {
-      const stream = this.stream;
-      if (err) stream.destroy(err);
-      if ((stream._duplexState & DESTROY_STATUS) === 0) {
-        stream._duplexState |= WRITE_DONE;
-        stream.emit("finish");
-      }
-      if ((stream._duplexState & AUTO_DESTROY) === DONE) {
-        stream._duplexState |= DESTROYING;
-      }
-      stream._duplexState &= WRITE_NOT_FINISHING;
-      if ((stream._duplexState & WRITE_UPDATING) === 0) {
-        this.update();
-      } else {
-        this.updateNextTick();
-      }
-    }
-    function afterDestroy(err) {
-      const stream = this.stream;
-      if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error;
-      if (err) stream.emit("error", err);
-      stream._duplexState |= DESTROYED;
-      stream.emit("close");
-      const rs = stream._readableState;
-      const ws = stream._writableState;
-      if (rs !== null && rs.pipeline !== null) {
-        rs.pipeline.done(stream, err);
-      }
-      if (ws !== null) {
-        while (ws.drains !== null && ws.drains.length > 0) {
-          ws.drains.shift().resolve(false);
-        }
-        if (ws.pipeline !== null) {
-          ws.pipeline.done(stream, err);
-        }
-      }
-    }
-    function afterWrite(err) {
-      const stream = this.stream;
-      if (err) stream.destroy(err);
-      stream._duplexState &= WRITE_NOT_ACTIVE;
-      if (this.drains !== null) tickDrains(this.drains);
-      if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
-        stream._duplexState &= WRITE_DRAINED;
-        if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
-          stream.emit("drain");
-        }
-      }
-      this.updateCallback();
-    }
-    function afterRead(err) {
-      if (err) this.stream.destroy(err);
-      this.stream._duplexState &= READ_NOT_ACTIVE;
-      if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) {
-        this.stream._duplexState &= READ_NO_READ_AHEAD;
-      }
-      this.updateCallback();
-    }
-    function updateReadNT() {
-      if ((this.stream._duplexState & READ_UPDATING) === 0) {
-        this.stream._duplexState &= READ_NOT_NEXT_TICK;
-        this.update();
-      }
-    }
-    function updateWriteNT() {
-      if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
-        this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
-        this.update();
-      }
-    }
-    function tickDrains(drains) {
-      for (let i = 0; i < drains.length; i++) {
-        if (--drains[i].writes === 0) {
-          drains.shift().resolve(true);
-          i--;
-        }
-      }
-    }
-    function afterOpen(err) {
-      const stream = this.stream;
-      if (err) stream.destroy(err);
-      if ((stream._duplexState & DESTROYING) === 0) {
-        if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) {
-          stream._duplexState |= READ_PRIMARY;
-        }
-        if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) {
-          stream._duplexState |= WRITE_PRIMARY;
-        }
-        stream.emit("open");
-      }
-      stream._duplexState &= NOT_ACTIVE;
-      if (stream._writableState !== null) {
-        stream._writableState.updateCallback();
-      }
-      if (stream._readableState !== null) {
-        stream._readableState.updateCallback();
-      }
-    }
-    function afterTransform(err, data) {
-      if (data !== void 0 && data !== null) this.push(data);
-      this._writableState.afterWrite(err);
-    }
-    function newListener(name) {
-      if (this._readableState !== null) {
-        if (name === "data") {
-          this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD;
-          this._readableState.updateNextTick();
-        }
-        if (name === "readable") {
-          this._duplexState |= READ_EMIT_READABLE;
-          this._readableState.updateNextTick();
-        }
-      }
-      if (this._writableState !== null) {
-        if (name === "drain") {
-          this._duplexState |= WRITE_EMIT_DRAIN;
-          this._writableState.updateNextTick();
-        }
-      }
-    }
-    var Stream = class extends EventEmitter {
-      constructor(opts) {
-        super();
-        this._duplexState = 0;
-        this._readableState = null;
-        this._writableState = null;
-        if (opts) {
-          if (opts.open) this._open = opts.open;
-          if (opts.destroy) this._destroy = opts.destroy;
-          if (opts.predestroy) this._predestroy = opts.predestroy;
-          if (opts.signal) opts.signal.addEventListener("abort", abort.bind(this));
-        }
-        this.on("newListener", newListener);
-      }
-      _open(cb) {
-        cb(null);
-      }
-      _destroy(cb) {
-        cb(null);
-      }
-      _predestroy() {
-      }
-      get readable() {
-        return this._readableState !== null ? true : void 0;
-      }
-      get writable() {
-        return this._writableState !== null ? true : void 0;
-      }
-      get destroyed() {
-        return (this._duplexState & DESTROYED) !== 0;
-      }
-      get destroying() {
-        return (this._duplexState & DESTROY_STATUS) !== 0;
-      }
-      destroy(err) {
-        if ((this._duplexState & DESTROY_STATUS) === 0) {
-          if (!err) err = StreamError.STREAM_DESTROYED();
-          this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
-          if (this._readableState !== null) {
-            this._readableState.highWaterMark = 0;
-            this._readableState.error = err;
-          }
-          if (this._writableState !== null) {
-            this._writableState.highWaterMark = 0;
-            this._writableState.error = err;
-          }
-          this._duplexState |= PREDESTROYING;
-          this._predestroy();
-          this._duplexState &= NOT_PREDESTROYING;
-          if (this._readableState !== null) {
-            this._readableState.updateNextTick();
-          }
-          if (this._writableState !== null) {
-            this._writableState.updateNextTick();
-          }
-        }
-      }
-    };
-    var Readable2 = class _Readable extends Stream {
-      constructor(opts) {
-        super(opts);
-        this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD;
-        this._readableState = new ReadableState(this, opts);
-        if (opts) {
-          if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD;
-          if (opts.read) this._read = opts.read;
-          if (opts.eagerOpen) this._readableState.updateNextTick();
-          if (opts.encoding) this.setEncoding(opts.encoding);
-        }
-      }
-      static deferred(fn, opts) {
-        const out = new PassThrough(opts);
-        fn().then((src) => {
-          if (src === null) return out.end();
-          if (out.destroying) return;
-          pipeline2(src, out, noop);
-        }).catch((err) => out.destroy(err));
-        return out;
-      }
-      setEncoding(encoding) {
-        const dec = new TextDecoder2(encoding);
-        const map = this._readableState.map || echo;
-        this._readableState.map = mapOrSkip;
-        return this;
-        function mapOrSkip(data) {
-          const next = dec.push(data);
-          return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
-        }
-      }
-      _read(cb) {
-        cb(null);
-      }
-      pipe(dest, cb) {
-        this._readableState.updateNextTick();
-        this._readableState.pipe(dest, cb);
-        return dest;
-      }
-      read() {
-        this._readableState.updateNextTick();
-        return this._readableState.read();
-      }
-      push(data) {
-        this._readableState.updateNextTickIfOpen();
-        return this._readableState.push(data);
-      }
-      unshift(data) {
-        this._readableState.updateNextTickIfOpen();
-        return this._readableState.unshift(data);
-      }
-      resume() {
-        this._duplexState |= READ_RESUMED_READ_AHEAD;
-        this._readableState.updateNextTick();
-        return this;
-      }
-      pause() {
-        this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED;
-        return this;
-      }
-      static _fromAsyncIterator(ite, opts) {
-        let destroy;
-        const rs = new _Readable({
-          ...opts,
-          read(cb) {
-            ite.next().then(push).then(cb.bind(null, null)).catch(cb);
-          },
-          predestroy() {
-            destroy = ite.return();
-          },
-          destroy(cb) {
-            if (!destroy) return cb(null);
-            destroy.then(cb.bind(null, null)).catch(cb);
-          }
-        });
-        return rs;
-        function push(data) {
-          if (data.done) rs.push(null);
-          else rs.push(data.value);
-        }
-      }
-      static from(data, opts) {
-        if (isReadStreamx(data)) return data;
-        if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts);
-        if (!Array.isArray(data)) data = data === void 0 ? [] : [data];
-        let i = 0;
-        return new _Readable({
-          ...opts,
-          read(cb) {
-            this.push(i === data.length ? null : data[i++]);
-            cb(null);
-          }
-        });
-      }
-      static isBackpressured(rs) {
-        return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
-      }
-      static isPaused(rs) {
-        return (rs._duplexState & READ_RESUMED) === 0;
-      }
-      [asyncIterator]() {
-        const stream = this;
-        let error = null;
-        let promiseResolve = null;
-        let promiseReject = null;
-        this.on("error", (err) => {
-          error = err;
-        });
-        this.on("readable", onreadable);
-        this.on("close", onclose);
-        return {
-          [asyncIterator]() {
-            return this;
-          },
-          next() {
-            return new Promise(function(resolve3, reject) {
-              promiseResolve = resolve3;
-              promiseReject = reject;
-              const data = stream.read();
-              if (data !== null) ondata(data);
-              else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
-            });
-          },
-          return() {
-            return destroy(null);
-          },
-          throw(err) {
-            return destroy(err);
-          }
-        };
-        function onreadable() {
-          if (promiseResolve !== null) ondata(stream.read());
-        }
-        function onclose() {
-          if (promiseResolve !== null) ondata(null);
-        }
-        function ondata(data) {
-          if (promiseReject === null) return;
-          if (error) {
-            promiseReject(error);
-          } else if (data === null && (stream._duplexState & READ_DONE) === 0) {
-            promiseReject(StreamError.STREAM_DESTROYED());
-          } else {
-            promiseResolve({ value: data, done: data === null });
-          }
-          promiseReject = promiseResolve = null;
-        }
-        function destroy(err) {
-          stream.destroy(err);
-          return new Promise((resolve3, reject) => {
-            if (stream._duplexState & DESTROYED) return resolve3({ value: void 0, done: true });
-            stream.once("close", function() {
-              if (err) reject(err);
-              else resolve3({ value: void 0, done: true });
-            });
-          });
-        }
-      }
-    };
-    var Writable = class extends Stream {
-      constructor(opts) {
-        super(opts);
-        this._duplexState |= OPENING | READ_DONE;
-        this._writableState = new WritableState(this, opts);
-        if (opts) {
-          if (opts.writev) this._writev = opts.writev;
-          if (opts.write) this._write = opts.write;
-          if (opts.final) this._final = opts.final;
-          if (opts.eagerOpen) this._writableState.updateNextTick();
-        }
-      }
-      cork() {
-        this._duplexState |= WRITE_CORKED;
-      }
-      uncork() {
-        this._duplexState &= WRITE_NOT_CORKED;
-        this._writableState.updateNextTick();
-      }
-      _writev(batch, cb) {
-        cb(null);
-      }
-      _write(data, cb) {
-        this._writableState.autoBatch(data, cb);
-      }
-      _final(cb) {
-        cb(null);
-      }
-      static isBackpressured(ws) {
-        return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
-      }
-      static drained(ws) {
-        if (ws.destroyed) return Promise.resolve(false);
-        const state = ws._writableState;
-        const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length;
-        const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
-        if (writes === 0) return Promise.resolve(true);
-        if (state.drains === null) state.drains = [];
-        return new Promise((resolve3) => {
-          state.drains.push({ writes, resolve: resolve3 });
-        });
-      }
-      write(data) {
-        this._writableState.updateNextTick();
-        return this._writableState.push(data);
-      }
-      end(data) {
-        this._writableState.updateNextTick();
-        this._writableState.end(data);
-        return this;
-      }
-    };
-    var Duplex = class extends Readable2 {
-      // and Writable
-      constructor(opts) {
-        super(opts);
-        this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD;
-        this._writableState = new WritableState(this, opts);
-        if (opts) {
-          if (opts.writev) this._writev = opts.writev;
-          if (opts.write) this._write = opts.write;
-          if (opts.final) this._final = opts.final;
-        }
-      }
-      cork() {
-        this._duplexState |= WRITE_CORKED;
-      }
-      uncork() {
-        this._duplexState &= WRITE_NOT_CORKED;
-        this._writableState.updateNextTick();
-      }
-      _writev(batch, cb) {
-        cb(null);
-      }
-      _write(data, cb) {
-        this._writableState.autoBatch(data, cb);
-      }
-      _final(cb) {
-        cb(null);
-      }
-      write(data) {
-        this._writableState.updateNextTick();
-        return this._writableState.push(data);
-      }
-      end(data) {
-        this._writableState.updateNextTick();
-        this._writableState.end(data);
-        return this;
-      }
-    };
-    var Transform = class extends Duplex {
-      constructor(opts) {
-        super(opts);
-        this._transformState = new TransformState(this);
-        if (opts) {
-          if (opts.transform) this._transform = opts.transform;
-          if (opts.flush) this._flush = opts.flush;
-        }
-      }
-      _write(data, cb) {
-        if (this._readableState.buffered >= this._readableState.highWaterMark) {
-          this._transformState.data = data;
-        } else {
-          this._transform(data, this._transformState.afterTransform);
-        }
-      }
-      _read(cb) {
-        if (this._transformState.data !== null) {
-          const data = this._transformState.data;
-          this._transformState.data = null;
-          cb(null);
-          this._transform(data, this._transformState.afterTransform);
-        } else {
-          cb(null);
-        }
-      }
-      destroy(err) {
-        super.destroy(err);
-        if (this._transformState.data !== null) {
-          this._transformState.data = null;
-          this._transformState.afterTransform();
-        }
-      }
-      _transform(data, cb) {
-        cb(null, data);
-      }
-      _flush(cb) {
-        cb(null);
-      }
-      _final(cb) {
-        this._transformState.afterFinal = cb;
-        this._flush(transformAfterFlush.bind(this));
-      }
-    };
-    var PassThrough = class extends Transform {
-    };
-    function transformAfterFlush(err, data) {
-      const cb = this._transformState.afterFinal;
-      if (err) return cb(err);
-      if (data !== null && data !== void 0) this.push(data);
-      this.push(null);
-      cb(null);
-    }
-    function pipelinePromise(...streams) {
-      return new Promise((resolve3, reject) => {
-        return pipeline2(...streams, (err) => {
-          if (err) return reject(err);
-          resolve3();
-        });
-      });
-    }
-    function pipeline2(stream, ...streams) {
-      const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
-      const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
-      if (all.length < 2) throw StreamError.BAD_ARGUMENT("Pipeline requires at least 2 streams");
-      let src = all[0];
-      let dest = null;
-      let error = null;
-      for (let i = 1; i < all.length; i++) {
-        dest = all[i];
-        if (isStreamx(src)) {
-          src.pipe(dest, onerror);
-        } else {
-          errorHandle(src, true, i > 1, onerror);
-          src.pipe(dest);
-        }
-        src = dest;
-      }
-      if (done) {
-        let fin = false;
-        const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
-        dest.on("error", (err) => {
-          if (error === null) error = err;
-        });
-        dest.on("finish", () => {
-          fin = true;
-          if (!autoDestroy) done(error);
-        });
-        if (autoDestroy) {
-          dest.on("close", () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE())));
-        }
-      }
-      return dest;
-      function errorHandle(s, rd, wr, onerror2) {
-        s.on("error", onerror2);
-        s.on("close", onclose);
-        function onclose() {
-          if (s._readableState && !s._readableState.ended) {
-            return onerror2(StreamError.PREMATURE_CLOSE());
-          }
-          if (wr && s._writableState && !s._writableState.ended) {
-            return onerror2(StreamError.PREMATURE_CLOSE());
-          }
-        }
-      }
-      function onerror(err) {
-        if (!err || error) return;
-        error = err;
-        for (const s of all) {
-          s.destroy(err);
-        }
-      }
-    }
-    function echo(s) {
-      return s;
-    }
-    function isStream(stream) {
-      return !!stream._readableState || !!stream._writableState;
-    }
-    function isStreamx(stream) {
-      return typeof stream._duplexState === "number" && isStream(stream);
-    }
-    function isEnding(stream) {
-      return !!stream._readableState && stream._readableState.ending;
-    }
-    function isEnded(stream) {
-      return !!stream._readableState && stream._readableState.ended;
-    }
-    function isFinishing(stream) {
-      return !!stream._writableState && stream._writableState.ending;
-    }
-    function isFinished(stream) {
-      return !!stream._writableState && stream._writableState.ended;
-    }
-    function getStreamError(stream, opts = {}) {
-      const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
-      return !opts.all && StreamError.isStreamDestroyed(err) ? null : err;
-    }
-    function isReadStreamx(stream) {
-      return isStreamx(stream) && stream.readable;
-    }
-    function isDisturbed(stream) {
-      return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
-    }
-    function isTypedArray(data) {
-      return typeof data === "object" && data !== null && typeof data.byteLength === "number";
-    }
-    function defaultByteLength(data) {
-      return isTypedArray(data) ? data.byteLength : 1024;
-    }
-    function noop() {
-    }
-    function abort() {
-      this.destroy(StreamError.ABORTED());
-    }
-    function isWritev(s) {
-      return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
-    }
-    module.exports = {
-      pipeline: pipeline2,
-      pipelinePromise,
-      isStream,
-      isStreamx,
-      isEnding,
-      isEnded,
-      isFinishing,
-      isFinished,
-      isDisturbed,
-      getStreamError,
-      Stream,
-      Writable,
-      Readable: Readable2,
-      Duplex,
-      Transform,
-      // Export PassThrough for compatibility with Node.js core's stream module
-      PassThrough
-    };
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-stream/headers.js
-var require_headers = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-stream/headers.js"(exports) {
-    var b4a = require_b4a();
-    var ZEROS = "0000000000000000000";
-    var SEVENS = "7777777777777777777";
-    var ZERO_OFFSET = "0".charCodeAt(0);
-    var USTAR_MAGIC = b4a.from([117, 115, 116, 97, 114, 0]);
-    var USTAR_VER = b4a.from([ZERO_OFFSET, ZERO_OFFSET]);
-    var GNU_MAGIC = b4a.from([117, 115, 116, 97, 114, 32]);
-    var GNU_VER = b4a.from([32, 0]);
-    var MASK = 4095;
-    var MAGIC_OFFSET = 257;
-    var VERSION_OFFSET = 263;
-    exports.decodeLongPath = function decodeLongPath(buf, encoding) {
-      return decodeStr(buf, 0, buf.length, encoding);
-    };
-    exports.encodePax = function encodePax(opts) {
-      let result = "";
-      if (opts.name) result += addLength(" path=" + opts.name + "\n");
-      if (opts.linkname) result += addLength(" linkpath=" + opts.linkname + "\n");
-      const pax = opts.pax;
-      if (pax) {
-        for (const key in pax) {
-          result += addLength(" " + key + "=" + pax[key] + "\n");
-        }
-      }
-      return b4a.from(result);
-    };
-    exports.decodePax = function decodePax(buf) {
-      const result = {};
-      while (buf.length) {
-        let i = 0;
-        while (i < buf.length && buf[i] !== 32) i++;
-        const len = parseInt(b4a.toString(buf.subarray(0, i)), 10);
-        if (!len) return result;
-        const b = b4a.toString(buf.subarray(i + 1, len - 1));
-        const keyIndex = b.indexOf("=");
-        if (keyIndex === -1) return result;
-        result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
-        buf = buf.subarray(len);
-      }
-      return result;
-    };
-    exports.encode = function encode(opts) {
-      const buf = b4a.alloc(512);
-      let name = opts.name;
-      let prefix = "";
-      if (opts.typeflag === 5 && name[name.length - 1] !== "/") name += "/";
-      if (b4a.byteLength(name) !== name.length) return null;
-      while (b4a.byteLength(name) > 100) {
-        const i = name.indexOf("/");
-        if (i === -1) return null;
-        prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i);
-        name = name.slice(i + 1);
-      }
-      if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155) return null;
-      if (opts.linkname && b4a.byteLength(opts.linkname) > 100) return null;
-      b4a.write(buf, name);
-      b4a.write(buf, encodeOct(opts.mode & MASK, 6), 100);
-      b4a.write(buf, encodeOct(opts.uid, 6), 108);
-      b4a.write(buf, encodeOct(opts.gid, 6), 116);
-      encodeSize(opts.size, buf, 124);
-      b4a.write(buf, encodeOct(opts.mtime.getTime() / 1e3 | 0, 11), 136);
-      buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
-      if (opts.linkname) b4a.write(buf, opts.linkname, 157);
-      b4a.copy(USTAR_MAGIC, buf, MAGIC_OFFSET);
-      b4a.copy(USTAR_VER, buf, VERSION_OFFSET);
-      if (opts.uname) b4a.write(buf, opts.uname, 265);
-      if (opts.gname) b4a.write(buf, opts.gname, 297);
-      b4a.write(buf, encodeOct(opts.devmajor || 0, 6), 329);
-      b4a.write(buf, encodeOct(opts.devminor || 0, 6), 337);
-      if (prefix) b4a.write(buf, prefix, 345);
-      b4a.write(buf, encodeOct(cksum(buf), 6), 148);
-      return buf;
-    };
-    exports.decode = function decode(buf, filenameEncoding, allowUnknownFormat) {
-      let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
-      let name = decodeStr(buf, 0, 100, filenameEncoding);
-      const mode = decodeOct(buf, 100, 8);
-      const uid = decodeOct(buf, 108, 8);
-      const gid = decodeOct(buf, 116, 8);
-      const size = decodeOct(buf, 124, 12);
-      const mtime = decodeOct(buf, 136, 12);
-      const type = toType(typeflag);
-      const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
-      const uname = decodeStr(buf, 265, 32);
-      const gname = decodeStr(buf, 297, 32);
-      const devmajor = decodeOct(buf, 329, 8);
-      const devminor = decodeOct(buf, 337, 8);
-      const c = cksum(buf);
-      if (c === 8 * 32) return null;
-      if (c !== decodeOct(buf, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
-      if (isUSTAR(buf)) {
-        if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name;
-      } else if (isGNU(buf)) ; else {
-        if (!allowUnknownFormat) {
-          throw new Error("Invalid tar header: unknown format.");
-        }
-      }
-      if (typeflag === 0 && name && name[name.length - 1] === "/") typeflag = 5;
-      return {
-        name,
-        mode,
-        uid,
-        gid,
-        size,
-        mtime: new Date(1e3 * mtime),
-        type,
-        linkname,
-        uname,
-        gname,
-        devmajor,
-        devminor,
-        pax: null
-      };
-    };
-    function isUSTAR(buf) {
-      return b4a.equals(USTAR_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6));
-    }
-    function isGNU(buf) {
-      return b4a.equals(GNU_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)) && b4a.equals(GNU_VER, buf.subarray(VERSION_OFFSET, VERSION_OFFSET + 2));
-    }
-    function clamp(index, len, defaultValue) {
-      if (typeof index !== "number") return defaultValue;
-      index = ~~index;
-      if (index >= len) return len;
-      if (index >= 0) return index;
-      index += len;
-      if (index >= 0) return index;
-      return 0;
-    }
-    function toType(flag) {
-      switch (flag) {
-        case 0:
-          return "file";
-        case 1:
-          return "link";
-        case 2:
-          return "symlink";
-        case 3:
-          return "character-device";
-        case 4:
-          return "block-device";
-        case 5:
-          return "directory";
-        case 6:
-          return "fifo";
-        case 7:
-          return "contiguous-file";
-        case 72:
-          return "pax-header";
-        case 55:
-          return "pax-global-header";
-        case 27:
-          return "gnu-long-link-path";
-        case 28:
-        case 30:
-          return "gnu-long-path";
-      }
-      return null;
-    }
-    function toTypeflag(flag) {
-      switch (flag) {
-        case "file":
-          return 0;
-        case "link":
-          return 1;
-        case "symlink":
-          return 2;
-        case "character-device":
-          return 3;
-        case "block-device":
-          return 4;
-        case "directory":
-          return 5;
-        case "fifo":
-          return 6;
-        case "contiguous-file":
-          return 7;
-        case "pax-header":
-          return 72;
-      }
-      return 0;
-    }
-    function indexOf(block, num, offset, end) {
-      for (; offset < end; offset++) {
-        if (block[offset] === num) return offset;
-      }
-      return end;
-    }
-    function cksum(block) {
-      let sum = 8 * 32;
-      for (let i = 0; i < 148; i++) sum += block[i];
-      for (let j = 156; j < 512; j++) sum += block[j];
-      return sum;
-    }
-    function encodeOct(val, n) {
-      val = val.toString(8);
-      if (val.length > n) return SEVENS.slice(0, n) + " ";
-      return ZEROS.slice(0, n - val.length) + val + " ";
-    }
-    function encodeSizeBin(num, buf, off) {
-      buf[off] = 128;
-      for (let i = 11; i > 0; i--) {
-        buf[off + i] = num & 255;
-        num = Math.floor(num / 256);
-      }
-    }
-    function encodeSize(num, buf, off) {
-      if (num.toString(8).length > 11) {
-        encodeSizeBin(num, buf, off);
-      } else {
-        b4a.write(buf, encodeOct(num, 11), off);
-      }
-    }
-    function parse256(buf) {
-      let positive;
-      if (buf[0] === 128) positive = true;
-      else if (buf[0] === 255) positive = false;
-      else return null;
-      const tuple = [];
-      let i;
-      for (i = buf.length - 1; i > 0; i--) {
-        const byte = buf[i];
-        if (positive) tuple.push(byte);
-        else tuple.push(255 - byte);
-      }
-      let sum = 0;
-      const l = tuple.length;
-      for (i = 0; i < l; i++) {
-        sum += tuple[i] * Math.pow(256, i);
-      }
-      return positive ? sum : -1 * sum;
-    }
-    function decodeOct(val, offset, length) {
-      val = val.subarray(offset, offset + length);
-      offset = 0;
-      if (val[offset] & 128) {
-        return parse256(val);
-      } else {
-        while (offset < val.length && val[offset] === 32) offset++;
-        const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
-        while (offset < end && val[offset] === 0) offset++;
-        if (end === offset) return 0;
-        return parseInt(b4a.toString(val.subarray(offset, end)), 8);
-      }
-    }
-    function decodeStr(val, offset, length, encoding) {
-      return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding);
-    }
-    function addLength(str) {
-      const len = b4a.byteLength(str);
-      let digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
-      if (len + digits >= Math.pow(10, digits)) digits++;
-      return len + digits + str;
-    }
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-stream/extract.js
-var require_extract = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-stream/extract.js"(exports, module) {
-    var { Writable, Readable: Readable2, getStreamError } = require_streamx();
-    var FIFO = require_fast_fifo();
-    var b4a = require_b4a();
-    var headers = require_headers();
-    var EMPTY = b4a.alloc(0);
-    var BufferList = class {
-      constructor() {
-        this.buffered = 0;
-        this.shifted = 0;
-        this.queue = new FIFO();
-        this._offset = 0;
-      }
-      push(buffer) {
-        this.buffered += buffer.byteLength;
-        this.queue.push(buffer);
-      }
-      shiftFirst(size) {
-        return this._buffered === 0 ? null : this._next(size);
-      }
-      shift(size) {
-        if (size > this.buffered) return null;
-        if (size === 0) return EMPTY;
-        let chunk = this._next(size);
-        if (size === chunk.byteLength) return chunk;
-        const chunks = [chunk];
-        while ((size -= chunk.byteLength) > 0) {
-          chunk = this._next(size);
-          chunks.push(chunk);
-        }
-        return b4a.concat(chunks);
-      }
-      _next(size) {
-        const buf = this.queue.peek();
-        const rem = buf.byteLength - this._offset;
-        if (size >= rem) {
-          const sub = this._offset ? buf.subarray(this._offset, buf.byteLength) : buf;
-          this.queue.shift();
-          this._offset = 0;
-          this.buffered -= rem;
-          this.shifted += rem;
-          return sub;
-        }
-        this.buffered -= size;
-        this.shifted += size;
-        return buf.subarray(this._offset, this._offset += size);
-      }
-    };
-    var Source = class extends Readable2 {
-      constructor(self, header, offset) {
-        super();
-        this.header = header;
-        this.offset = offset;
-        this._parent = self;
-      }
-      _read(cb) {
-        if (this.header.size === 0) {
-          this.push(null);
-        }
-        if (this._parent._stream === this) {
-          this._parent._update();
-        }
-        cb(null);
-      }
-      _predestroy() {
-        this._parent.destroy(getStreamError(this));
-      }
-      _detach() {
-        if (this._parent._stream === this) {
-          this._parent._stream = null;
-          this._parent._missing = overflow(this.header.size);
-          this._parent._update();
-        }
-      }
-      _destroy(cb) {
-        this._detach();
-        cb(null);
-      }
-    };
-    var Extract = class extends Writable {
-      constructor(opts) {
-        super(opts);
-        if (!opts) opts = {};
-        this._buffer = new BufferList();
-        this._offset = 0;
-        this._header = null;
-        this._stream = null;
-        this._missing = 0;
-        this._longHeader = false;
-        this._callback = noop;
-        this._locked = false;
-        this._finished = false;
-        this._pax = null;
-        this._paxGlobal = null;
-        this._gnuLongPath = null;
-        this._gnuLongLinkPath = null;
-        this._filenameEncoding = opts.filenameEncoding || "utf-8";
-        this._allowUnknownFormat = !!opts.allowUnknownFormat;
-        this._unlockBound = this._unlock.bind(this);
-      }
-      _unlock(err) {
-        this._locked = false;
-        if (err) {
-          this.destroy(err);
-          this._continueWrite(err);
-          return;
-        }
-        this._update();
-      }
-      _consumeHeader() {
-        if (this._locked) return false;
-        this._offset = this._buffer.shifted;
-        try {
-          this._header = headers.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
-        } catch (err) {
-          this._continueWrite(err);
-          return false;
-        }
-        if (!this._header) return true;
-        switch (this._header.type) {
-          case "gnu-long-path":
-          case "gnu-long-link-path":
-          case "pax-global-header":
-          case "pax-header":
-            this._longHeader = true;
-            this._missing = this._header.size;
-            return true;
-        }
-        this._locked = true;
-        this._applyLongHeaders();
-        if (this._header.size === 0 || this._header.type === "directory") {
-          this.emit("entry", this._header, this._createStream(), this._unlockBound);
-          return true;
-        }
-        this._stream = this._createStream();
-        this._missing = this._header.size;
-        this.emit("entry", this._header, this._stream, this._unlockBound);
-        return true;
-      }
-      _applyLongHeaders() {
-        if (this._gnuLongPath) {
-          this._header.name = this._gnuLongPath;
-          this._gnuLongPath = null;
-        }
-        if (this._gnuLongLinkPath) {
-          this._header.linkname = this._gnuLongLinkPath;
-          this._gnuLongLinkPath = null;
-        }
-        if (this._pax) {
-          if (this._pax.path) this._header.name = this._pax.path;
-          if (this._pax.linkpath) this._header.linkname = this._pax.linkpath;
-          if (this._pax.size) this._header.size = parseInt(this._pax.size, 10);
-          this._header.pax = this._pax;
-          this._pax = null;
-        }
-      }
-      _decodeLongHeader(buf) {
-        switch (this._header.type) {
-          case "gnu-long-path":
-            this._gnuLongPath = headers.decodeLongPath(buf, this._filenameEncoding);
-            break;
-          case "gnu-long-link-path":
-            this._gnuLongLinkPath = headers.decodeLongPath(buf, this._filenameEncoding);
-            break;
-          case "pax-global-header":
-            this._paxGlobal = headers.decodePax(buf);
-            break;
-          case "pax-header":
-            this._pax = this._paxGlobal === null ? headers.decodePax(buf) : Object.assign({}, this._paxGlobal, headers.decodePax(buf));
-            break;
-        }
-      }
-      _consumeLongHeader() {
-        this._longHeader = false;
-        this._missing = overflow(this._header.size);
-        const buf = this._buffer.shift(this._header.size);
-        try {
-          this._decodeLongHeader(buf);
-        } catch (err) {
-          this._continueWrite(err);
-          return false;
-        }
-        return true;
-      }
-      _consumeStream() {
-        const buf = this._buffer.shiftFirst(this._missing);
-        if (buf === null) return false;
-        this._missing -= buf.byteLength;
-        const drained = this._stream.push(buf);
-        if (this._missing === 0) {
-          this._stream.push(null);
-          if (drained) this._stream._detach();
-          return drained && this._locked === false;
-        }
-        return drained;
-      }
-      _createStream() {
-        return new Source(this, this._header, this._offset);
-      }
-      _update() {
-        while (this._buffer.buffered > 0 && !this.destroying) {
-          if (this._missing > 0) {
-            if (this._stream !== null) {
-              if (this._consumeStream() === false) return;
-              continue;
-            }
-            if (this._longHeader === true) {
-              if (this._missing > this._buffer.buffered) break;
-              if (this._consumeLongHeader() === false) return false;
-              continue;
-            }
-            const ignore = this._buffer.shiftFirst(this._missing);
-            if (ignore !== null) this._missing -= ignore.byteLength;
-            continue;
-          }
-          if (this._buffer.buffered < 512) break;
-          if (this._stream !== null || this._consumeHeader() === false) return;
-        }
-        this._continueWrite(null);
-      }
-      _continueWrite(err) {
-        const cb = this._callback;
-        this._callback = noop;
-        cb(err);
-      }
-      _write(data, cb) {
-        this._callback = cb;
-        this._buffer.push(data);
-        this._update();
-      }
-      _final(cb) {
-        this._finished = this._missing === 0 && this._buffer.buffered === 0;
-        cb(this._finished ? null : new Error("Unexpected end of data"));
-      }
-      _predestroy() {
-        this._continueWrite(null);
-      }
-      _destroy(cb) {
-        if (this._stream) this._stream.destroy(getStreamError(this));
-        cb(null);
-      }
-      [Symbol.asyncIterator]() {
-        let error = null;
-        let promiseResolve = null;
-        let promiseReject = null;
-        let entryStream = null;
-        let entryCallback = null;
-        const extract3 = this;
-        this.on("entry", onentry);
-        this.on("error", (err) => {
-          error = err;
-        });
-        this.on("close", onclose);
-        return {
-          [Symbol.asyncIterator]() {
-            return this;
-          },
-          next() {
-            return new Promise(onnext);
-          },
-          return() {
-            return destroy(null);
-          },
-          throw(err) {
-            return destroy(err);
-          }
-        };
-        function consumeCallback(err) {
-          if (!entryCallback) return;
-          const cb = entryCallback;
-          entryCallback = null;
-          cb(err);
-        }
-        function onnext(resolve3, reject) {
-          if (error) {
-            return reject(error);
-          }
-          if (entryStream) {
-            resolve3({ value: entryStream, done: false });
-            entryStream = null;
-            return;
-          }
-          promiseResolve = resolve3;
-          promiseReject = reject;
-          consumeCallback(null);
-          if (extract3._finished && promiseResolve) {
-            promiseResolve({ value: void 0, done: true });
-            promiseResolve = promiseReject = null;
-          }
-        }
-        function onentry(header, stream, callback) {
-          entryCallback = callback;
-          stream.on("error", noop);
-          if (promiseResolve) {
-            promiseResolve({ value: stream, done: false });
-            promiseResolve = promiseReject = null;
-          } else {
-            entryStream = stream;
-          }
-        }
-        function onclose() {
-          consumeCallback(error);
-          if (!promiseResolve) return;
-          if (error) promiseReject(error);
-          else promiseResolve({ value: void 0, done: true });
-          promiseResolve = promiseReject = null;
-        }
-        function destroy(err) {
-          extract3.destroy(err);
-          consumeCallback(err);
-          return new Promise((resolve3, reject) => {
-            if (extract3.destroyed) return resolve3({ value: void 0, done: true });
-            extract3.once("close", function() {
-              if (err) reject(err);
-              else resolve3({ value: void 0, done: true });
-            });
-          });
-        }
-      }
-    };
-    module.exports = function extract3(opts) {
-      return new Extract(opts);
-    };
-    function noop() {
-    }
-    function overflow(size) {
-      size &= 511;
-      return size && 512 - size;
-    }
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-stream/constants.js
-var require_constants = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-stream/constants.js"(exports, module) {
-    var constants = {
-      // just for envs without fs
-      S_IFMT: 61440,
-      S_IFDIR: 16384,
-      S_IFCHR: 8192,
-      S_IFBLK: 24576,
-      S_IFIFO: 4096,
-      S_IFLNK: 40960
-    };
-    try {
-      module.exports = __require("fs").constants || constants;
-    } catch {
-      module.exports = constants;
-    }
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-stream/pack.js
-var require_pack = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-stream/pack.js"(exports, module) {
-    var { Readable: Readable2, Writable, getStreamError } = require_streamx();
-    var b4a = require_b4a();
-    var constants = require_constants();
-    var headers = require_headers();
-    var DMODE = 493;
-    var FMODE = 420;
-    var END_OF_TAR = b4a.alloc(1024);
-    var Sink = class extends Writable {
-      constructor(pack, header, callback) {
-        super({ mapWritable, eagerOpen: true });
-        this.written = 0;
-        this.header = header;
-        this._callback = callback;
-        this._linkname = null;
-        this._isLinkname = header.type === "symlink" && !header.linkname;
-        this._isVoid = header.type !== "file" && header.type !== "contiguous-file";
-        this._finished = false;
-        this._pack = pack;
-        this._openCallback = null;
-        if (this._pack._stream === null) this._pack._stream = this;
-        else this._pack._pending.push(this);
-      }
-      _open(cb) {
-        this._openCallback = cb;
-        if (this._pack._stream === this) this._continueOpen();
-      }
-      _continuePack(err) {
-        if (this._callback === null) return;
-        const callback = this._callback;
-        this._callback = null;
-        callback(err);
-      }
-      _continueOpen() {
-        if (this._pack._stream === null) this._pack._stream = this;
-        const cb = this._openCallback;
-        this._openCallback = null;
-        if (cb === null) return;
-        if (this._pack.destroying) return cb(new Error("pack stream destroyed"));
-        if (this._pack._finalized) return cb(new Error("pack stream is already finalized"));
-        this._pack._stream = this;
-        if (!this._isLinkname) {
-          this._pack._encode(this.header);
-        }
-        if (this._isVoid) {
-          this._finish();
-          this._continuePack(null);
-        }
-        cb(null);
-      }
-      _write(data, cb) {
-        if (this._isLinkname) {
-          this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data;
-          return cb(null);
-        }
-        if (this._isVoid) {
-          if (data.byteLength > 0) {
-            return cb(new Error("No body allowed for this entry"));
-          }
-          return cb();
-        }
-        this.written += data.byteLength;
-        if (this._pack.push(data)) return cb();
-        this._pack._drain = cb;
-      }
-      _finish() {
-        if (this._finished) return;
-        this._finished = true;
-        if (this._isLinkname) {
-          this.header.linkname = this._linkname ? b4a.toString(this._linkname, "utf-8") : "";
-          this._pack._encode(this.header);
-        }
-        overflow(this._pack, this.header.size);
-        this._pack._done(this);
-      }
-      _final(cb) {
-        if (this.written !== this.header.size) {
-          return cb(new Error("Size mismatch"));
-        }
-        this._finish();
-        cb(null);
-      }
-      _getError() {
-        return getStreamError(this) || new Error("tar entry destroyed");
-      }
-      _predestroy() {
-        this._pack.destroy(this._getError());
-      }
-      _destroy(cb) {
-        this._pack._done(this);
-        this._continuePack(this._finished ? null : this._getError());
-        cb();
-      }
-    };
-    var Pack = class extends Readable2 {
-      constructor(opts) {
-        super(opts);
-        this._drain = noop;
-        this._finalized = false;
-        this._finalizing = false;
-        this._pending = [];
-        this._stream = null;
-      }
-      entry(header, buffer, callback) {
-        if (this._finalized || this.destroying) throw new Error("already finalized or destroyed");
-        if (typeof buffer === "function") {
-          callback = buffer;
-          buffer = null;
-        }
-        if (!callback) callback = noop;
-        if (!header.size || header.type === "symlink") header.size = 0;
-        if (!header.type) header.type = modeToType(header.mode);
-        if (!header.mode) header.mode = header.type === "directory" ? DMODE : FMODE;
-        if (!header.uid) header.uid = 0;
-        if (!header.gid) header.gid = 0;
-        if (!header.mtime) header.mtime = /* @__PURE__ */ new Date();
-        if (typeof buffer === "string") buffer = b4a.from(buffer);
-        const sink = new Sink(this, header, callback);
-        if (b4a.isBuffer(buffer)) {
-          header.size = buffer.byteLength;
-          sink.write(buffer);
-          sink.end();
-          return sink;
-        }
-        if (sink._isVoid) {
-          return sink;
-        }
-        return sink;
-      }
-      finalize() {
-        if (this._stream || this._pending.length > 0) {
-          this._finalizing = true;
-          return;
-        }
-        if (this._finalized) return;
-        this._finalized = true;
-        this.push(END_OF_TAR);
-        this.push(null);
-      }
-      _done(stream) {
-        if (stream !== this._stream) return;
-        this._stream = null;
-        if (this._finalizing) this.finalize();
-        if (this._pending.length) this._pending.shift()._continueOpen();
-      }
-      _encode(header) {
-        if (!header.pax) {
-          const buf = headers.encode(header);
-          if (buf) {
-            this.push(buf);
-            return;
-          }
-        }
-        this._encodePax(header);
-      }
-      _encodePax(header) {
-        const paxHeader = headers.encodePax({
-          name: header.name,
-          linkname: header.linkname,
-          pax: header.pax
-        });
-        const newHeader = {
-          name: "PaxHeader",
-          mode: header.mode,
-          uid: header.uid,
-          gid: header.gid,
-          size: paxHeader.byteLength,
-          mtime: header.mtime,
-          type: "pax-header",
-          linkname: header.linkname && "PaxHeader",
-          uname: header.uname,
-          gname: header.gname,
-          devmajor: header.devmajor,
-          devminor: header.devminor
-        };
-        this.push(headers.encode(newHeader));
-        this.push(paxHeader);
-        overflow(this, paxHeader.byteLength);
-        newHeader.size = header.size;
-        newHeader.type = header.type;
-        this.push(headers.encode(newHeader));
-      }
-      _doDrain() {
-        const drain = this._drain;
-        this._drain = noop;
-        drain();
-      }
-      _predestroy() {
-        const err = getStreamError(this);
-        if (this._stream) this._stream.destroy(err);
-        while (this._pending.length) {
-          const stream = this._pending.shift();
-          stream.destroy(err);
-          stream._continueOpen();
-        }
-        this._doDrain();
-      }
-      _read(cb) {
-        this._doDrain();
-        cb();
-      }
-    };
-    module.exports = function pack(opts) {
-      return new Pack(opts);
-    };
-    function modeToType(mode) {
-      switch (mode & constants.S_IFMT) {
-        case constants.S_IFBLK:
-          return "block-device";
-        case constants.S_IFCHR:
-          return "character-device";
-        case constants.S_IFDIR:
-          return "directory";
-        case constants.S_IFIFO:
-          return "fifo";
-        case constants.S_IFLNK:
-          return "symlink";
-      }
-      return "file";
-    }
-    function noop() {
-    }
-    function overflow(self, size) {
-      size &= 511;
-      if (size) self.push(END_OF_TAR.subarray(0, 512 - size));
-    }
-    function mapWritable(buf) {
-      return b4a.isBuffer(buf) ? buf : b4a.from(buf);
-    }
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-stream/index.js
-var require_tar_stream = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-stream/index.js"(exports) {
-    exports.extract = require_extract();
-    exports.pack = require_pack();
-  }
-});
-
-// ../../node_modules/wrappy/wrappy.js
-var require_wrappy = __commonJS({
-  "../../node_modules/wrappy/wrappy.js"(exports, module) {
-    module.exports = wrappy;
-    function wrappy(fn, cb) {
-      if (fn && cb) return wrappy(fn)(cb);
-      if (typeof fn !== "function")
-        throw new TypeError("need wrapper function");
-      Object.keys(fn).forEach(function(k) {
-        wrapper[k] = fn[k];
-      });
-      return wrapper;
-      function wrapper() {
-        var args = new Array(arguments.length);
-        for (var i = 0; i < args.length; i++) {
-          args[i] = arguments[i];
-        }
-        var ret = fn.apply(this, args);
-        var cb2 = args[args.length - 1];
-        if (typeof ret === "function" && ret !== cb2) {
-          Object.keys(cb2).forEach(function(k) {
-            ret[k] = cb2[k];
-          });
-        }
-        return ret;
-      }
-    }
-  }
-});
-
-// ../../node_modules/once/once.js
-var require_once = __commonJS({
-  "../../node_modules/once/once.js"(exports, module) {
-    var wrappy = require_wrappy();
-    module.exports = wrappy(once);
-    module.exports.strict = wrappy(onceStrict);
-    once.proto = once(function() {
-      Object.defineProperty(Function.prototype, "once", {
-        value: function() {
-          return once(this);
-        },
-        configurable: true
-      });
-      Object.defineProperty(Function.prototype, "onceStrict", {
-        value: function() {
-          return onceStrict(this);
-        },
-        configurable: true
-      });
-    });
-    function once(fn) {
-      var f = function() {
-        if (f.called) return f.value;
-        f.called = true;
-        return f.value = fn.apply(this, arguments);
-      };
-      f.called = false;
-      return f;
-    }
-    function onceStrict(fn) {
-      var f = function() {
-        if (f.called)
-          throw new Error(f.onceError);
-        f.called = true;
-        return f.value = fn.apply(this, arguments);
-      };
-      var name = fn.name || "Function wrapped with `once`";
-      f.onceError = name + " shouldn't be called more than once";
-      f.called = false;
-      return f;
-    }
-  }
-});
-
-// ../../node_modules/end-of-stream/index.js
-var require_end_of_stream = __commonJS({
-  "../../node_modules/end-of-stream/index.js"(exports, module) {
-    var once = require_once();
-    var noop = function() {
-    };
-    var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
-    var isRequest = function(stream) {
-      return stream.setHeader && typeof stream.abort === "function";
-    };
-    var isChildProcess = function(stream) {
-      return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
-    };
-    var eos = function(stream, opts, callback) {
-      if (typeof opts === "function") return eos(stream, null, opts);
-      if (!opts) opts = {};
-      callback = once(callback || noop);
-      var ws = stream._writableState;
-      var rs = stream._readableState;
-      var readable = opts.readable || opts.readable !== false && stream.readable;
-      var writable = opts.writable || opts.writable !== false && stream.writable;
-      var cancelled = false;
-      var onlegacyfinish = function() {
-        if (!stream.writable) onfinish();
-      };
-      var onfinish = function() {
-        writable = false;
-        if (!readable) callback.call(stream);
-      };
-      var onend = function() {
-        readable = false;
-        if (!writable) callback.call(stream);
-      };
-      var onexit = function(exitCode) {
-        callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
-      };
-      var onerror = function(err) {
-        callback.call(stream, err);
-      };
-      var onclose = function() {
-        qnt(onclosenexttick);
-      };
-      var onclosenexttick = function() {
-        if (cancelled) return;
-        if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error("premature close"));
-        if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error("premature close"));
-      };
-      var onrequest = function() {
-        stream.req.on("finish", onfinish);
-      };
-      if (isRequest(stream)) {
-        stream.on("complete", onfinish);
-        stream.on("abort", onclose);
-        if (stream.req) onrequest();
-        else stream.on("request", onrequest);
-      } else if (writable && !ws) {
-        stream.on("end", onlegacyfinish);
-        stream.on("close", onlegacyfinish);
-      }
-      if (isChildProcess(stream)) stream.on("exit", onexit);
-      stream.on("end", onend);
-      stream.on("finish", onfinish);
-      if (opts.error !== false) stream.on("error", onerror);
-      stream.on("close", onclose);
-      return function() {
-        cancelled = true;
-        stream.removeListener("complete", onfinish);
-        stream.removeListener("abort", onclose);
-        stream.removeListener("request", onrequest);
-        if (stream.req) stream.req.removeListener("finish", onfinish);
-        stream.removeListener("end", onlegacyfinish);
-        stream.removeListener("close", onlegacyfinish);
-        stream.removeListener("finish", onfinish);
-        stream.removeListener("exit", onexit);
-        stream.removeListener("end", onend);
-        stream.removeListener("error", onerror);
-        stream.removeListener("close", onclose);
-      };
-    };
-    module.exports = eos;
-  }
-});
-
-// ../../node_modules/pump/index.js
-var require_pump = __commonJS({
-  "../../node_modules/pump/index.js"(exports, module) {
-    var once = require_once();
-    var eos = require_end_of_stream();
-    var fs;
-    try {
-      fs = __require("fs");
-    } catch (e) {
-    }
-    var noop = function() {
-    };
-    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
-    var isFn = function(fn) {
-      return typeof fn === "function";
-    };
-    var isFS = function(stream) {
-      if (!ancient) return false;
-      if (!fs) return false;
-      return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
-    };
-    var isRequest = function(stream) {
-      return stream.setHeader && isFn(stream.abort);
-    };
-    var destroyer = function(stream, reading, writing, callback) {
-      callback = once(callback);
-      var closed = false;
-      stream.on("close", function() {
-        closed = true;
-      });
-      eos(stream, { readable: reading, writable: writing }, function(err) {
-        if (err) return callback(err);
-        closed = true;
-        callback();
-      });
-      var destroyed = false;
-      return function(err) {
-        if (closed) return;
-        if (destroyed) return;
-        destroyed = true;
-        if (isFS(stream)) return stream.close(noop);
-        if (isRequest(stream)) return stream.abort();
-        if (isFn(stream.destroy)) return stream.destroy();
-        callback(err || new Error("stream was destroyed"));
-      };
-    };
-    var call = function(fn) {
-      fn();
-    };
-    var pipe = function(from, to) {
-      return from.pipe(to);
-    };
-    var pump = function() {
-      var streams = Array.prototype.slice.call(arguments);
-      var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
-      if (Array.isArray(streams[0])) streams = streams[0];
-      if (streams.length < 2) throw new Error("pump requires two streams per minimum");
-      var error;
-      var destroys = streams.map(function(stream, i) {
-        var reading = i < streams.length - 1;
-        var writing = i > 0;
-        return destroyer(stream, reading, writing, function(err) {
-          if (!error) error = err;
-          if (err) destroys.forEach(call);
-          if (reading) return;
-          destroys.forEach(call);
-          callback(error);
-        });
-      });
-      return streams.reduce(pipe);
-    };
-    module.exports = pump;
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/node_modules/tar-fs/index.js
-var require_tar_fs = __commonJS({
-  "../../node_modules/@sparticuz/chromium/node_modules/tar-fs/index.js"(exports) {
-    var tar = require_tar_stream();
-    var pump = require_pump();
-    var fs = __require("fs");
-    var path = __require("path");
-    var win32 = (global.Bare ? global.Bare.platform : process.platform) === "win32";
-    exports.pack = function pack(cwd, opts) {
-      if (!cwd) cwd = ".";
-      if (!opts) opts = {};
-      const xfs = opts.fs || fs;
-      const ignore = opts.ignore || opts.filter || noop;
-      const mapStream = opts.mapStream || echo;
-      const statNext = statAll(xfs, opts.dereference ? xfs.stat : xfs.lstat, cwd, ignore, opts.entries, opts.sort);
-      const strict = opts.strict !== false;
-      const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask();
-      const pack2 = opts.pack || tar.pack();
-      const finish = opts.finish || noop;
-      let map = opts.map || noop;
-      let dmode = typeof opts.dmode === "number" ? opts.dmode : 0;
-      let fmode = typeof opts.fmode === "number" ? opts.fmode : 0;
-      if (opts.strip) map = strip(map, opts.strip);
-      if (opts.readable) {
-        dmode |= parseInt(555, 8);
-        fmode |= parseInt(444, 8);
-      }
-      if (opts.writable) {
-        dmode |= parseInt(333, 8);
-        fmode |= parseInt(222, 8);
-      }
-      onnextentry();
-      function onsymlink(filename, header) {
-        xfs.readlink(path.join(cwd, filename), function(err, linkname) {
-          if (err) return pack2.destroy(err);
-          header.linkname = normalize(linkname);
-          pack2.entry(header, onnextentry);
-        });
-      }
-      function onstat(err, filename, stat) {
-        if (pack2.destroyed) return;
-        if (err) return pack2.destroy(err);
-        if (!filename) {
-          if (opts.finalize !== false) pack2.finalize();
-          return finish(pack2);
-        }
-        if (stat.isSocket()) return onnextentry();
-        let header = {
-          name: normalize(filename),
-          mode: (stat.mode | (stat.isDirectory() ? dmode : fmode)) & umask,
-          mtime: stat.mtime,
-          size: stat.size,
-          type: "file",
-          uid: stat.uid,
-          gid: stat.gid
-        };
-        if (stat.isDirectory()) {
-          header.size = 0;
-          header.type = "directory";
-          header = map(header) || header;
-          return pack2.entry(header, onnextentry);
-        }
-        if (stat.isSymbolicLink()) {
-          header.size = 0;
-          header.type = "symlink";
-          header = map(header) || header;
-          return onsymlink(filename, header);
-        }
-        header = map(header) || header;
-        if (!stat.isFile()) {
-          if (strict) return pack2.destroy(new Error("unsupported type for " + filename));
-          return onnextentry();
-        }
-        const entry = pack2.entry(header, onnextentry);
-        const rs = mapStream(xfs.createReadStream(path.join(cwd, filename), { start: 0, end: header.size > 0 ? header.size - 1 : header.size }), header);
-        rs.on("error", function(err2) {
-          entry.destroy(err2);
-        });
-        pump(rs, entry);
-      }
-      function onnextentry(err) {
-        if (err) return pack2.destroy(err);
-        statNext(onstat);
-      }
-      return pack2;
-    };
-    function head(list) {
-      return list.length ? list[list.length - 1] : null;
-    }
-    function processGetuid() {
-      return !global.Bare && process.getuid ? process.getuid() : -1;
-    }
-    function processUmask() {
-      return !global.Bare && process.umask ? process.umask() : 0;
-    }
-    exports.extract = function extract3(cwd, opts) {
-      if (!cwd) cwd = ".";
-      if (!opts) opts = {};
-      cwd = path.resolve(cwd);
-      const xfs = opts.fs || fs;
-      const ignore = opts.ignore || opts.filter || noop;
-      const mapStream = opts.mapStream || echo;
-      const own = opts.chown !== false && !win32 && processGetuid() === 0;
-      const extract4 = opts.extract || tar.extract();
-      const stack = [];
-      const now = /* @__PURE__ */ new Date();
-      const umask = typeof opts.umask === "number" ? ~opts.umask : ~processUmask();
-      const strict = opts.strict !== false;
-      const validateSymLinks = opts.validateSymlinks !== false;
-      let map = opts.map || noop;
-      let dmode = typeof opts.dmode === "number" ? opts.dmode : 0;
-      let fmode = typeof opts.fmode === "number" ? opts.fmode : 0;
-      if (opts.strip) map = strip(map, opts.strip);
-      if (opts.readable) {
-        dmode |= parseInt(555, 8);
-        fmode |= parseInt(444, 8);
-      }
-      if (opts.writable) {
-        dmode |= parseInt(333, 8);
-        fmode |= parseInt(222, 8);
-      }
-      extract4.on("entry", onentry);
-      if (opts.finish) extract4.on("finish", opts.finish);
-      return extract4;
-      function onentry(header, stream, next) {
-        header = map(header) || header;
-        header.name = normalize(header.name);
-        const name = path.join(cwd, path.join("/", header.name));
-        if (ignore(name, header)) {
-          stream.resume();
-          return next();
-        }
-        const dir = path.join(name, ".") === path.join(cwd, ".") ? cwd : path.dirname(name);
-        validate(xfs, dir, path.join(cwd, "."), function(err, valid) {
-          if (err) return next(err);
-          if (!valid) return next(new Error(dir + " is not a valid path"));
-          if (header.type === "directory") {
-            stack.push([name, header.mtime]);
-            return mkdirfix(name, {
-              uid: header.uid,
-              gid: header.gid,
-              mode: header.mode
-            }, stat);
-          }
-          mkdirfix(dir, {
-            uid: header.uid,
-            gid: header.gid,
-            // normally, the folders with rights and owner should be part of the TAR file
-            // if this is not the case, create folder for same user as file and with
-            // standard permissions of 0o755 (rwxr-xr-x)
-            mode: 493
-          }, function(err2) {
-            if (err2) return next(err2);
-            switch (header.type) {
-              case "file":
-                return onfile();
-              case "link":
-                return onlink();
-              case "symlink":
-                return onsymlink();
-            }
-            if (strict) return next(new Error("unsupported type for " + name + " (" + header.type + ")"));
-            stream.resume();
-            next();
-          });
-        });
-        function stat(err) {
-          if (err) return next(err);
-          if (path.join(name, ".") === path.join(cwd, ".")) return next();
-          utimes(name, header, function(err2) {
-            if (err2) return next(err2);
-            if (win32) return next();
-            chperm(name, header, next);
-          });
-        }
-        function onsymlink() {
-          if (win32) return next();
-          xfs.unlink(name, function() {
-            const dst = path.resolve(path.dirname(name), header.linkname);
-            if (!inCwd(dst) && (validateSymLinks || opts.strip)) return next(new Error(name + " is not a valid symlink"));
-            validateNotSymlink(xfs, dst, path.join(cwd, "."), function(err, valid) {
-              if (err) return next(err);
-              if (!valid && validateSymLinks) return next(new Error(name + " is not a valid symlink"));
-              xfs.symlink(header.linkname, name, stat);
-            });
-          });
-        }
-        function onlink() {
-          if (win32) return next();
-          xfs.unlink(name, function() {
-            const link = path.join(cwd, path.join("/", header.linkname));
-            xfs.realpath(link, function(err, dst) {
-              if (err || !inCwd(dst)) return next(new Error(name + " is not a valid hardlink"));
-              xfs.link(dst, name, function(err2) {
-                if (err2 && err2.code === "EPERM" && opts.hardlinkAsFilesFallback) {
-                  stream = xfs.createReadStream(dst);
-                  return onfile();
-                }
-                stat(err2);
-              });
-            });
-          });
-        }
-        function inCwd(dst) {
-          return dst === cwd || dst.startsWith(cwd + path.sep);
-        }
-        function onfile() {
-          xfs.lstat(name, function(err, st) {
-            if (!err && st.isSymbolicLink()) return xfs.unlink(name, onwrite);
-            onwrite();
-          });
-          function onwrite(err) {
-            if (err) return next(err);
-            const ws = xfs.createWriteStream(name);
-            const rs = mapStream(stream, header);
-            ws.on("error", function(err2) {
-              rs.destroy(err2);
-            });
-            pump(rs, ws, function(err2) {
-              if (err2) return next(err2);
-              ws.on("close", stat);
-            });
-          }
-        }
-      }
-      function utimesParent(name, cb) {
-        let top;
-        while ((top = head(stack)) && name.slice(0, top[0].length) !== top[0]) stack.pop();
-        if (!top) return cb();
-        xfs.utimes(top[0], now, top[1], cb);
-      }
-      function utimes(name, header, cb) {
-        if (opts.utimes === false) return cb();
-        if (header.type === "directory") return xfs.utimes(name, now, header.mtime, cb);
-        if (header.type === "symlink") return utimesParent(name, cb);
-        xfs.utimes(name, now, header.mtime, function(err) {
-          if (err) return cb(err);
-          utimesParent(name, cb);
-        });
-      }
-      function chperm(name, header, cb) {
-        const link = header.type === "symlink";
-        const chmod = link ? xfs.lchmod : xfs.chmod;
-        const chown = link ? xfs.lchown : xfs.chown;
-        if (!chmod) return cb();
-        const mode = (header.mode | (header.type === "directory" ? dmode : fmode)) & umask & 511;
-        if (chown && own) chown.call(xfs, name, header.uid, header.gid, onchown);
-        else onchown(null);
-        function onchown(err) {
-          if (err) return cb(err);
-          if (!chmod) return cb();
-          chmod.call(xfs, name, mode, cb);
-        }
-      }
-      function mkdirfix(name, opts2, cb) {
-        xfs.stat(name, function(err) {
-          if (!err) return cb(null);
-          if (err.code !== "ENOENT") return cb(err);
-          xfs.mkdir(name, { mode: opts2.mode, recursive: true }, function(err2, made) {
-            if (err2) return cb(err2);
-            chperm(name, opts2, cb);
-          });
-        });
-      }
-    };
-    function validateNotSymlink(fs2, name, root, cb) {
-      if (name === root) return cb(null, true);
-      if (!name.startsWith(root + path.sep)) return cb(null, false);
-      fs2.lstat(name, function(err, st) {
-        if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err);
-        if (err || !st.isSymbolicLink()) return validateNotSymlink(fs2, path.join(name, ".."), root, cb);
-        cb(null, false);
-      });
-    }
-    function validate(fs2, name, root, cb) {
-      if (name === root) return cb(null, true);
-      fs2.lstat(name, function(err, st) {
-        if (err && err.code !== "ENOENT" && err.code !== "EPERM") return cb(err);
-        if (err || st.isDirectory()) return validate(fs2, path.join(name, ".."), root, cb);
-        cb(null, false);
-      });
-    }
-    function inside(root, name) {
-      return name === root || name.startsWith(root + path.sep);
-    }
-    function noop() {
-    }
-    function echo(name) {
-      return name;
-    }
-    function normalize(name) {
-      return win32 ? name.replace(/\\/g, "/").replace(/[:?<>|]/g, "_") : name;
-    }
-    function statAll(fs2, stat, cwd, ignore, entries, sort) {
-      if (!entries) entries = ["."];
-      const queue = entries.slice(0);
-      const root = path.resolve(cwd);
-      return function loop(callback) {
-        if (!queue.length) return callback(null);
-        const next = queue.shift();
-        const nextAbs = path.join(cwd, next);
-        if (!inside(root, path.resolve(cwd, next))) return callback(new Error(next + " is not a valid path"));
-        stat.call(fs2, nextAbs, function(err, stat2) {
-          if (err) return callback(entries.indexOf(next) === -1 && err.code === "ENOENT" ? null : err);
-          if (!stat2.isDirectory()) return callback(null, next, stat2);
-          fs2.readdir(nextAbs, function(err2, files) {
-            if (err2) return callback(err2);
-            if (sort) files.sort();
-            for (let i = 0; i < files.length; i++) {
-              if (!ignore(path.join(cwd, next, files[i]))) queue.push(path.join(next, files[i]));
-            }
-            callback(null, next, stat2);
-          });
-        });
-      };
-    }
-    function strip(map, level) {
-      return function(header) {
-        header.name = header.name.split("/").slice(level).join("/");
-        const linkname = header.linkname;
-        if (linkname && (header.type === "link" || path.isAbsolute(linkname))) {
-          header.linkname = linkname.split("/").slice(level).join("/");
-        }
-        return map(header);
-      };
-    }
-  }
-});
-var import_tar_fs, setupLambdaEnvironment, isValidUrl, isRunningInAmazonLinux2023, downloadAndExtract;
-var init_helper = __esm({
-  "../../node_modules/@sparticuz/chromium/build/helper.js"() {
-    import_tar_fs = __toESM(require_tar_fs());
-    setupLambdaEnvironment = (baseLibPath) => {
-      process.env["FONTCONFIG_PATH"] ??= join(tmpdir(), "fonts");
-      process.env["HOME"] ??= tmpdir();
-      if (process.env["LD_LIBRARY_PATH"] === void 0) {
-        process.env["LD_LIBRARY_PATH"] = baseLibPath;
-      } else if (!process.env["LD_LIBRARY_PATH"].startsWith(baseLibPath)) {
-        process.env["LD_LIBRARY_PATH"] = [
-          baseLibPath,
-          ...new Set(process.env["LD_LIBRARY_PATH"].split(":"))
-        ].join(":");
-      }
-    };
-    isValidUrl = (input) => {
-      try {
-        const url = new URL(input);
-        if (url.protocol === "https:")
-          return true;
-        if (url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]")) {
-          return true;
-        }
-        return false;
-      } catch {
-        return false;
-      }
-    };
-    isRunningInAmazonLinux2023 = (nodeMajorVersion2) => {
-      const awsExecEnv = process.env["AWS_EXECUTION_ENV"] ?? "";
-      const awsLambdaJsRuntime = process.env["AWS_LAMBDA_JS_RUNTIME"] ?? "";
-      const codebuildImage = process.env["CODEBUILD_BUILD_IMAGE"] ?? "";
-      if (awsExecEnv.includes("20.x") || awsExecEnv.includes("22.x") || awsExecEnv.includes("24.x") || awsLambdaJsRuntime.includes("20.x") || awsLambdaJsRuntime.includes("22.x") || awsLambdaJsRuntime.includes("24.x") || codebuildImage.includes("nodejs20") || codebuildImage.includes("nodejs22") || codebuildImage.includes("nodejs24")) {
-        return true;
-      }
-      if (process.env["VERCEL"] && nodeMajorVersion2 >= 20) {
-        return true;
-      }
-      return false;
-    };
-    downloadAndExtract = async (url) => {
-      const destDir = join(tmpdir(), "chromium-pack");
-      const response = await fetch(url, {
-        redirect: "follow",
-        signal: AbortSignal.timeout(3e5)
-      });
-      if (!response.ok) {
-        throw new Error(`Unexpected status code: ${String(response.status)}.`);
-      }
-      if (!response.body) {
-        throw new Error("Response body is empty.");
-      }
-      try {
-        await pipeline(Readable.fromWeb(response.body), (0, import_tar_fs.extract)(destDir));
-      } catch (error) {
-        await new Promise((resolve3) => {
-          rm(destDir, { force: true, recursive: true }, () => {
-            resolve3();
-          });
-        });
-        throw error;
-      }
-      return destDir;
-    };
-  }
-});
-var import_tar_fs2, ARCHIVE_EXTENSION_REGEX, TAR_EXTENSION_REGEX, BROTLI_EXTENSION_REGEX, GZIP_EXTENSION_REGEX, inflate;
-var init_lambdafs = __esm({
-  "../../node_modules/@sparticuz/chromium/build/lambdafs.js"() {
-    import_tar_fs2 = __toESM(require_tar_fs());
-    ARCHIVE_EXTENSION_REGEX = /\.(?:t(?:ar(?:\.(?:br|gz))?|br|gz)|br|gz)$/i;
-    TAR_EXTENSION_REGEX = /\.t(?:ar(?:\.(?:br|gz))?|br|gz)$/i;
-    BROTLI_EXTENSION_REGEX = /br$/i;
-    GZIP_EXTENSION_REGEX = /gz$/i;
-    inflate = (filePath) => {
-      const output = filePath.includes("swiftshader") ? tmpdir() : join(tmpdir(), basename(filePath).replace(ARCHIVE_EXTENSION_REGEX, ""));
-      return new Promise((resolve3, reject) => {
-        if (filePath.includes("swiftshader")) {
-          if (existsSync(`${output}/libGLESv2.so`)) {
-            resolve3(output);
-            return;
-          }
-        } else if (existsSync(output)) {
-          resolve3(output);
-          return;
-        }
-        const isBrotli = BROTLI_EXTENSION_REGEX.test(filePath);
-        const isGzip = GZIP_EXTENSION_REGEX.test(filePath);
-        const isTar = TAR_EXTENSION_REGEX.test(filePath);
-        const highWaterMark = 2 ** 22;
-        const source = createReadStream(filePath, { highWaterMark });
-        let target;
-        const handleError = (error) => {
-          reject(error);
-        };
-        source.once("error", handleError);
-        if (isTar) {
-          target = (0, import_tar_fs2.extract)(output);
-          target.once("finish", () => {
-            resolve3(output);
-          });
-        } else {
-          target = createWriteStream(output, { mode: 448 });
-          target.once("close", () => {
-            resolve3(output);
-          });
-        }
-        target.once("error", handleError);
-        if (isBrotli || isGzip) {
-          const decompressor = isBrotli ? createBrotliDecompress({ chunkSize: 2 ** 21 }) : createUnzip({ chunkSize: 2 ** 21 });
-          decompressor.once("error", handleError);
-          source.pipe(decompressor).pipe(target);
-        } else {
-          source.pipe(target);
-        }
-      });
-    };
-  }
-});
-function getBinPath() {
-  return join(dirname(fileURLToPath(import.meta.url)), "..", "bin");
-}
-var init_paths = __esm({
-  "../../node_modules/@sparticuz/chromium/build/paths.js"() {
-  }
-});
-
-// ../../node_modules/@sparticuz/chromium/build/index.js
-var build_exports = {};
-__export(build_exports, {
-  default: () => build_default,
-  inflate: () => inflate,
-  setupLambdaEnvironment: () => setupLambdaEnvironment
-});
-var nodeMajorVersion, Chromium, build_default;
-var init_build = __esm({
-  "../../node_modules/@sparticuz/chromium/build/index.js"() {
-    init_helper();
-    init_lambdafs();
-    init_paths();
-    init_helper();
-    init_lambdafs();
-    nodeMajorVersion = Number.parseInt(process.versions.node.split(".")[0] ?? "");
-    if (isRunningInAmazonLinux2023(nodeMajorVersion)) {
-      setupLambdaEnvironment(join(tmpdir(), "al2023", "lib"));
-    }
-    Chromium = class {
-      /**
-       * Returns a list of additional Chromium flags recommended for serverless environments.
-       * The canonical list of flags can be found on https://peter.sh/experiments/chromium-command-line-switches/.
-       * Most of below can be found here: https://github.com/GoogleChrome/chrome-launcher/blob/main/docs/chrome-flags-for-tools.md
-       */
-      static get args() {
-        const chromiumFlags = [
-          "--ash-no-nudges",
-          // Avoids blue bubble "user education" nudges (eg., "… give your browser a new look", Memory Saver)
-          "--disable-domain-reliability",
-          // Disables Domain Reliability Monitoring, which tracks whether the browser has difficulty contacting Google-owned sites and uploads reports to Google.
-          "--disable-print-preview",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kDisablePrintPreview&ss=chromium
-          "--disk-cache-size=33554432",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kDiskCacheSize&ss=chromium Forces the maximum disk space to be used by the disk cache, in bytes.
-          "--no-default-browser-check",
-          // Disable the default browser check, do not prompt to set it as such. (This is already set by Playwright, but not Puppeteer)
-          "--no-pings",
-          // Don't send hyperlink auditing pings
-          "--single-process",
-          // Runs the renderer and plugins in the same process as the browser. NOTES: Needs to be single-process to avoid `prctl(PR_SET_NO_NEW_PRIVS) failed` error
-          "--font-render-hinting=none"
-          // https://github.com/puppeteer/puppeteer/issues/2410#issuecomment-560573612
-        ];
-        const chromiumDisableFeatures = [
-          "AudioServiceOutOfProcess",
-          "IsolateOrigins",
-          "site-per-process"
-          // Disables OOPIF. https://www.chromium.org/Home/chromium-security/site-isolation
-        ];
-        const chromiumEnableFeatures = ["SharedArrayBuffer"];
-        const graphicsFlags = [
-          "--ignore-gpu-blocklist",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kIgnoreGpuBlocklist&ss=chromium
-          "--in-process-gpu"
-          // Saves some memory by moving GPU process into a browser process thread
-        ];
-        if (this.graphics) {
-          graphicsFlags.push(
-            // As the unsafe WebGL fallback, SwANGLE (ANGLE + SwiftShader Vulkan)
-            "--use-gl=angle",
-            "--use-angle=swiftshader",
-            "--enable-unsafe-swiftshader"
-          );
-        } else {
-          graphicsFlags.push("--disable-webgl");
-        }
-        const insecureFlags = [
-          "--allow-running-insecure-content",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kAllowRunningInsecureContent&ss=chromium
-          "--disable-setuid-sandbox",
-          // Lambda runs as root, so this is required to allow Chromium to run as root
-          "--disable-site-isolation-trials",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kDisableSiteIsolation&ss=chromium
-          "--disable-web-security"
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kDisableWebSecurity&ss=chromium
-        ];
-        const headlessFlags = [
-          "--headless='shell'",
-          // We only support running chrome-headless-shell
-          "--no-sandbox",
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kNoSandbox&ss=chromium
-          "--no-zygote"
-          // https://source.chromium.org/search?q=lang:cpp+symbol:kNoZygote&ss=chromium
-        ];
-        return [
-          ...chromiumFlags,
-          `--disable-features=${[...chromiumDisableFeatures].join(",")}`,
-          `--enable-features=${[...chromiumEnableFeatures].join(",")}`,
-          ...graphicsFlags,
-          ...insecureFlags,
-          ...headlessFlags
-        ];
-      }
-      /**
-       * Returns whether the graphics stack is enabled or disabled
-       * @returns boolean
-       */
-      static get graphics() {
-        return this.graphicsMode;
-      }
-      /**
-       * Sets whether the graphics stack is enabled or disabled.
-       * @param true means the stack is enabled. WebGL will work.
-       * @param false means that the stack is disabled. WebGL will not work.
-       * @default true
-       */
-      static set setGraphicsMode(value) {
-        if (typeof value !== "boolean") {
-          throw new TypeError(`Graphics mode must be a boolean, you entered '${String(value)}'`);
-        }
-        this.graphicsMode = value;
-      }
-      /**
-       * If true, the graphics stack and webgl is enabled,
-       * If false, webgl will be disabled.
-       * (If false, the swiftshader.tar.br file will also not extract)
-       */
-      static graphicsMode = true;
-      /**
-       * Inflates the included version of Chromium
-       * @param input The location of the `bin` folder
-       * @returns The path to the `chromium` binary
-       */
-      static async executablePath(input) {
-        if (existsSync(join(tmpdir(), "chromium"))) {
-          return join(tmpdir(), "chromium");
-        }
-        if (input && isValidUrl(input)) {
-          return this.executablePath(await downloadAndExtract(input));
+          throw new OpenRouterError(message, response.status, void 0, response.headers);
         }
-        input ??= getBinPath();
-        if (!existsSync(input)) {
-          throw new Error(`The input directory "${input}" does not exist. If you are using a bundler (esbuild, webpack, etc.), you must externalize @sparticuz/chromium so it is not relocated. See: https://github.com/Sparticuz/chromium#bundler-configuration`);
+        if (!response.body) {
+          throw new OpenRouterError("No response body for streaming request", 500);
         }
-        const promises = [
-          inflate(join(input, "chromium.br")),
-          inflate(join(input, "fonts.tar.br")),
-          inflate(join(input, "swiftshader.tar.br"))
-        ];
-        if (isRunningInAmazonLinux2023(nodeMajorVersion)) {
-          promises.push(inflate(join(input, "al2023.tar.br")));
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed || trimmed.startsWith(":")) continue;
+              if (trimmed === "data: [DONE]") return;
+              if (!trimmed.startsWith("data: ")) continue;
+              const json = trimmed.slice("data: ".length);
+              try {
+                yield JSON.parse(json);
+              } catch {
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
         }
-        const result = await Promise.all(promises);
-        return result.shift();
       }
     };
-    build_default = Chromium;
   }
 });
 
@@ -3708,6 +426,50 @@ function createAnthropicClient(rawKey) {
   });
 }
 
+// src/adapters/claude/claude-code-login.ts
+var LOGIN_CHILD_ENV_NAMES = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "TERM",
+  "TZ",
+  "LANG",
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_STATE_HOME",
+  "XDG_RUNTIME_DIR",
+  "HTTPS_PROXY",
+  "https_proxy",
+  "HTTP_PROXY",
+  "http_proxy",
+  "NO_PROXY",
+  "no_proxy",
+  "ALL_PROXY",
+  "all_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR"
+];
+var LOGIN_CHILD_ENV = new Set(LOGIN_CHILD_ENV_NAMES);
+function loginChildEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (v !== void 0 && (LOGIN_CHILD_ENV.has(k) || k.startsWith("LC_"))) out[k] = v;
+  }
+  return out;
+}
+function claudeCodeLoginQueryOptions() {
+  return { tools: [], settingSources: [] };
+}
+
 // src/adapters/provider-router.ts
 function getBedrockModelId(model) {
   const BEDROCK_MAP = {
@@ -3757,6 +519,26 @@ function toJsonValue(value, path) {
     `Tool-call arguments contain a non-JSON value at '${path}' (${typeof value})`
   );
 }
+
+// src/adapters/openai/tokens.ts
+function splitOpenAiUsage(inputTokensInclCached, outputTokens, cachedTokens) {
+  return splitCacheInclusiveUsage(inputTokensInclCached, outputTokens, cachedTokens);
+}
+function splitCacheInclusiveUsage(inputTokensInclCached, outputTokens, cachedTokens) {
+  const cacheRead = Math.min(
+    Math.max(cachedTokens, 0),
+    Math.max(inputTokensInclCached, 0)
+  );
+  const nonCachedInput = Math.max(inputTokensInclCached, 0) - cacheRead;
+  return {
+    tokens: {
+      input: nonCachedInput,
+      output: outputTokens,
+      total: nonCachedInput + cacheRead + outputTokens
+    },
+    cacheReadTokens: cacheRead
+  };
+}
 function emitLlmTraceEvent(event) {
   return;
 }
@@ -3767,6 +549,271 @@ function newLlmTraceId() {
   return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
 }
 
+// src/adapters/claude/tool-bridge.ts
+var MCP_SERVER_NAME = "ggui";
+
+// src/harness/claude-code-login-query.ts
+var MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+function stripMcpToolPrefix(name) {
+  return name.startsWith(MCP_TOOL_PREFIX) ? name.slice(MCP_TOOL_PREFIX.length) : name;
+}
+var LOGIN_API_KEY_SOURCE = "none";
+var ClaudeCodeLoginAuthError = class extends Error {
+  apiKeySource;
+  constructor(apiKeySource) {
+    super(
+      `claude-code-login: the Claude Code binary authenticated from apiKeySource=${apiKeySource}, not from its login \u2014 a provider key reached the spawned process; the run was stopped before it spent a turn`
+    );
+    this.name = "ClaudeCodeLoginAuthError";
+    this.apiKeySource = apiKeySource;
+  }
+};
+var ClaudeCodeLoginResultError = class extends Error {
+  subtype;
+  errors;
+  status;
+  constructor(subtype, errors, status) {
+    super(
+      `claude-code-login: query() ended with ${subtype}` + (status !== void 0 ? ` (api status ${status})` : "") + `: ${errors.length > 0 ? errors.join("; ") : "no detail from the binary"}`
+    );
+    this.name = "ClaudeCodeLoginResultError";
+    this.subtype = subtype;
+    this.errors = errors;
+    this.status = status;
+  }
+};
+function createDenyingIntercept(intercepted) {
+  return async (toolName, input) => {
+    intercepted.push({ name: toolName, input });
+    return {
+      behavior: "deny",
+      message: "ggui executes tools in its harness; the binary only proposes them."
+    };
+  };
+}
+async function* imageUserMessage(text, image) {
+  const message = {
+    role: "user",
+    content: [
+      {
+        type: "image",
+        source: { type: "base64", media_type: image.mediaType, data: image.base64 }
+      },
+      { type: "text", text }
+    ]
+  };
+  yield { type: "user", message, parent_tool_use_id: null };
+}
+function buildLoginQueryOptions(params) {
+  return {
+    model: params.model,
+    systemPrompt: params.systemPrompt,
+    maxTurns: 1,
+    thinking: { type: "disabled" },
+    env: loginChildEnv(params.env ?? process.env),
+    ...claudeCodeLoginQueryOptions(),
+    ...params.tools !== void 0 ? {
+      mcpServers: { [MCP_SERVER_NAME]: params.tools.server },
+      canUseTool: params.tools.canUseTool
+    } : {}
+  };
+}
+var JSON_SCHEMA_TYPES = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "integer"
+];
+function isJsonSchemaType(value) {
+  return typeof value === "string" && JSON_SCHEMA_TYPES.includes(value);
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function schemaAt(value, path) {
+  if (typeof value === "boolean") return value;
+  if (!isJsonObject(value)) {
+    throw new Error(
+      `claude-code-login: ${path} must be a JSON-Schema object or boolean, got ${JSON.stringify(value)}`
+    );
+  }
+  return toZodJsonSchema(value, path);
+}
+function toZodJsonSchema(parameters, path = "parameters") {
+  const out = {};
+  for (const [key, value] of Object.entries(parameters)) {
+    if (value === void 0) continue;
+    switch (key) {
+      case "type": {
+        if (!isJsonSchemaType(value)) {
+          throw new Error(
+            `claude-code-login: ${path}.type must be one of ${JSON_SCHEMA_TYPES.join("|")}, got ${JSON.stringify(value)}`
+          );
+        }
+        out.type = value;
+        break;
+      }
+      case "properties":
+      case "patternProperties":
+      case "$defs": {
+        if (!isJsonObject(value))
+          throw new Error(`claude-code-login: ${path}.${key} must be an object`);
+        const record = {};
+        for (const [name, sub] of Object.entries(value)) {
+          if (sub === void 0) continue;
+          record[name] = schemaAt(sub, `${path}.${key}.${name}`);
+        }
+        if (key === "$defs") {
+          const defs = {};
+          for (const [name, sub] of Object.entries(record)) {
+            if (typeof sub === "boolean")
+              throw new Error(`claude-code-login: ${path}.$defs.${name} must be an object`);
+            defs[name] = sub;
+          }
+          out.$defs = defs;
+        } else {
+          out[key] = record;
+        }
+        break;
+      }
+      case "items": {
+        out.items = Array.isArray(value) ? value.map((sub, i) => schemaAt(sub, `${path}.items[${i}]`)) : schemaAt(value, `${path}.items`);
+        break;
+      }
+      case "additionalProperties":
+      case "not": {
+        out[key] = schemaAt(value, `${path}.${key}`);
+        break;
+      }
+      case "anyOf":
+      case "oneOf":
+      case "allOf": {
+        if (!Array.isArray(value))
+          throw new Error(`claude-code-login: ${path}.${key} must be an array`);
+        out[key] = value.map((sub, i) => {
+          const s = schemaAt(sub, `${path}.${key}[${i}]`);
+          if (typeof s === "boolean")
+            throw new Error(`claude-code-login: ${path}.${key}[${i}] must be an object`);
+          return s;
+        });
+        break;
+      }
+      case "required": {
+        if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+          throw new Error(`claude-code-login: ${path}.required must be an array of strings`);
+        }
+        out.required = value;
+        break;
+      }
+      case "enum": {
+        if (!Array.isArray(value) || !value.every(
+          (v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+        )) {
+          throw new Error(`claude-code-login: ${path}.enum must be an array of primitives`);
+        }
+        out.enum = value;
+        break;
+      }
+      default:
+        out[key] = value;
+    }
+  }
+  return out;
+}
+function createLoginToolServer(sdk, tools) {
+  const sdkTools = tools.map((def) => {
+    const schema = z.fromJSONSchema(toZodJsonSchema(def.parameters, `${def.name}.parameters`));
+    if (!(schema instanceof z.ZodObject)) {
+      throw new Error(
+        `claude-code-login: tool ${def.name}'s parameters must be a JSON-Schema object`
+      );
+    }
+    return sdk.tool(def.name, def.description, schema.shape, async () => {
+      throw new Error(
+        `claude-code-login: the binary tried to execute ${def.name} \u2014 ggui's tools are proposed to the harness and never run in the binary (the intercept denies every call)`
+      );
+    });
+  });
+  return sdk.createSdkMcpServer({ name: MCP_SERVER_NAME, version: "1.0.0", tools: sdkTools });
+}
+var LOGIN_REQUIRED_TOOL_INSTRUCTION = "Respond only with tool calls: do not write any text before, between or after them. Text outside a tool call is not read.";
+function describeCalls(calls) {
+  return JSON.stringify(calls.map((c) => ({ name: stripMcpToolPrefix(c.name), input: c.input })));
+}
+async function collectLoginTurn(stream, opts) {
+  let init;
+  const toolCalls = [];
+  let text = "";
+  let thinkingBlocks = 0;
+  let result;
+  try {
+    for await (const msg of stream) {
+      if (msg.type === "system" && msg.subtype === "init") {
+        const measured = msg;
+        init = measured;
+        opts.log(
+          `[claude-code-login] apiKeySource=${measured.apiKeySource} claude_code_version=${measured.claude_code_version} model=${measured.model}`
+        );
+        if (measured.apiKeySource !== LOGIN_API_KEY_SOURCE) {
+          throw new ClaudeCodeLoginAuthError(measured.apiKeySource);
+        }
+      } else if (msg.type === "assistant") {
+        for (const block of msg.message.content) {
+          if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              name: stripMcpToolPrefix(block.name),
+              input: isRecord(block.input) ? toolArgsToJsonObject(block.input) : {}
+            });
+          } else if (block.type === "text") {
+            text += block.text;
+          } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+            thinkingBlocks += 1;
+          }
+        }
+      } else if (msg.type === "result") {
+        result = msg;
+      }
+    }
+  } catch (e) {
+    if (result === void 0) throw e;
+    opts.log(
+      `[claude-code-login] query() threw after its result message \u2014 the result decides (${e instanceof Error ? e.message : String(e)})`
+    );
+  }
+  if (result === void 0) {
+    throw new Error("claude-code-login: query() ended without a result message");
+  }
+  const usage = result.usage;
+  const thinkingTokens = usage.output_tokens_details?.thinking_tokens ?? 0;
+  opts.log(
+    `[claude-code-login] usage kind=${opts.kind} input=${usage.input_tokens} output=${usage.output_tokens} cacheRead=${usage.cache_read_input_tokens} cacheCreated=${usage.cache_creation_input_tokens} thinking=${thinkingTokens} thinkingBlocks=${thinkingBlocks} textChars=${text.length} toolCalls=${toolCalls.length} stop=${result.stop_reason ?? "none"} choice=${opts.choice}`
+  );
+  const streamSaw = describeCalls(toolCalls);
+  const interceptSaw = describeCalls(opts.intercepted);
+  if (streamSaw !== interceptSaw) {
+    opts.warn(
+      `[claude-code-login] intercept/stream disagreement \u2014 the stream's blocks win. intercepted=${interceptSaw} stream=${streamSaw}`
+    );
+  }
+  if (result.subtype === "success") {
+    if (result.is_error) {
+      throw new ClaudeCodeLoginResultError(
+        "success",
+        [result.result],
+        result.api_error_status ?? void 0
+      );
+    }
+  } else if (result.subtype !== "error_max_turns") {
+    const failed = result;
+    throw new ClaudeCodeLoginResultError(failed.subtype, failed.errors, void 0);
+  }
+  return { init, toolCalls, text, result };
+}
+
 // src/harness/llm-router.ts
 function addStrictSchemaConstraints(schema) {
   const result = { ...schema };
@@ -3961,17 +1008,6 @@ var LLMAgent = class {
     }
   }
 };
-function normalizeAnthropicModelId(model) {
-  return model.replace(/^anthropic\//, "").replace(/^(?:[a-z]{2}\.)?anthropic\./, "");
-}
-function anthropicRejectsSamplingParams(model) {
-  return /^claude-(?:opus-4-7|opus-5|sonnet-5|fable-5)(?:-|$)/.test(
-    normalizeAnthropicModelId(model)
-  );
-}
-function anthropicRejectsForcedToolChoice(model) {
-  return /^claude-fable-5-1(?:-|$)/.test(normalizeAnthropicModelId(model));
-}
 function resolveAnthropicSampling(model, temperature) {
   if (temperature === void 0) {
     return { request: {}, applied: { temperature: "provider-default" } };
@@ -4307,6 +1343,170 @@ var AnthropicAgent = class extends LLMAgent {
     }
   }
 };
+var ClaudeCodeLoginAgent = class extends LLMAgent {
+  provider = "anthropic";
+  resolveModel(model) {
+    return model.startsWith("anthropic/") ? model.slice("anthropic/".length) : model;
+  }
+  async createClient() {
+    const { query: query2, tool: tool2, createSdkMcpServer: createSdkMcpServer2 } = await import('@anthropic-ai/claude-agent-sdk');
+    return { query: query2, tool: tool2, createSdkMcpServer: createSdkMcpServer2 };
+  }
+  async callText(model, systemPrompt, userPrompt, _maxTokens, _temperature) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    try {
+      const turn = await this.apiCall(
+        () => collectLoginTurn(
+          sdk.query({
+            prompt: userPrompt,
+            options: buildLoginQueryOptions({ model: resolvedModel, systemPrompt })
+          }),
+          { intercepted: [], kind: "callText", choice: "none", log: console.log, warn: console.warn }
+        )
+      );
+      const usage = turn.result.usage;
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callText",
+        systemPrompt,
+        userPrompt,
+        result: {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          cacheCreated: usage.cache_creation_input_tokens,
+          cacheRead: usage.cache_read_input_tokens,
+          text: turn.text
+        }
+      });
+      return { text: turn.text, inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+    } catch (e) {
+      emitLlmTraceEvent({
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callVision(model, systemPrompt, userPrompt, image, _maxTokens) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    try {
+      const turn = await this.apiCall(
+        () => collectLoginTurn(
+          sdk.query({
+            prompt: imageUserMessage(userPrompt, image),
+            options: buildLoginQueryOptions({ model: resolvedModel, systemPrompt })
+          }),
+          { intercepted: [], kind: "callVision", choice: "none", log: console.log, warn: console.warn }
+        )
+      );
+      const usage = turn.result.usage;
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callVision",
+        systemPrompt,
+        userPrompt,
+        result: { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens, text: turn.text }
+      });
+      return { text: turn.text, inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+    } catch (e) {
+      emitLlmTraceEvent({
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callTools(model, systemPrompt, userPrompt, tools, toolChoice = "required", _scopedTools) {
+    const sdk = await this.getClient();
+    const traceId = newLlmTraceId();
+    const startedAt = Date.now();
+    const resolvedModel = this.resolveModel(model);
+    const sentUserPrompt = toolChoice === "required" ? `${userPrompt}
+
+${LOGIN_REQUIRED_TOOL_INSTRUCTION}` : userPrompt;
+    try {
+      const turn = await this.apiCall(() => {
+        const intercepted = [];
+        const server = createLoginToolServer(sdk, tools);
+        return collectLoginTurn(
+          sdk.query({
+            prompt: sentUserPrompt,
+            options: buildLoginQueryOptions({
+              model: resolvedModel,
+              systemPrompt,
+              tools: { server, canUseTool: createDenyingIntercept(intercepted) }
+            })
+          }),
+          { intercepted, kind: "callTools", choice: toolChoice === "required" ? "required:instructed" : "auto", log: console.log, warn: console.warn }
+        );
+      });
+      const usage = turn.result.usage;
+      const cacheCreated = usage.cache_creation_input_tokens;
+      const cacheRead = usage.cache_read_input_tokens;
+      if (cacheCreated || cacheRead) {
+        console.log(
+          `[claude-code-login] callTools cache: created=${cacheCreated} read=${cacheRead} input=${usage.input_tokens} output=${usage.output_tokens}`
+        );
+      }
+      const toolCalls = turn.toolCalls.map((c) => ({ id: c.id, name: c.name, input: c.input }));
+      const endedAt = Date.now();
+      emitLlmTraceEvent({
+        id: traceId,
+        at: startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt,
+        provider: "claude-code-login",
+        model: resolvedModel,
+        kind: "callTools",
+        systemPrompt,
+        userPrompt: sentUserPrompt,
+        tools: summarizeTools(tools),
+        result: {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          cacheCreated,
+          cacheRead,
+          toolCalls: toolCalls.map((c) => ({ name: c.name, input: c.input }))
+        }
+      });
+      return {
+        toolCalls,
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cacheReadTokens: cacheRead,
+        cacheCreationTokens: cacheCreated,
+        appliedToolChoice: "auto"
+      };
+    } catch (e) {
+      emitLlmTraceEvent({
+        tools: summarizeTools(tools),
+        error: { message: e instanceof Error ? e.message : String(e) }
+      });
+      throw e;
+    }
+  }
+  async callWithTools() {
+    throw new Error(
+      "claude-code-login: callWithTools (an in-client agentic loop) is not part of the login client \u2014 ggui's harness runs the loop through callTools"
+    );
+  }
+};
 var OpenAIAgent = class extends LLMAgent {
   provider = "openai";
   resolveModel(model) {
@@ -4335,10 +1535,15 @@ var OpenAIAgent = class extends LLMAgent {
         }
       }
     }
+    const textUsage = splitOpenAiUsage(
+      response.usage?.input_tokens ?? 0,
+      response.usage?.output_tokens ?? 0,
+      response.usage?.input_tokens_details?.cached_tokens ?? 0
+    );
     return {
       text,
-      inputTokens: response.usage?.input_tokens ?? 0,
-      outputTokens: response.usage?.output_tokens ?? 0,
+      inputTokens: textUsage.tokens.input,
+      outputTokens: textUsage.tokens.output,
       sampling: { temperature: temperature ?? "provider-default" }
     };
   }
@@ -4377,14 +1582,20 @@ var OpenAIAgent = class extends LLMAgent {
     const functionCalls = response.output.filter(
       (o) => o.type === "function_call"
     );
+    const toolsUsage = splitOpenAiUsage(
+      response.usage?.input_tokens ?? 0,
+      response.usage?.output_tokens ?? 0,
+      response.usage?.input_tokens_details?.cached_tokens ?? 0
+    );
     return {
       toolCalls: functionCalls.map((fc) => ({
         id: fc.call_id,
         name: fc.name,
         input: JSON.parse(fc.arguments ?? "{}")
       })),
-      inputTokens: response.usage?.input_tokens ?? 0,
-      outputTokens: response.usage?.output_tokens ?? 0
+      inputTokens: toolsUsage.tokens.input,
+      outputTokens: toolsUsage.tokens.output,
+      cacheReadTokens: toolsUsage.cacheReadTokens
     };
   }
   // Pending tool results — stored by sendToolResult, consumed by next callTools
@@ -4411,6 +1622,7 @@ var OpenAIAgent = class extends LLMAgent {
     ];
     let totalIn = 0;
     let totalOut = 0;
+    let totalCacheRead = 0;
     let allText = "";
     for (let turn = 0; turn < maxTurns; turn++) {
       const response = await this.apiCall(
@@ -4421,8 +1633,14 @@ var OpenAIAgent = class extends LLMAgent {
           tools: openaiTools
         })
       );
-      totalIn += response.usage?.input_tokens ?? 0;
-      totalOut += response.usage?.output_tokens ?? 0;
+      const turnUsage = splitOpenAiUsage(
+        response.usage?.input_tokens ?? 0,
+        response.usage?.output_tokens ?? 0,
+        response.usage?.input_tokens_details?.cached_tokens ?? 0
+      );
+      totalIn += turnUsage.tokens.input;
+      totalOut += turnUsage.tokens.output;
+      totalCacheRead += turnUsage.cacheReadTokens;
       const functionCalls = response.output.filter(
         (o) => o.type === "function_call"
       );
@@ -4453,6 +1671,7 @@ var OpenAIAgent = class extends LLMAgent {
       text: allText,
       inputTokens: totalIn,
       outputTokens: totalOut,
+      cacheReadTokens: totalCacheRead,
       turnsUsed: input.length
     };
   }
@@ -4478,6 +1697,10 @@ function functionCallSteps(interaction) {
 function toUserInputStep(text) {
   return { type: "user_input", content: [{ type: "text", text }] };
 }
+function googleInteractionUsage(usage) {
+  const split = splitCacheInclusiveUsage(usage?.total_input_tokens ?? 0, usage?.total_output_tokens ?? 0, usage?.total_cached_tokens ?? 0);
+  return { inputTokens: split.tokens.input, outputTokens: split.tokens.output, cacheReadTokens: split.cacheReadTokens };
+}
 var GoogleAgent = class extends LLMAgent {
   provider = "google";
   resolveModel(model) {
@@ -4507,8 +1730,9 @@ var GoogleAgent = class extends LLMAgent {
     );
     return {
       text: interactionText(interaction),
-      inputTokens: interaction.usage?.total_input_tokens ?? 0,
-      outputTokens: interaction.usage?.total_output_tokens ?? 0,
+      // ggui#1186 (third site): `total_input_tokens` INCLUDES the cached part of the prompt — report the non-cached input.
+      inputTokens: googleInteractionUsage(interaction.usage).inputTokens,
+      outputTokens: googleInteractionUsage(interaction.usage).outputTokens,
       sampling: { temperature: temperature ?? "provider-default" }
     };
   }
@@ -4540,7 +1764,8 @@ var GoogleAgent = class extends LLMAgent {
       const usage = response.usageMetadata;
       const result = {
         text,
-        inputTokens: usage?.promptTokenCount ?? 0,
+        // ggui#1186 (third site): `promptTokenCount` includes `cachedContentTokenCount` — report the non-cached input.
+        inputTokens: splitCacheInclusiveUsage(usage?.promptTokenCount ?? 0, usage?.candidatesTokenCount ?? 0, usage?.cachedContentTokenCount ?? 0).tokens.input,
         outputTokens: usage?.candidatesTokenCount ?? 0
       };
       const endedAt = Date.now();
@@ -4674,8 +1899,8 @@ var GoogleAgent = class extends LLMAgent {
     }));
     return {
       toolCalls,
-      inputTokens: interaction.usage?.total_input_tokens ?? 0,
-      outputTokens: interaction.usage?.total_output_tokens ?? 0
+      // ggui#1186 (third site): the coding loop reads this per-turn usage — the non-cached prompt as input, the cached subset reported.
+      ...googleInteractionUsage(interaction.usage)
     };
   }
   // Pending tool results — stored by sendToolResult, consumed by next callTools
@@ -4699,6 +1924,7 @@ var GoogleAgent = class extends LLMAgent {
     }));
     let totalIn = 0;
     let totalOut = 0;
+    let totalCacheRead = 0;
     let allText = "";
     let turnsUsed = 0;
     let interaction = await this.apiCall(
@@ -4712,8 +1938,10 @@ var GoogleAgent = class extends LLMAgent {
     for (let turn = 0; turn < maxTurns; turn++) {
       turnsUsed = turn + 1;
       if (interaction.usage) {
-        totalIn += interaction.usage.total_input_tokens ?? 0;
-        totalOut += interaction.usage.total_output_tokens ?? 0;
+        const turnUsage = googleInteractionUsage(interaction.usage);
+        totalIn += turnUsage.inputTokens;
+        totalOut += turnUsage.outputTokens;
+        totalCacheRead += turnUsage.cacheReadTokens;
       }
       allText += interactionText(interaction);
       const fnCalls = functionCallSteps(interaction);
@@ -4751,6 +1979,7 @@ var GoogleAgent = class extends LLMAgent {
       text: allText,
       inputTokens: totalIn,
       outputTokens: totalOut,
+      cacheReadTokens: totalCacheRead,
       turnsUsed
     };
   }
@@ -4806,12 +2035,19 @@ var OpenRouterAgent = class extends LLMAgent {
       this.sessionMessages.push({ role: "system", content: systemPrompt });
     }
     this.sessionMessages.push({ role: "user", content: userPrompt });
+    const requested = toolChoice ?? "auto";
+    const appliedToolChoice = requested === "required" && anthropicRejectsForcedToolChoice(resolved) ? "auto" : requested;
+    if (appliedToolChoice !== requested) {
+      console.warn(
+        `[openrouter] callTools: ${resolved} rejects forced tool_choice (HTTP 400); caller's 'required' downgraded to 'auto'`
+      );
+    }
     const response = await this.apiCall(
       () => client.chatCompletion({
         model: resolved,
         messages: this.sessionMessages,
         tools: orTools,
-        tool_choice: toolChoice ?? "auto"
+        tool_choice: appliedToolChoice
       })
     );
     const choice = response.choices[0];
@@ -4830,7 +2066,8 @@ var OpenRouterAgent = class extends LLMAgent {
     return {
       toolCalls,
       inputTokens: response.usage.prompt_tokens,
-      outputTokens: response.usage.completion_tokens
+      outputTokens: response.usage.completion_tokens,
+      appliedToolChoice
     };
   }
   async sendToolResult(results) {
@@ -4901,6 +2138,14 @@ function createAgent(providerOrConfig) {
   const provider = typeof providerOrConfig === "string" ? providerOrConfig : providerOrConfig.provider;
   const routeOverride = typeof providerOrConfig === "string" ? void 0 : providerOrConfig.routeOverride;
   const onRetry = typeof providerOrConfig === "string" ? void 0 : providerOrConfig.onRetry;
+  if (routeOverride?.claudeCodeLogin === true) {
+    if (provider !== "anthropic") {
+      throw new Error(
+        `${provider}: the claude-code-login credential authenticates the Claude Code binary only \u2014 pick an anthropic route or supply a ${provider} API key`
+      );
+    }
+    return new ClaudeCodeLoginAgent(routeOverride, onRetry);
+  }
   switch (provider) {
     case "anthropic":
       return new AnthropicAgent(routeOverride, onRetry);
@@ -4913,11 +2158,23 @@ function createAgent(providerOrConfig) {
   }
 }
 function createVisionAgent(config) {
+  if (config.routeOverride?.claudeCodeLogin === true) {
+    if (config.provider !== "anthropic") {
+      throw new Error(
+        `${config.provider}: the claude-code-login credential authenticates the Claude Code binary only \u2014 pick an anthropic route or supply a ${config.provider} API key`
+      );
+    }
+    return new ClaudeCodeLoginAgent(config.routeOverride, config.onRetry);
+  }
   switch (config.provider) {
     case "anthropic":
       return new AnthropicAgent(config.routeOverride, config.onRetry);
     case "google":
       return new GoogleAgent(config.routeOverride, config.onRetry);
+    default: {
+      const unreachable = config.provider;
+      throw new Error(`createVisionAgent: provider '${String(unreachable)}' has no vision path (anthropic, google)`);
+    }
   }
 }
 
@@ -7235,18 +4492,19 @@ function isDesignRenderingInput(relativePath) {
   return true;
 }
 function designTreeSha256(root) {
+  const base = resolve(root);
   const files = [];
   const walk = (dir) => {
     for (const name of readdirSync(dir).sort()) {
       const full = resolve(dir, name);
       if (statSync(full).isDirectory()) walk(full);
-      else if (isDesignRenderingInput(full.slice(root.length + 1))) files.push(full);
+      else if (isDesignRenderingInput(relative(base, full))) files.push(full);
     }
   };
-  walk(root);
+  walk(base);
   const h = createHash("sha256");
   for (const f of files) {
-    h.update(f.slice(root.length + 1) + "\n");
+    h.update(relative(base, f) + "\n");
     h.update(readFileSync(f));
     h.update("\n");
   }
@@ -7285,12 +4543,21 @@ var JUDGE_SCOPE_CLASS = "ggui-judge-scope";
 function canvasFit(canvas) {
   return displayModeForCanvas(canvas) === "fullscreen" ? "fill" : void 0;
 }
+function integerBox(viewport) {
+  return { width: Math.round(viewport.width), height: Math.round(viewport.height) };
+}
+function isDeclaredViewport(canvas, viewport) {
+  const classBox = CANVAS_VIEWPORTS[canvas];
+  return viewport.width !== classBox.width || viewport.height !== classBox.height;
+}
 function canvasOverflowIssue(canvas, viewport, contentHeight, verdict) {
   const hidden = contentHeight - viewport.height;
+  const classBox = CANVAS_VIEWPORTS[canvas];
+  const box = isDeclaredViewport(canvas, viewport) ? `declared ${viewport.width}\xD7${viewport.height}; class box ${classBox.width}\xD7${classBox.height}` : `${viewport.width}\xD7${viewport.height}`;
   return {
     dimension: "canvas-overflow",
     severity: verdict === "fail" ? "critical" : "major",
-    description: `Rendered content is ${contentHeight}px tall on the ${canvas} canvas (${viewport.width}\xD7${viewport.height}) \u2014 ${hidden}px ${verdict === "fail" ? "is cut off: the inline card does not scroll" : "sits below the first screen"}.`,
+    description: `Rendered content is ${contentHeight}px tall on the ${canvas} canvas (${box}) \u2014 ${hidden}px ${verdict === "fail" ? "is cut off: the inline card does not scroll" : "sits below the first screen"}.`,
     fix: "Fit the composition to the canvas: fewer and shorter sections, one compact row of chips, no hero taller than a third of the box, no fixed min-heights or tall paddings \u2014 measure against the canvas, not the page."
   };
 }
@@ -7331,8 +4598,7 @@ function resolveDesignPackageDir() {
   }
 }
 async function bundleForRendering(compiledCode, sampleProps, designSrc = resolve(resolveDesignPackageDir(), "src")) {
-  const tmpDir = resolve(tmpdir(), "ggui-visual-eval-" + Date.now());
-  mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = mkdtempSync(resolve(tmpdir(), "ggui-visual-eval-"));
   const componentFile = resolve(tmpDir, "component.tsx");
   const entryFile = resolve(tmpDir, "entry.tsx");
   const designPkgDir = resolve(designSrc, "..");
@@ -7407,14 +4673,7 @@ try {
     });
     return result.outputFiles[0]?.text ?? "";
   } finally {
-    try {
-      unlinkSync(entryFile);
-    } catch {
-    }
-    try {
-      unlinkSync(componentFile);
-    } catch {
-    }
+    rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 function buildRenderHTML(bundledCode, cssTokens, fit) {
@@ -7429,7 +4688,10 @@ function buildRenderHTML(bundledCode, cssTokens, fit) {
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
     body {
       font-family: var(--ggui-font-family-sans, system-ui, -apple-system, sans-serif);
-      background: var(--ggui-color-neutral-50, #ffffff);
+      /* ggui#1083 \u2014 the host stand-in (neutral-50) under the theme's scrim (its tint at
+         its opacity): the ground a frosted host puts under the card, so the judge scores
+         the card where the visitor sees it. */
+      background: color-mix(in oklch, var(--ggui-scrim-tint, var(--ggui-color-ground, #ffffff)) calc(var(--ggui-scrim-opacity, 0.45) * 100%), var(--ggui-color-neutral-50, #ffffff));
       color: var(--ggui-color-neutral-900, #111827);
     }
     .error { color: #dc2626; padding: 16px; font-family: monospace; white-space: pre-wrap; }
@@ -7457,24 +4719,25 @@ ${bundledCode}
 var EXECUTABLE_PATH_LAUNCH_ARGS = ["--no-sandbox", "--disable-dev-shm-usage"];
 var DEFAULT_SCREENSHOT_VIEWPORT = { width: 1280, height: 800 };
 async function loadSparticuzChromium() {
-  const chromium = await Promise.resolve().then(() => (init_build(), build_exports));
+  const chromium = await import('@sparticuz/chromium');
   return chromium.default;
 }
 async function resolveLaunchOptions(viewport, deps = {}) {
   const env = deps.env ?? process.env;
   const override = env.PUPPETEER_EXECUTABLE_PATH?.trim();
+  const defaultViewport = integerBox(viewport);
   if (override) {
     return {
       executablePath: override,
       args: [...EXECUTABLE_PATH_LAUNCH_ARGS],
-      defaultViewport: viewport,
+      defaultViewport,
       headless: true
     };
   }
   const chromium = await (deps.loadChromium ?? loadSparticuzChromium)();
   return {
     args: chromium.args,
-    defaultViewport: viewport,
+    defaultViewport,
     executablePath: await chromium.executablePath(),
     headless: true
   };
@@ -7583,6 +4846,20 @@ ${originalPrompt}
     VISUAL_JUDGE_MAX_OUTPUT_TOKENS
   );
 }
+async function frameCanvas(bundledCode, context, html, canvas, canvasViewports, deps) {
+  const declaredBox = canvasViewports?.[canvas];
+  const viewport = declaredBox !== void 0 ? integerBox(declaredBox) : CANVAS_VIEWPORTS[canvas];
+  const policy = canvasFitPolicy(canvas);
+  const fit = canvasFit(canvas);
+  const canvasHtml = fit !== void 0 ? buildRenderHTML(bundledCode, context.cssTokens, fit) : html;
+  const attempt = await captureScreenshotDetailed(canvasHtml, viewport, deps, policy.capture);
+  return { viewport, policy, fit, declared: declaredBox !== void 0, attempt };
+}
+function fitVerdict(canvas, frame) {
+  const contentHeight = frame.attempt.contentHeight;
+  if (contentHeight === null || contentHeight <= frame.viewport.height || frame.policy.overflow === "none") return null;
+  return canvasOverflowIssue(canvas, frame.viewport, contentHeight, frame.policy.overflow);
+}
 function judgeCountFor(config, canvas) {
   const k = Math.max(1, Math.floor(config.judgeK ?? 1));
   if (k === 1) return 1;
@@ -7650,11 +4927,8 @@ async function runVisualEvaluationDetailed(context, config, deps = {}) {
     const perCanvas = [];
     const perCanvasResults = [];
     for (const canvas of config.canvases) {
-      const viewport = CANVAS_VIEWPORTS[canvas];
-      const policy = canvasFitPolicy(canvas);
-      const fit = canvasFit(canvas);
-      const canvasHtml = fit !== void 0 ? buildRenderHTML(bundledCode, context.cssTokens, fit) : html;
-      const attempt2 = await captureScreenshotDetailed(canvasHtml, viewport, deps, policy.capture);
+      const frame = await frameCanvas(bundledCode, context, html, canvas, config.canvasViewports, deps);
+      const { viewport, policy, fit, attempt: attempt2 } = frame;
       const screenshot2 = attempt2.png;
       if (!screenshot2) {
         const unavailableReason = attempt2.reason ?? "no browser available";
@@ -7689,8 +4963,9 @@ async function runVisualEvaluationDetailed(context, config, deps = {}) {
       };
       const contentHeight = attempt2.contentHeight;
       const overflow = contentHeight !== null && contentHeight > viewport.height;
-      if (contentHeight !== null && contentHeight > viewport.height && policy.overflow !== "none") {
-        result2.issues.push(canvasOverflowIssue(canvas, viewport, contentHeight, policy.overflow));
+      const fitIssue = fitVerdict(canvas, frame);
+      if (fitIssue !== null) {
+        result2.issues.push(fitIssue);
         if (policy.overflow === "fail") result2.passed = false;
       }
       perCanvasResults.push(result2);
@@ -7703,7 +4978,8 @@ async function runVisualEvaluationDetailed(context, config, deps = {}) {
         contentHeight,
         overflow,
         judge: judgeRecord,
-        ...fit !== void 0 ? { fit } : {}
+        ...fit !== void 0 ? { fit } : {},
+        ...frame.declared ? { declared: true } : {}
       });
       console.log(
         `[visual-eval] canvas=${canvas} ${viewport.width}\xD7${viewport.height} score=${result2.finalScore}${k > 1 ? ` (median of ${judgeRecord.samples.length}/${k}: ${judgeRecord.samples.join(",")} \u03C3=${judgeRecord.sigma})` : ""} ${result2.passed ? "pass" : "FAIL"} | content=${contentHeight ?? "?"}px${overflow ? ` OVERFLOW (${policy.overflow})` : ""} | in=${response2.inputTokens} out=${response2.outputTokens}`
@@ -7743,6 +5019,9 @@ async function runVisualEvaluationDetailed(context, config, deps = {}) {
   console.log(`[visual-eval] score=${result.finalScore} (${elapsed}ms) | in=${response.inputTokens} out=${response.outputTokens}`);
   return { result: stamp(result) };
 }
+function canvasScopedIssue(canvas, issue) {
+  return { ...issue, description: `[${canvas}] ${issue.description}` };
+}
 function aggregateCanvasResults(perCanvas, results) {
   const n = results.length;
   const mean = (pick) => Math.round(results.reduce((sum, r) => sum + pick(r), 0) / n);
@@ -7759,7 +5038,7 @@ function aggregateCanvasResults(perCanvas, results) {
   let outputTokens = 0;
   results.forEach((r, i) => {
     const canvas = perCanvas[i].canvas;
-    for (const issue of r.issues) issues.push({ ...issue, description: `[${canvas}] ${issue.description}` });
+    for (const issue of r.issues) issues.push(canvasScopedIssue(canvas, issue));
     if (r.critique) critiques.push(`${canvas}: ${r.critique}`);
     inputTokens += r.inputTokens ?? 0;
     outputTokens += r.outputTokens ?? 0;
@@ -7787,10 +5066,19 @@ function summarizeVisualResult(result) {
     judge: c.judge,
     ...c.fit !== void 0 ? { fit: c.fit } : {}
   }));
+  const fitCanvas = result.canvases.find((c) => canvasFitPolicy(c.canvas).overflow === "fail" && c.contentHeight !== null);
+  const fit = fitCanvas !== void 0 && fitCanvas.contentHeight !== null ? {
+    canvas: fitCanvas.canvas,
+    ceiling: { width: fitCanvas.viewport.width, height: fitCanvas.viewport.height },
+    // Declared = the order carried a box, even one equal to the class box (the review's point).
+    declared: fitCanvas.declared === true,
+    overflowPx: Math.max(0, fitCanvas.contentHeight - fitCanvas.viewport.height)
+  } : void 0;
   return {
     score: result.finalScore,
     passed: result.passed,
     canvases,
+    ...fit !== void 0 ? { fit } : {},
     ...result.design !== void 0 ? { design: result.design } : {},
     ...result.themeMode !== void 0 ? { themeMode: result.themeMode } : {}
   };
@@ -7878,10 +5166,20 @@ function getDefaultVisualModel(provider) {
       return "gemini-3-flash-preview";
   }
 }
-async function runVisualEval(context, config) {
-  const result = await runVisualEvaluation(context, config);
-  if (!result) return { issues: [] };
-  const issues = (result.issues || []).map((issue) => ({
+async function runVisualEval(context, config, deps = {}) {
+  const detailed = await runVisualEvaluationDetailed(context, config, deps);
+  const result = detailed.result;
+  if (!result) {
+    const reason = detailed.unavailableReason ?? "no browser available";
+    return { issues: [], coverage: { status: "skipped", reason } };
+  }
+  const issues = (result.issues || []).map(toEvalIssue);
+  const summary = summarizeVisualResult(result);
+  const coverage = { status: "ran" };
+  return summary === void 0 ? { issues, coverage } : { issues, summary, coverage };
+}
+function toEvalIssue(issue) {
+  return {
     tier: 2,
     result: issue.severity === "critical" ? "fail" : "warn",
     category: "visual",
@@ -7889,9 +5187,7 @@ async function runVisualEval(context, config) {
     severity: issue.severity === "critical" ? "critical" : "major",
     description: issue.description,
     fix: issue.fix || ""
-  }));
-  const summary = summarizeVisualResult(result);
-  return summary === void 0 ? { issues } : { issues, summary };
+  };
 }
 function cssTokensForAppTheme(theme, mode = "light") {
   if (theme === void 0) return getCssTokens(mode);