@ggui-ai/ui-gen 0.15.0 → 0.16.0

package/dist/evaluation/index.js

@@ -1,19 +1,56 @@
+import { 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 Anthropic from '@anthropic-ai/sdk';
 import { z } from 'zod';
 import { listContractGadgets, HOOK_NAME_RE, STDLIB_GADGETS_PACKAGE } from '@ggui-ai/protocol';
-import 'esbuild';
-import '@ggui-ai/design/rendering';
+import { build } from 'esbuild';
+import { getCssTokens } from '@ggui-ai/design/rendering';
 
+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;
@@ -27,103 +64,3352 @@ var init_types = __esm({
         this.headers = headers;
         this.name = "OpenRouterError";
       }
-      status;
-      code;
-      headers;
-      get isTransient() {
-        return this.status === 408 || this.status === 429 || this.status === 502 || this.status === 503;
+      status;
+      code;
+      headers;
+      get isTransient() {
+        return this.status === 408 || this.status === 429 || this.status === 502 || this.status === 503;
+      }
+    };
+  }
+});
+
+// src/adapters/openrouter/client.ts
+var client_exports = {};
+__export(client_exports, {
+  OpenRouterClient: () => OpenRouterClient
+});
+var DEFAULT_BASE_URL, OpenRouterClient;
+var init_client = __esm({
+  "src/adapters/openrouter/client.ts"() {
+    init_types();
+    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+    OpenRouterClient = class {
+      constructor(config) {
+        this.config = config;
+        this.baseUrl = config.baseUrl ?? process.env.OPENROUTER_BASE_URL ?? DEFAULT_BASE_URL;
+        this.headers = {
+          "Authorization": `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json",
+          "HTTP-Referer": config.siteUrl ?? process.env.OPENROUTER_SITE_URL ?? "https://ggui.ai",
+          "X-Title": config.siteName ?? process.env.OPENROUTER_SITE_NAME ?? "ggui"
+        };
+      }
+      config;
+      baseUrl;
+      headers;
+      /**
+       * Non-streaming chat completion.
+       */
+      async chatCompletion(params) {
+        const body = { ...params, stream: false };
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body)
+        });
+        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);
+        }
+        return response.json();
+      }
+      /**
+       * Streaming chat completion via SSE.
+       * Yields delta chunks, accumulates the final usage from the last chunk.
+       */
+      async *chatCompletionStream(params) {
+        const body = { ...params, stream: true };
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body)
+        });
+        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(resolve2, reject) {
+              promiseResolve = resolve2;
+              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((resolve2, reject) => {
+            if (stream._duplexState & DESTROYED) return resolve2({ value: void 0, done: true });
+            stream.once("close", function() {
+              if (err) reject(err);
+              else resolve2({ 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((resolve2) => {
+          state.drains.push({ writes, resolve: resolve2 });
+        });
+      }
+      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((resolve2, reject) => {
+        return pipeline2(...streams, (err) => {
+          if (err) return reject(err);
+          resolve2();
+        });
+      });
+    }
+    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(resolve2, reject) {
+          if (error) {
+            return reject(error);
+          }
+          if (entryStream) {
+            resolve2({ value: entryStream, done: false });
+            entryStream = null;
+            return;
+          }
+          promiseResolve = resolve2;
+          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((resolve2, reject) => {
+            if (extract3.destroyed) return resolve2({ value: void 0, done: true });
+            extract3.once("close", function() {
+              if (err) reject(err);
+              else resolve2({ 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((resolve2) => {
+          rm(destDir, { force: true, recursive: true }, () => {
+            resolve2();
+          });
+        });
+        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((resolve2, reject) => {
+        if (filePath.includes("swiftshader")) {
+          if (existsSync(`${output}/libGLESv2.so`)) {
+            resolve2(output);
+            return;
+          }
+        } else if (existsSync(output)) {
+          resolve2(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", () => {
+            resolve2(output);
+          });
+        } else {
+          target = createWriteStream(output, { mode: 448 });
+          target.once("close", () => {
+            resolve2(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"() {
+  }
+});
 
-// src/adapters/openrouter/client.ts
-var client_exports = {};
-__export(client_exports, {
-  OpenRouterClient: () => OpenRouterClient
+// ../../node_modules/@sparticuz/chromium/build/index.js
+var build_exports = {};
+__export(build_exports, {
+  default: () => build_default,
+  inflate: () => inflate,
+  setupLambdaEnvironment: () => setupLambdaEnvironment
 });
-var DEFAULT_BASE_URL, OpenRouterClient;
-var init_client = __esm({
-  "src/adapters/openrouter/client.ts"() {
-    init_types();
-    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
-    OpenRouterClient = class {
-      constructor(config) {
-        this.config = config;
-        this.baseUrl = config.baseUrl ?? process.env.OPENROUTER_BASE_URL ?? DEFAULT_BASE_URL;
-        this.headers = {
-          "Authorization": `Bearer ${config.apiKey}`,
-          "Content-Type": "application/json",
-          "HTTP-Referer": config.siteUrl ?? process.env.OPENROUTER_SITE_URL ?? "https://ggui.ai",
-          "X-Title": config.siteName ?? process.env.OPENROUTER_SITE_NAME ?? "ggui"
-        };
+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
+        ];
       }
-      config;
-      baseUrl;
-      headers;
       /**
-       * Non-streaming chat completion.
+       * Returns whether the graphics stack is enabled or disabled
+       * @returns boolean
        */
-      async chatCompletion(params) {
-        const body = { ...params, stream: false };
-        const response = await fetch(`${this.baseUrl}/chat/completions`, {
-          method: "POST",
-          headers: this.headers,
-          body: JSON.stringify(body)
-        });
-        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);
+      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)}'`);
         }
-        return response.json();
+        this.graphicsMode = value;
       }
       /**
-       * Streaming chat completion via SSE.
-       * Yields delta chunks, accumulates the final usage from the last chunk.
+       * 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)
        */
-      async *chatCompletionStream(params) {
-        const body = { ...params, stream: true };
-        const response = await fetch(`${this.baseUrl}/chat/completions`, {
-          method: "POST",
-          headers: this.headers,
-          body: JSON.stringify(body)
-        });
-        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);
+      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 (!response.body) {
-          throw new OpenRouterError("No response body for streaming request", 500);
+        if (input && isValidUrl(input)) {
+          return this.executablePath(await downloadAndExtract(input));
         }
-        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();
+        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`);
         }
+        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 result = await Promise.all(promises);
+        return result.shift();
       }
     };
+    build_default = Chromium;
   }
 });
 
@@ -354,20 +3640,51 @@ Intentional custom colors (status indicators) are acceptable when no semantic to
 Only list ACTUAL violations. Use 'fail' only for pervasive violations.`
   }
 ];
-function getCriteriaByPriority(priority) {
-  return CRITERIA.filter((c) => c.priority === priority);
+var FREE_DESIGN_CRITERIA_OVERRIDES = [
+  {
+    id: "tokens",
+    name: "Color tokens",
+    priority: "P1",
+    tier: 0,
+    failOutcome: "warn",
+    codingGuidance: "Every color is a bare var(--ggui-color-*) from the token manifest \u2014 no hex, rgb()/hsl(), CSS named colors or literal fallbacks, in style props and <style> blocks alike. Spacing, typography, radius and shadow geometry may be literals.",
+    evalInstruction: "Flag hardcoded hex colors, rgba/hsl functions, CSS named colors, and literal fallbacks inside var(--ggui-*) references. Do NOT flag literal spacing, font sizes, radii or pixel values \u2014 they are allowed in this mode."
+  },
+  {
+    id: "visual",
+    name: "Visual composition",
+    priority: "P2",
+    tier: 2,
+    failOutcome: "warn",
+    codingGuidance: "Compose deliberately: one clear focal point, consistent spacing rhythm, a coherent theme-token palette, a fit to the rendering canvas.",
+    evalInstruction: `Evaluate VISUAL COMPOSITION: Is the component composed deliberately for its canvas?
+
+Judge: visual hierarchy (one clear focal point, headings distinct from body text), consistent spacing rhythm and alignment, a coherent palette drawn from the theme tokens, fit to the canvas (fluid width, no fixed widths, nothing cramped or stretched).
+Do NOT reward or penalise the use of design-system primitives \u2014 raw HTML with inline CSS is a first-class choice here. Literal spacing / typography / radius values are fine.
+
+Only list ACTUAL composition problems. Use 'fail' only for a fundamentally incoherent composition.`
+  }
+];
+function criteriaFor(designMode = "constrained") {
+  if (designMode === "constrained") return CRITERIA;
+  return CRITERIA.map(
+    (c) => FREE_DESIGN_CRITERIA_OVERRIDES.find((o) => o.id === c.id) ?? c
+  );
+}
+function getCriteriaByPriority(priority, designMode = "constrained") {
+  return criteriaFor(designMode).filter((c) => c.priority === priority);
 }
-function getCriterionById(id) {
-  return CRITERIA.find((c) => c.id === id);
+function getCriterionById(id, designMode = "constrained") {
+  return criteriaFor(designMode).find((c) => c.id === id);
 }
-function getLLMCriteria() {
-  return CRITERIA.filter((c) => c.tier > 0);
+function getLLMCriteria(designMode = "constrained") {
+  return criteriaFor(designMode).filter((c) => c.tier > 0);
 }
-function buildCodingCriteriaSummary() {
+function buildCodingCriteriaSummary(designMode = "constrained") {
   const lines = ["## Priority (P0 first, then P1, then P2)", ""];
   for (const priority of ["P0", "P1", "P2"]) {
     const label = priority === "P0" ? "Must (compile + complete)" : priority === "P1" ? "Should (safety)" : "Nice (quality)";
-    const criteria = getCriteriaByPriority(priority);
+    const criteria = getCriteriaByPriority(priority, designMode);
     lines.push(`**${priority} \u2014 ${label}:**`);
     for (const c of criteria) {
       lines.push(`- ${c.codingGuidance}`);
@@ -501,7 +3818,7 @@ function extractRetryAfterSec(e) {
   return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : void 0;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var MAX_RETRY_ATTEMPTS = 2;
 var RETRY_AFTER_CAP_SEC = 15;
@@ -3233,6 +6550,7 @@ var stepperAdopted = {
   values: ["multi-step"],
   run(input) {
     if (input.compiledCode === null) return [];
+    if (input.designMode === "free") return [];
     if (/<Stepper[\s/>]/.test(input.sourceCode)) return [];
     return [
       mkIssue2(
@@ -3293,7 +6611,8 @@ function runAxisChecks(classification, input) {
     compiledCode: input.compiledCode,
     ...input.contract !== void 0 ? { contract: input.contract } : {},
     originalPrompt: input.originalPrompt,
-    classification
+    classification,
+    ...input.designMode !== void 0 ? { designMode: input.designMode } : {}
   };
   const issues = [];
   const firedIds = /* @__PURE__ */ new Set();
@@ -3305,6 +6624,296 @@ function runAxisChecks(classification, input) {
   }
   return issues;
 }
+
+// src/design-mode.ts
+var CANVAS_CLASSES = [
+  "xs-chat-card",
+  "mobile-fullscreen-small",
+  "md",
+  "lg",
+  "xl"
+];
+var CANVAS_VIEWPORTS = {
+  "xs-chat-card": { width: 400, height: 640 },
+  "mobile-fullscreen-small": { width: 390, height: 844 },
+  md: { width: 768, height: 1024 },
+  lg: { width: 1024, height: 768 },
+  xl: { width: 1440, height: 900 }
+};
+function canvasDisplayModeForShell(shell) {
+  return shell === "chat" || shell === "inline" ? "inline" : "fullscreen";
+}
+var CANVAS_BREAKPOINTS = { md: 600, lg: 1024, xl: 1440 };
+function canvasForViewportWidth(mode, width) {
+  if (mode === "inline") return "xs-chat-card";
+  if (width < CANVAS_BREAKPOINTS.md) return "mobile-fullscreen-small";
+  if (width < CANVAS_BREAKPOINTS.lg) return "md";
+  if (width < CANVAS_BREAKPOINTS.xl) return "lg";
+  return "xl";
+}
+function canvasForRendering(shellType, screen) {
+  const shell = shellType ?? "fullscreen";
+  if (canvasDisplayModeForShell(shell) === "inline") return "xs-chat-card";
+  if (shell === "spatial") return "md";
+  switch (screen ?? "universal") {
+    case "mobile":
+      return "mobile-fullscreen-small";
+    case "tablet":
+      return "md";
+    default:
+      return "lg";
+  }
+}
+var CANVAS_DESCRIPTORS = {
+  "xs-chat-card": {
+    label: "extra-small chat card",
+    minWidthPx: 320,
+    maxWidthPx: 480,
+    host: "an inline card inside a chat message bubble \u2014 the host draws the card border, shadow and rounded corners; the component fills the bubble width and takes its natural height"
+  },
+  "mobile-fullscreen-small": {
+    label: "small mobile fullscreen",
+    minWidthPx: 320,
+    maxWidthPx: 599,
+    host: "a phone-sized viewport the component owns edge to edge \u2014 single column, touch targets at least 44px, the component manages its own scroll"
+  },
+  md: {
+    label: "medium panel",
+    minWidthPx: 600,
+    maxWidthPx: 1023,
+    host: "a tablet viewport or a floating panel (spatial / picture-in-picture) \u2014 one or two columns, medium density"
+  },
+  lg: {
+    label: "large fullscreen",
+    minWidthPx: 1024,
+    maxWidthPx: 1439,
+    host: "a desktop viewport the component owns edge to edge \u2014 multi-column layouts, hover states and pointer interactions are available"
+  },
+  xl: {
+    label: "extra-large fullscreen",
+    minWidthPx: 1440,
+    maxWidthPx: 1920,
+    host: "a wide desktop viewport the component owns edge to edge \u2014 cap content width or use the extra room deliberately; never stretch a single column across the whole width"
+  }
+};
+function describeCanvas(canvas) {
+  const d = CANVAS_DESCRIPTORS[canvas];
+  return `This component renders on the \`${canvas}\` canvas (${d.label}): ${d.minWidthPx}\u2013${d.maxWidthPx}px wide, ${d.host}. Design for the whole range \u2014 the host may size the iframe anywhere inside it.`;
+}
+
+// src/evaluation/visual-evaluator.ts
+function resolveUiGenPackageDir() {
+  const selfDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(selfDir, "..", "..");
+}
+function resolveDesignPackageDir() {
+  const selfDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(selfDir, "..", "..", "..", "design");
+}
+async function bundleForRendering(compiledCode, sampleProps) {
+  const tmpDir = resolve(tmpdir(), "ggui-visual-eval-" + Date.now());
+  mkdirSync(tmpDir, { recursive: true });
+  const componentFile = resolve(tmpDir, "component.tsx");
+  const entryFile = resolve(tmpDir, "entry.tsx");
+  const designPkgDir = resolveDesignPackageDir();
+  writeFileSync(componentFile, compiledCode);
+  const entryCode = `
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { GguiWireProvider } from '@ggui-ai/wire';
+import Component from './component.tsx';
+
+const props = ${JSON.stringify(sampleProps)};
+const wireConfig = {
+  app: { appId: 'visual-eval', appName: 'Visual evaluation' },
+  render: { sessionId: 'visual-eval', isConnected: true },
+  auth: { isAuthenticated: false },
+  dispatch: () => {},
+  subscribe: () => () => {},
+};
+class RenderErrorBoundary extends React.Component<{ children: React.ReactNode }, { message: string | null }> {
+  state = { message: null as string | null };
+  static getDerivedStateFromError(err: unknown) { return { message: err instanceof Error ? err.message : String(err) }; }
+  render() {
+    return this.state.message === null
+      ? this.props.children
+      : React.createElement('div', { className: 'error' }, 'Render error: ' + this.state.message);
+  }
+}
+const root = createRoot(document.getElementById('root')!);
+try {
+  root.render(
+    React.createElement(GguiWireProvider, { config: wireConfig },
+      React.createElement(RenderErrorBoundary, null, React.createElement(Component, props))),
+  );
+} catch (err) {
+  root.render(React.createElement('div', { className: 'error' }, 'Render error: ' + (err as Error).message));
+}
+`;
+  writeFileSync(entryFile, entryCode);
+  try {
+    const result = await build({
+      entryPoints: [entryFile],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "browser",
+      target: "es2020",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      external: ["react", "react-dom", "react-dom/client", "react/jsx-runtime"],
+      alias: {
+        // D1: generated code imports the single `@ggui-ai/design` barrel.
+        // The subpath aliases stay for any first-party / legacy code.
+        "@ggui-ai/design": resolve(designPkgDir, "src", "index.ts"),
+        "@ggui-ai/design/primitives": resolve(designPkgDir, "src", "primitives", "index.ts"),
+        "@ggui-ai/design/components": resolve(designPkgDir, "src", "components", "index.ts"),
+        "@ggui-ai/design/compositions": resolve(designPkgDir, "src", "compositions", "index.ts"),
+        "@ggui-ai/design/interact": resolve(designPkgDir, "src", "interact", "index.ts")
+      },
+      // Bare imports in the generated component resolve against ui-gen's
+      // own node_modules — the temp entry dir has none. Without this every
+      // wire-bearing component (`@ggui-ai/wire`) failed to bundle.
+      nodePaths: [resolve(resolveUiGenPackageDir(), "node_modules")],
+      logLevel: "silent"
+    });
+    return result.outputFiles[0]?.text ?? "";
+  } finally {
+    try {
+      unlinkSync(entryFile);
+    } catch {
+    }
+    try {
+      unlinkSync(componentFile);
+    } catch {
+    }
+  }
+}
+function buildRenderHTML(bundledCode, cssTokens) {
+  const tokens = cssTokens ?? getCssTokens();
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    ${tokens}
+    *, *::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);
+      color: var(--ggui-color-neutral-900, #111827);
+    }
+    .error { color: #dc2626; padding: 16px; font-family: monospace; white-space: pre-wrap; }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@18",
+      "react-dom": "https://esm.sh/react-dom@18",
+      "react-dom/client": "https://esm.sh/react-dom@18/client",
+      "react/jsx-runtime": "https://esm.sh/react@18/jsx-runtime"
+    }
+  }
+  </script>
+  <script type="module">
+${bundledCode}
+  </script>
+</body>
+</html>`;
+}
+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));
+  return chromium.default;
+}
+async function resolveLaunchOptions(viewport, deps = {}) {
+  const env = deps.env ?? process.env;
+  const override = env.PUPPETEER_EXECUTABLE_PATH?.trim();
+  if (override) {
+    return {
+      executablePath: override,
+      args: [...EXECUTABLE_PATH_LAUNCH_ARGS],
+      defaultViewport: viewport,
+      headless: true
+    };
+  }
+  const chromium = await (deps.loadChromium ?? loadSparticuzChromium)();
+  return {
+    args: chromium.args,
+    defaultViewport: viewport,
+    executablePath: await chromium.executablePath(),
+    headless: true
+  };
+}
+async function launchWithPuppeteer(options) {
+  const puppeteer = await import('puppeteer-core');
+  return puppeteer.default.launch(options);
+}
+async function captureScreenshot(html, viewport = DEFAULT_SCREENSHOT_VIEWPORT, deps = {}) {
+  try {
+    const launchOptions = await resolveLaunchOptions(viewport, deps);
+    const browser = await (deps.launch ?? launchWithPuppeteer)(launchOptions);
+    try {
+      const page = await browser.newPage();
+      await page.setContent(html, { waitUntil: "load", timeout: 15e3 });
+      await page.waitForNetworkIdle({ idleTime: 500, timeout: 15e3 }).catch(() => {
+      });
+      await page.waitForSelector("#root > *", { timeout: 1e4 }).catch(() => {
+      });
+      await new Promise((r) => setTimeout(r, deps.settleMs ?? 1e3));
+      const screenshot = await page.screenshot({ type: "png", fullPage: true });
+      return Buffer.from(screenshot);
+    } finally {
+      await browser.close();
+    }
+  } catch (e) {
+    console.warn(`[visual-eval] screenshot failed: ${e instanceof Error ? e.message : e}`);
+    return null;
+  }
+}
+var VISUAL_EVAL_PROMPT = `You are a visual quality evaluator for ggui \u2014 a platform where AI agents generate React UI components on demand.
+
+## Context
+The screenshot shows a generated React component built from a design system with CSS variable theming. The component was created by an LLM to fulfill a user's request. Your job is to evaluate whether the generated UI achieves the user's goal AND looks professionally designed.
+
+## Scoring Dimensions (0-100 each)
+
+1. **completeness** (25%): Does the screenshot show ALL features the user requested? Are all sections, controls, data fields, and interactive elements present? Missing features or sections = major deduction. Compare against the original request carefully.
+
+2. **layout** (25%): Is the layout well-composed? Clear sections and grouping? No overlapping elements? Proper spacing between elements? Responsive-looking? Does it look like a professional app UI, not a homework project?
+
+3. **hierarchy** (25%): Clear visual hierarchy? Headings are visually distinct from body text? Primary actions (buttons) are prominent? Information grouped logically with clear section breaks? Color and size used to guide the eye?
+
+4. **aesthetics** (25%): Professional, polished appearance? Consistent color palette? Good use of whitespace \u2014 not too sparse, not too cluttered? Cards, shadows, and borders used effectively? Does it look like something a designer would approve? Would you be comfortable showing this to a client?
+
+## Scoring Guide
+- 90-100: Production-ready. Would ship to real users. Polished layout, clear hierarchy, professional aesthetics.
+- 80-89: Good quality. Minor improvements needed (slightly tight spacing, one section could be better grouped).
+- 70-79: Acceptable but generic. Works correctly but lacks design polish or visual refinement.
+- 60-69: Below standard. Noticeable problems \u2014 cramped layout, poor hierarchy, or missing sections.
+- Below 60: Broken or fundamentally incomplete. Error messages visible, blank areas, or critical features missing.
+
+## Important
+- Check the screenshot against the "Original Request" \u2014 does it actually deliver what was asked for?
+- Error messages like "Render error" or blank white space = rendering score 0
+- A component that renders but is just a wall of text with no structure should score low on layout and hierarchy
+
+Respond with ONLY a JSON object (no markdown, no explanation):
+{
+  "completeness": <0-100>,
+  "layout": <0-100>,
+  "hierarchy": <0-100>,
+  "aesthetics": <0-100>,
+  "issues": [
+    { "dimension": "<dimension>", "severity": "<critical|major|minor>", "description": "<what's wrong>", "fix": "<specific fix>" }
+  ],
+  "critique": "<2-3 sentences: what's good, what needs improvement, does it achieve the user's goal?>"
+}`;
 async function callMultimodalLLM(config, model, prompt, screenshot, originalPrompt) {
   const userPrompt = `## Original Request
 ${originalPrompt}
@@ -3323,7 +6932,172 @@ Evaluate the screenshot of the generated component.`;
     1500
   );
 }
+async function runVisualEvaluation(context, config, deps = {}) {
+  const startTime = Date.now();
+  const judge = deps.judge ?? callMultimodalLLM;
+  const bundledCode = await bundleForRendering(
+    context.compiledCode,
+    config.sampleProps ?? {}
+  );
+  console.log(`[visual-eval] bundled: ${bundledCode.length}B (${Date.now() - startTime}ms)`);
+  const html = buildRenderHTML(bundledCode, context.cssTokens);
+  const model = config.model ?? getDefaultVisualModel(config.provider);
+  if (config.canvases !== void 0 && config.canvases.length > 0) {
+    const perCanvas = [];
+    const perCanvasResults = [];
+    for (const canvas of config.canvases) {
+      const viewport = CANVAS_VIEWPORTS[canvas];
+      const screenshot2 = await captureScreenshot(html, viewport, deps);
+      if (!screenshot2) {
+        console.warn(`[visual-eval] no browser available at canvas ${canvas} \u2014 skipping visual evaluation`);
+        return null;
+      }
+      const response2 = await judge(config, model, VISUAL_EVAL_PROMPT, screenshot2, context.originalPrompt);
+      const result2 = parseVisualResponse(response2.text, config.passThreshold);
+      result2.inputTokens = response2.inputTokens;
+      result2.outputTokens = response2.outputTokens;
+      perCanvasResults.push(result2);
+      perCanvas.push({
+        canvas,
+        viewport,
+        score: result2.finalScore,
+        passed: result2.passed,
+        screenshotPng: screenshot2
+      });
+      console.log(
+        `[visual-eval] canvas=${canvas} ${viewport.width}\xD7${viewport.height} score=${result2.finalScore} ${result2.passed ? "pass" : "FAIL"} | in=${response2.inputTokens} out=${response2.outputTokens}`
+      );
+    }
+    const aggregate = aggregateCanvasResults(perCanvas, perCanvasResults);
+    const elapsed2 = Date.now() - startTime;
+    console.log(
+      `[visual-eval] score=${aggregate.finalScore} (mean of ${perCanvas.length} canvases; ${aggregate.passed ? "every canvas passed" : `${perCanvas.filter((c) => !c.passed).length} failed`}) (${elapsed2}ms)`
+    );
+    return aggregate;
+  }
+  const screenshot = await captureScreenshot(html, config.viewport, deps);
+  if (!screenshot) {
+    console.warn("[visual-eval] no browser available \u2014 skipping visual evaluation");
+    return null;
+  }
+  console.log(`[visual-eval] screenshot: ${screenshot.length}B (${Date.now() - startTime}ms)`);
+  const response = await judge(
+    config,
+    model,
+    VISUAL_EVAL_PROMPT,
+    screenshot,
+    context.originalPrompt
+  );
+  const result = parseVisualResponse(response.text, config.passThreshold);
+  result.inputTokens = response.inputTokens;
+  result.outputTokens = response.outputTokens;
+  const elapsed = Date.now() - startTime;
+  console.log(`[visual-eval] score=${result.finalScore} (${elapsed}ms) | in=${response.inputTokens} out=${response.outputTokens}`);
+  return result;
+}
+function aggregateCanvasResults(perCanvas, results) {
+  const n = results.length;
+  const mean = (pick) => Math.round(results.reduce((sum, r) => sum + pick(r), 0) / n);
+  const dimensions = {
+    completeness: mean((r) => r.dimensions.completeness),
+    visualPolish: mean((r) => r.dimensions.visualPolish),
+    interactivity: mean((r) => r.dimensions.interactivity),
+    accessibility: mean((r) => r.dimensions.accessibility),
+    codeQuality: mean((r) => r.dimensions.codeQuality)
+  };
+  const issues = [];
+  const critiques = [];
+  let inputTokens = 0;
+  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}` });
+    if (r.critique) critiques.push(`${canvas}: ${r.critique}`);
+    inputTokens += r.inputTokens ?? 0;
+    outputTokens += r.outputTokens ?? 0;
+  });
+  return {
+    passed: perCanvas.every((c) => c.passed),
+    finalScore: mean((r) => r.finalScore),
+    dimensions,
+    issues,
+    ...critiques.length > 0 ? { critique: critiques.join("\n") } : {},
+    inputTokens,
+    outputTokens,
+    canvases: [...perCanvas]
+  };
+}
+function summarizeVisualResult(result) {
+  if (result.canvases === void 0) return void 0;
+  const canvases = result.canvases.map((c) => ({
+    canvas: c.canvas,
+    viewport: c.viewport,
+    score: c.score,
+    passed: c.passed
+  }));
+  return { score: result.finalScore, passed: result.passed, canvases };
+}
+function parseVisualResponse(text, passThreshold) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Visual evaluator did not return valid JSON: " + text.slice(0, 200));
+  }
+  const raw = JSON.parse(jsonMatch[0]);
+  const completeness = raw.completeness ?? 0;
+  const layout = raw.layout ?? 0;
+  const hierarchy = raw.hierarchy ?? 0;
+  const aesthetics = raw.aesthetics ?? 0;
+  const finalScore = Math.round(
+    completeness * 0.25 + layout * 0.25 + hierarchy * 0.25 + aesthetics * 0.25
+  );
+  const dimensions = {
+    completeness,
+    visualPolish: aesthetics,
+    interactivity: 0,
+    // can't assess interactivity from screenshot
+    accessibility: 0,
+    // can't assess a11y from screenshot
+    codeQuality: 0
+    // can't assess code from screenshot
+  };
+  const issues = (raw.issues || []).map((i) => ({
+    dimension: i.dimension || "visual",
+    severity: i.severity || "minor",
+    description: i.description || "",
+    fix: i.fix || ""
+  }));
+  return {
+    passed: finalScore >= passThreshold,
+    finalScore,
+    dimensions,
+    issues,
+    critique: raw.critique
+  };
+}
+function getDefaultVisualModel(provider) {
+  switch (provider) {
+    case "claude":
+      return "claude-haiku-4-5-20251001";
+    case "google":
+      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) => ({
+    tier: 2,
+    result: issue.severity === "critical" ? "fail" : "warn",
+    category: "visual",
+    subcategory: issue.dimension,
+    severity: issue.severity === "critical" ? "critical" : "major",
+    description: issue.description,
+    fix: issue.fix || ""
+  }));
+  const summary = summarizeVisualResult(result);
+  return summary === void 0 ? { issues } : { issues, summary };
+}
 
-export { CRITERIA, DEFAULT_EVAL_MAX_ROUNDS, DEFAULT_QUALITY_CONFIG, LLM_EVAL_STATIC_CRITERIA, MAX_EVAL_ROUNDS_HARD_LIMIT, buildCodingCriteriaSummary, buildFixPrompt, callMultimodalLLM, computeEvaluationScore, createEvaluationToolsServer, extractCompiledCode, extractCompiledCodeFromMessage, extractEvalResult, extractSourceCode, extractSourceCodeFromMessage, extractToolResultTexts, getActionableIssues, getCriteriaByPriority, getCriterionById, getEvaluatorSystemPrompt, getLLMCriteria, isBlocked, matches, notApplicableCoverage, priorityForIssue, runAxisChecks, runEvaluation, runEvaluationLoop };
+export { CANVAS_BREAKPOINTS, CANVAS_CLASSES, CANVAS_DESCRIPTORS, CANVAS_VIEWPORTS, CRITERIA, DEFAULT_EVAL_MAX_ROUNDS, DEFAULT_QUALITY_CONFIG, LLM_EVAL_STATIC_CRITERIA, MAX_EVAL_ROUNDS_HARD_LIMIT, buildCodingCriteriaSummary, buildFixPrompt, callMultimodalLLM, canvasDisplayModeForShell, canvasForRendering, canvasForViewportWidth, captureScreenshot, computeEvaluationScore, createEvaluationToolsServer, criteriaFor, describeCanvas, extractCompiledCode, extractCompiledCodeFromMessage, extractEvalResult, extractSourceCode, extractSourceCodeFromMessage, extractToolResultTexts, getActionableIssues, getCriteriaByPriority, getCriterionById, getEvaluatorSystemPrompt, getLLMCriteria, isBlocked, matches, notApplicableCoverage, priorityForIssue, resolveLaunchOptions, runAxisChecks, runEvaluation, runEvaluationLoop, runVisualEval, runVisualEvaluation, summarizeVisualResult };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map