unbrowse 10.2.0 → 10.3.0

package/runtime/cli.js

@@ -16445,7 +16445,7 @@ For a list of runtimes that currently support Ed25519 operations, visit https://
   function getErrorMessage(code, context = {}) {
     if (true) {
       return getHumanReadableErrorMessage(code, context);
-    }
+    } else {}
   }
   function isSolanaError(e, code) {
     const isSolanaError2 = e instanceof Error && e.name === "SolanaError";
@@ -22217,7 +22217,7 @@ var require_fallback = __commonJS((exports, module) => {
 
 // node_modules/.bun/bufferutil@4.1.0/node_modules/bufferutil/index.js
 var require_bufferutil = __commonJS((exports, module) => {
-  var __dirname = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/bufferutil@4.1.0/node_modules/bufferutil";
+  var __dirname = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/bufferutil@4.1.0/node_modules/bufferutil";
   try {
     module.exports = require_node_gyp_build2()(__dirname);
   } catch (e) {
@@ -22633,7 +22633,7 @@ var require_fallback2 = __commonJS((exports, module) => {
 
 // node_modules/.bun/utf-8-validate@6.0.6/node_modules/utf-8-validate/index.js
 var require_utf_8_validate = __commonJS((exports, module) => {
-  var __dirname = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/utf-8-validate@6.0.6/node_modules/utf-8-validate";
+  var __dirname = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/utf-8-validate@6.0.6/node_modules/utf-8-validate";
   try {
     module.exports = require_node_gyp_build2()(__dirname);
   } catch (e) {
@@ -64886,7 +64886,7 @@ var init_telemetry = __esm(() => {
 });
 
 // .tmp-runtime-src/build-info.generated.ts
-var BUILD_RELEASE_VERSION = "10.2.0", BUILD_GIT_SHA = "a5129ea18c09", BUILD_CODE_HASH = "5d9ebf619c61", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMTAuMi4wIiwiZ2l0X3NoYSI6ImE1MTI5ZWExOGMwOSIsImNvZGVfaGFzaCI6IjVkOWViZjYxOWM2MSIsInRyYWNlX3ZlcnNpb24iOiI1ZDllYmY2MTljNjFAYTUxMjllYTE4YzA5IiwiaXNzdWVkX2F0IjoiMjAyNi0wNi0yNFQwNTowMDozNi42ODRaIn0", BUILD_RELEASE_MANIFEST_SIGNATURE = "Qk8pVgRsymF5wBQGgm9sctXksHjjL89QgTSOURoSe3k", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai", BUILD_DEFAULT_PROFILE = "";
+var BUILD_RELEASE_VERSION = "10.3.0", BUILD_GIT_SHA = "f83d7800067c", BUILD_CODE_HASH = "5d9ebf619c61", BUILD_RELEASE_MANIFEST_BASE64 = "eyJzY2hlbWFfdmVyc2lvbiI6MSwicmVsZWFzZV92ZXJzaW9uIjoiMTAuMy4wIiwiZ2l0X3NoYSI6ImY4M2Q3ODAwMDY3YyIsImNvZGVfaGFzaCI6IjVkOWViZjYxOWM2MSIsInRyYWNlX3ZlcnNpb24iOiI1ZDllYmY2MTljNjFAZjgzZDc4MDAwNjdjIiwiaXNzdWVkX2F0IjoiMjAyNi0wNi0yNFQxMzoxODoyMS44MDJaIn0", BUILD_RELEASE_MANIFEST_SIGNATURE = "ecKMJ9MsPEVLVo7Q4WKNqdJ_nF2UP4yu4ktN-ezC6Og", BUILD_DEFAULT_BACKEND_URL = "https://beta-api.unbrowse.ai", BUILD_DEFAULT_PROFILE = "";
 
 // .tmp-runtime-src/version.ts
 import { createHash as createHash8 } from "crypto";
@@ -68981,7 +68981,7 @@ Candidates:`;
 
 // node_modules/.bun/sodium-native@5.1.0+607645472ba173c2/node_modules/sodium-native/binding.js
 var require_binding = __commonJS((exports, module) => {
-  var __filename = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/sodium-native@5.1.0+607645472ba173c2/node_modules/sodium-native/binding.js";
+  var __filename = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/sodium-native@5.1.0+607645472ba173c2/node_modules/sodium-native/binding.js";
   __require.addon = require_node();
   module.exports = __require.addon(".", __filename);
 });
@@ -76621,7 +76621,7 @@ var require_boot = __commonJS((exports, module) => {
         clearTimeout(timer);
         this._error = err;
         cb(this._error);
-      }
+      } else {}
     }
   }
   function closeWithCbOrNextTick(func, cb) {
@@ -80242,7 +80242,7 @@ var require_indexes = __commonJS((exports, module) => {
 
 // node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream/index.js
 var require_thread_stream = __commonJS((exports, module) => {
-  var __dirname = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream";
+  var __dirname = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream";
   var { version: version2 } = require_package();
   var { EventEmitter } = __require("events");
   var { Worker } = __require("worker_threads");
@@ -80758,7 +80758,7 @@ var require_thread_stream = __commonJS((exports, module) => {
 
 // node_modules/.bun/pino@10.3.1/node_modules/pino/lib/transport.js
 var require_transport = __commonJS((exports, module) => {
-  var __dirname = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/pino@10.3.1/node_modules/pino/lib";
+  var __dirname = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/pino@10.3.1/node_modules/pino/lib";
   var { createRequire: createRequire2 } = __require("module");
   var { existsSync: existsSync22 } = __require("node:fs");
   var getCallers = require_caller();
@@ -108376,696 +108376,3311 @@ var require_plugin2 = __commonJS((exports, module) => {
     if (options.fastify !== undefined && typeof options.fastify !== "string") {
       throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
     }
-    if (!options.name) {
-      autoName = true;
-      options.name = getPluginName(fn) + "-auto-" + count++;
+    if (!options.name) {
+      autoName = true;
+      options.name = getPluginName(fn) + "-auto-" + count++;
+    }
+    fn[Symbol.for("skip-override")] = options.encapsulate !== true;
+    fn[Symbol.for("fastify.display-name")] = options.name;
+    fn[Symbol.for("plugin-meta")] = options;
+    if (!fn.default) {
+      fn.default = fn;
+    }
+    const camelCase = toCamelCase(options.name);
+    if (!autoName && !fn[camelCase]) {
+      fn[camelCase] = fn;
+    }
+    return fn;
+  }
+  module.exports = plugin;
+  module.exports.default = plugin;
+  module.exports.fastifyPlugin = plugin;
+});
+
+// node_modules/.bun/@fastify+cors@11.2.0/node_modules/@fastify/cors/vary.js
+var require_vary = __commonJS((exports, module) => {
+  var { FifoMap: FifoCache } = require_toad_cache();
+  var validFieldnameRE = /^[!#$%&'*+\-.^\w`|~]+$/u;
+  function validateFieldname(fieldname) {
+    if (validFieldnameRE.test(fieldname) === false) {
+      throw new TypeError("Fieldname contains invalid characters.");
+    }
+  }
+  function parse2(header) {
+    header = header.trim().toLowerCase();
+    const result = [];
+    if (header.length === 0) {} else if (header.indexOf(",") === -1) {
+      result.push(header);
+    } else {
+      const il = header.length;
+      let i = 0;
+      let pos = 0;
+      let char;
+      for (i;i < il; ++i) {
+        char = header[i];
+        if (char === " ") {
+          pos = i + 1;
+        } else if (char === ",") {
+          if (pos !== i) {
+            result.push(header.slice(pos, i));
+          }
+          pos = i + 1;
+        }
+      }
+      if (pos !== i) {
+        result.push(header.slice(pos, i));
+      }
+    }
+    return result;
+  }
+  function createAddFieldnameToVary(fieldname) {
+    const headerCache = new FifoCache(1000);
+    validateFieldname(fieldname);
+    return function(reply) {
+      let header = reply.getHeader("Vary");
+      if (!header) {
+        reply.header("Vary", fieldname);
+        return;
+      }
+      if (header === "*") {
+        return;
+      }
+      if (fieldname === "*") {
+        reply.header("Vary", "*");
+        return;
+      }
+      if (Array.isArray(header)) {
+        header = header.join(", ");
+      }
+      if (headerCache.get(header) === undefined) {
+        const vals = parse2(header);
+        if (vals.indexOf("*") !== -1) {
+          headerCache.set(header, "*");
+        } else if (vals.indexOf(fieldname.toLowerCase()) === -1) {
+          headerCache.set(header, header + ", " + fieldname);
+        } else {
+          headerCache.set(header, null);
+        }
+      }
+      const cached3 = headerCache.get(header);
+      if (cached3 !== null) {
+        reply.header("Vary", cached3);
+      }
+    };
+  }
+  exports.createAddFieldnameToVary = createAddFieldnameToVary;
+  exports.addOriginToVaryHeader = createAddFieldnameToVary("Origin");
+  exports.addAccessControlRequestHeadersToVaryHeader = createAddFieldnameToVary("Access-Control-Request-Headers");
+  exports.parse = parse2;
+});
+
+// node_modules/.bun/@fastify+cors@11.2.0/node_modules/@fastify/cors/index.js
+var require_cors = __commonJS((exports, module) => {
+  var fp = require_plugin2();
+  var {
+    addAccessControlRequestHeadersToVaryHeader,
+    addOriginToVaryHeader
+  } = require_vary();
+  var defaultOptions = {
+    origin: "*",
+    methods: "GET,HEAD,POST",
+    hook: "onRequest",
+    preflightContinue: false,
+    optionsSuccessStatus: 204,
+    credentials: false,
+    exposedHeaders: null,
+    allowedHeaders: null,
+    maxAge: null,
+    preflight: true,
+    strictPreflight: true
+  };
+  var validHooks = [
+    "onRequest",
+    "preParsing",
+    "preValidation",
+    "preHandler",
+    "preSerialization",
+    "onSend"
+  ];
+  var hookWithPayload = [
+    "preSerialization",
+    "preParsing",
+    "onSend"
+  ];
+  function validateHook(value, next) {
+    if (validHooks.indexOf(value) !== -1) {
+      return;
+    }
+    next(new TypeError("@fastify/cors: Invalid hook option provided."));
+  }
+  function fastifyCors(fastify, opts, next) {
+    fastify.decorateRequest("corsPreflightEnabled", false);
+    let hideOptionsRoute = true;
+    let logLevel;
+    if (typeof opts === "function") {
+      handleCorsOptionsDelegator(opts, fastify, { hook: defaultOptions.hook }, next);
+    } else if (opts.delegator) {
+      const { delegator, ...options } = opts;
+      handleCorsOptionsDelegator(delegator, fastify, options, next);
+    } else {
+      const corsOptions = normalizeCorsOptions(opts);
+      validateHook(corsOptions.hook, next);
+      if (hookWithPayload.indexOf(corsOptions.hook) !== -1) {
+        fastify.addHook(corsOptions.hook, function handleCors(req, reply, _payload, next2) {
+          addCorsHeadersHandler(fastify, corsOptions, req, reply, next2);
+        });
+      } else {
+        fastify.addHook(corsOptions.hook, function handleCors(req, reply, next2) {
+          addCorsHeadersHandler(fastify, corsOptions, req, reply, next2);
+        });
+      }
+    }
+    if (opts.logLevel !== undefined)
+      logLevel = opts.logLevel;
+    if (opts.hideOptionsRoute !== undefined)
+      hideOptionsRoute = opts.hideOptionsRoute;
+    fastify.options("*", { schema: { hide: hideOptionsRoute }, logLevel }, (req, reply) => {
+      if (!req.corsPreflightEnabled) {
+        reply.callNotFound();
+        return;
+      }
+      reply.send();
+    });
+    next();
+  }
+  function handleCorsOptionsDelegator(optionsResolver, fastify, opts, next) {
+    const hook = opts?.hook || defaultOptions.hook;
+    validateHook(hook, next);
+    if (optionsResolver.length === 2) {
+      if (hookWithPayload.indexOf(hook) !== -1) {
+        fastify.addHook(hook, function handleCors(req, reply, _payload, next2) {
+          handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next2);
+        });
+      } else {
+        fastify.addHook(hook, function handleCors(req, reply, next2) {
+          handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next2);
+        });
+      }
+    } else {
+      if (hookWithPayload.indexOf(hook) !== -1) {
+        fastify.addHook(hook, function handleCors(req, reply, _payload, next2) {
+          const ret = optionsResolver(req);
+          if (ret && typeof ret.then === "function") {
+            ret.then((options) => addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next2)).catch(next2);
+            return;
+          }
+          next2(new Error("Invalid CORS origin option"));
+        });
+      } else {
+        fastify.addHook(hook, function handleCors(req, reply, next2) {
+          const ret = optionsResolver(req);
+          if (ret && typeof ret.then === "function") {
+            ret.then((options) => addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next2)).catch(next2);
+            return;
+          }
+          next2(new Error("Invalid CORS origin option"));
+        });
+      }
+    }
+  }
+  function handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next) {
+    optionsResolver(req, (err, options) => {
+      if (err) {
+        next(err);
+      } else {
+        addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next);
+      }
+    });
+  }
+  function normalizeCorsOptions(opts, dynamic) {
+    const corsOptions = { ...defaultOptions, ...opts };
+    if (Array.isArray(opts.origin) && opts.origin.indexOf("*") !== -1) {
+      corsOptions.origin = "*";
+    }
+    if (Number.isInteger(corsOptions.cacheControl)) {
+      corsOptions.cacheControl = `max-age=${corsOptions.cacheControl}`;
+    } else if (typeof corsOptions.cacheControl !== "string") {
+      corsOptions.cacheControl = null;
+    }
+    corsOptions.dynamic = dynamic || false;
+    return corsOptions;
+  }
+  function addCorsHeadersHandler(fastify, globalOptions, req, reply, next) {
+    const options = { ...globalOptions, ...req.routeOptions.config?.cors };
+    if (typeof options.origin !== "string" && options.origin !== false || options.dynamic) {
+      addOriginToVaryHeader(reply);
+    }
+    const resolveOriginOption = typeof options.origin === "function" ? resolveOriginWrapper(fastify, options.origin) : (_, cb) => cb(null, options.origin);
+    resolveOriginOption(req, (error, resolvedOriginOption) => {
+      if (error !== null) {
+        return next(error);
+      }
+      if (resolvedOriginOption === false) {
+        return next();
+      }
+      if (req.routeOptions.config?.cors === false) {
+        return next();
+      }
+      if (!resolvedOriginOption) {
+        return next(new Error("Invalid CORS origin option"));
+      }
+      addCorsHeaders(req, reply, resolvedOriginOption, options);
+      if (req.raw.method === "OPTIONS" && options.preflight === true) {
+        if (options.strictPreflight === true && (!req.headers.origin || !req.headers["access-control-request-method"])) {
+          reply.status(400).type("text/plain").send("Invalid Preflight Request");
+          return;
+        }
+        req.corsPreflightEnabled = true;
+        addPreflightHeaders(req, reply, options);
+        if (!options.preflightContinue) {
+          reply.code(options.optionsSuccessStatus).header("Content-Length", "0").send();
+          return;
+        }
+      }
+      return next();
+    });
+  }
+  function addCorsHeaders(req, reply, originOption, corsOptions) {
+    const origin = getAccessControlAllowOriginHeader(req.headers.origin, originOption);
+    if (origin) {
+      reply.header("Access-Control-Allow-Origin", origin);
+    }
+    if (corsOptions.credentials) {
+      reply.header("Access-Control-Allow-Credentials", "true");
+    }
+    if (corsOptions.exposedHeaders !== null) {
+      reply.header("Access-Control-Expose-Headers", Array.isArray(corsOptions.exposedHeaders) ? corsOptions.exposedHeaders.join(", ") : corsOptions.exposedHeaders);
+    }
+  }
+  function addPreflightHeaders(req, reply, corsOptions) {
+    reply.header("Access-Control-Allow-Methods", Array.isArray(corsOptions.methods) ? corsOptions.methods.join(", ") : corsOptions.methods);
+    if (corsOptions.allowedHeaders === null) {
+      addAccessControlRequestHeadersToVaryHeader(reply);
+      const reqAllowedHeaders = req.headers["access-control-request-headers"];
+      if (reqAllowedHeaders !== undefined) {
+        reply.header("Access-Control-Allow-Headers", reqAllowedHeaders);
+      }
+    } else {
+      reply.header("Access-Control-Allow-Headers", Array.isArray(corsOptions.allowedHeaders) ? corsOptions.allowedHeaders.join(", ") : corsOptions.allowedHeaders);
+    }
+    if (corsOptions.maxAge !== null) {
+      reply.header("Access-Control-Max-Age", String(corsOptions.maxAge));
+    }
+    if (corsOptions.cacheControl) {
+      reply.header("Cache-Control", corsOptions.cacheControl);
+    }
+  }
+  function resolveOriginWrapper(fastify, origin) {
+    return function(req, cb) {
+      const result = origin.call(fastify, req.headers.origin, cb);
+      if (result && typeof result.then === "function") {
+        result.then((res) => cb(null, res), cb);
+      }
+    };
+  }
+  function getAccessControlAllowOriginHeader(reqOrigin, originOption) {
+    if (typeof originOption === "string") {
+      return originOption;
+    }
+    return isRequestOriginAllowed(reqOrigin, originOption) ? reqOrigin : false;
+  }
+  function isRequestOriginAllowed(reqOrigin, allowedOrigin) {
+    if (Array.isArray(allowedOrigin)) {
+      for (let i = 0;i < allowedOrigin.length; ++i) {
+        if (isRequestOriginAllowed(reqOrigin, allowedOrigin[i])) {
+          return true;
+        }
+      }
+      return false;
+    } else if (typeof allowedOrigin === "string") {
+      return reqOrigin === allowedOrigin;
+    } else if (allowedOrigin instanceof RegExp) {
+      allowedOrigin.lastIndex = 0;
+      return allowedOrigin.test(reqOrigin);
+    } else {
+      return !!allowedOrigin;
+    }
+  }
+  var _fastifyCors = fp(fastifyCors, {
+    fastify: "5.x",
+    name: "@fastify/cors"
+  });
+  module.exports = _fastifyCors;
+  module.exports.fastifyCors = _fastifyCors;
+  module.exports.default = _fastifyCors;
+});
+
+// .tmp-runtime-src/ratelimit/index.ts
+async function registerRateLimiter(_app) {}
+var ROUTE_LIMITS;
+var init_ratelimit = __esm(() => {
+  ROUTE_LIMITS = {
+    "/v1/intent/resolve": { max: 20, timeWindow: "1 minute" },
+    "/v1/skills/:skill_id/execute": { max: 30, timeWindow: "1 minute" },
+    "/v1/skills": { max: 5, timeWindow: "1 minute" },
+    "/v1/auth/login": { max: 3, timeWindow: "5 minutes" },
+    "/v1/feedback": { max: 60, timeWindow: "1 minute" }
+  };
+});
+
+// .tmp-runtime-src/logger.ts
+import fs2 from "node:fs";
+import path5 from "node:path";
+function logDir() {
+  return path5.join(getUnbrowseHome2(), "logs");
+}
+function getLogFile() {
+  const date = new Date().toISOString().slice(0, 10);
+  return path5.join(logDir(), `unbrowse-${date}.log`);
+}
+function ensureLogDir() {
+  fs2.mkdirSync(logDir(), { recursive: true });
+}
+function log(module, message) {
+  const ts = new Date().toTimeString().slice(0, 8);
+  const line = `[${ts}] [${module}] ${message}`;
+  console.error(line);
+  try {
+    ensureLogDir();
+    fs2.appendFileSync(getLogFile(), line + `
+`);
+  } catch {}
+}
+function tsMs() {
+  const d = new Date;
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+function traceLine(message) {
+  const line = `[${tsMs()}] [trace] ${message}`;
+  console.log(line);
+  try {
+    ensureLogDir();
+    fs2.appendFileSync(getLogFile(), line + `
+`);
+  } catch {}
+}
+async function traceAsync(scope, sid, phase, fn) {
+  if (!TRACE_ENABLED)
+    return fn();
+  const sidShort = (sid ?? "-").slice(0, 8);
+  const tag = `sid=${sidShort} scope=${scope} phase=${phase}`;
+  const start = Date.now();
+  traceLine(`${tag} BEGIN`);
+  const heartbeat = setInterval(() => {
+    traceLine(`${tag} SLOW elapsed=${Date.now() - start}ms`);
+  }, TRACE_SLOW_MS);
+  heartbeat.unref?.();
+  try {
+    const result = await fn();
+    clearInterval(heartbeat);
+    traceLine(`${tag} END dur=${Date.now() - start}ms`);
+    return result;
+  } catch (err) {
+    clearInterval(heartbeat);
+    const msg = err instanceof Error ? err.message : String(err);
+    traceLine(`${tag} THREW dur=${Date.now() - start}ms err=${msg}`);
+    throw err;
+  }
+}
+var TRACE_ENABLED, TRACE_SLOW_MS;
+var init_logger = __esm(() => {
+  init_paths();
+  TRACE_ENABLED = (() => {
+    const v = process.env.UNBROWSE_TRACE;
+    return v != null && v !== "" && v !== "0";
+  })();
+  TRACE_SLOW_MS = (() => {
+    const n = parseInt(process.env.UNBROWSE_TRACE_SLOW_MS ?? "5000", 10);
+    return Number.isFinite(n) && n > 0 ? n : 5000;
+  })();
+});
+
+// .tmp-runtime-src/domain.ts
+var exports_domain = {};
+__export(exports_domain, {
+  isSameBrandDomain: () => isSameBrandDomain,
+  isDomainMatch: () => isDomainMatch,
+  getRegistrableDomain: () => getRegistrableDomain,
+  getBrandName: () => getBrandName
+});
+function getBrandName(hostname4) {
+  const h = hostname4.replace(/^\./, "").toLowerCase();
+  const parts = h.split(".");
+  if (parts.length >= 3) {
+    const lastTwo = parts.slice(-2).join(".");
+    if (GEO_TLD_SUFFIXES.has(lastTwo) || CC_TLDS.has(lastTwo)) {
+      return parts[parts.length - 3] ?? parts[0] ?? h;
+    }
+  }
+  return parts[parts.length - 2] ?? parts[0] ?? h;
+}
+function isSameBrandDomain(a, b) {
+  return getBrandName(a) === getBrandName(b);
+}
+function getRegistrableDomain(hostname4) {
+  const parts = hostname4.split(".");
+  if (parts.length >= 3) {
+    const lastTwo = parts.slice(-2).join(".");
+    if (CC_TLDS.has(lastTwo) || GEO_TLD_SUFFIXES.has(lastTwo)) {
+      return parts.slice(-3).join(".");
+    }
+  }
+  return parts.slice(-2).join(".");
+}
+function isDomainMatch(cookieDomain, targetDomain) {
+  const c = cookieDomain.replace(/^\./, "").toLowerCase();
+  const t = targetDomain.replace(/^\./, "").toLowerCase();
+  return t === c || t.endsWith("." + c);
+}
+var CC_TLDS, GEO_TLD_SUFFIXES;
+var init_domain = __esm(() => {
+  CC_TLDS = new Set([
+    "co.uk",
+    "co.nz",
+    "co.jp",
+    "co.kr",
+    "co.in",
+    "com.br",
+    "com.au",
+    "com.cn",
+    "com.mx",
+    "com.ar",
+    "com.tw",
+    "org.uk",
+    "gov.uk",
+    "ac.uk",
+    "net.au",
+    "org.au"
+  ]);
+  GEO_TLD_SUFFIXES = new Set([
+    "com.sg",
+    "com.hk",
+    "com.my",
+    "com.ph",
+    "com.vn",
+    "com.id",
+    "com.th",
+    "com.np",
+    "com.pk",
+    "com.bd",
+    "com.lk",
+    "com.mm",
+    "com.kh",
+    "com.eg",
+    "com.sa",
+    "com.qa",
+    "com.ae",
+    "com.kw",
+    "com.jo",
+    "com.lb",
+    "com.bh",
+    "com.om",
+    "com.iq",
+    "co.id",
+    "co.th",
+    "co.nz",
+    "co.jp",
+    "co.kr",
+    "co.in",
+    "co.uk",
+    "co.za",
+    "co.zw",
+    "co.ke",
+    "co.tz",
+    "co.ug"
+  ]);
+});
+
+// .tmp-runtime-src/settings.ts
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join23 } from "node:path";
+function sanitizeProfileName3(value) {
+  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getConfigDir3() {
+  if (process.env.UNBROWSE_CONFIG_DIR)
+    return process.env.UNBROWSE_CONFIG_DIR;
+  const profile = sanitizeProfileName3(process.env.UNBROWSE_PROFILE ?? "");
+  return profile ? join23(getUnbrowseHome2(), "profiles", profile) : getUnbrowseHome2();
+}
+function getUnbrowseConfigPath() {
+  return join23(getConfigDir3(), "config.json");
+}
+function loadRawConfig() {
+  try {
+    const configPath2 = getUnbrowseConfigPath();
+    if (existsSync22(configPath2)) {
+      const parsed = JSON.parse(readFileSync19(configPath2, "utf-8"));
+      if (parsed && typeof parsed === "object")
+        return parsed;
+    }
+  } catch {}
+  return {};
+}
+function saveRawConfig(config) {
+  const configDir = getConfigDir3();
+  if (!existsSync22(configDir))
+    mkdirSync11(configDir, { recursive: true });
+  writeFileSync9(getUnbrowseConfigPath(), JSON.stringify(config, null, 2), { mode: 384 });
+}
+function normalizeDomainRule(value) {
+  let normalized = value.trim().toLowerCase();
+  if (!normalized)
+    return "";
+  normalized = normalized.replace(/^\*\./, "");
+  if (normalized.startsWith("http://") || normalized.startsWith("https://")) {
+    try {
+      normalized = new URL(normalized).hostname.toLowerCase();
+    } catch {
+      normalized = normalized.replace(/^https?:\/\//, "");
+    }
+  }
+  normalized = normalized.split("/")[0] ?? normalized;
+  normalized = normalized.replace(/:\d+$/, "");
+  normalized = normalized.replace(/^www\./, "");
+  return normalized;
+}
+function normalizeDomainList(values) {
+  if (!Array.isArray(values))
+    return [];
+  const normalized = values.filter((value) => typeof value === "string").map(normalizeDomainRule).filter(Boolean);
+  return Array.from(new Set(normalized)).sort();
+}
+function matchesDomainRule(domain, rule) {
+  const host = normalizeDomainRule(domain);
+  const target = normalizeDomainRule(rule);
+  if (!host || !target)
+    return false;
+  if (host === target || host.endsWith(`.${target}`))
+    return true;
+  try {
+    return getRegistrableDomain(host) === target;
+  } catch {
+    return false;
+  }
+}
+function firstMatchingRule(domain, rules) {
+  return rules.find((rule) => matchesDomainRule(domain, rule));
+}
+function getCapturePipelineSettings() {
+  const raw = loadRawConfig();
+  const capturePipeline = raw.capture_pipeline && typeof raw.capture_pipeline === "object" ? raw.capture_pipeline : {};
+  return {
+    auto_publish_checkpoints: capturePipeline.auto_publish_checkpoints !== false,
+    publish_domain_blacklist: normalizeDomainList(capturePipeline.publish_domain_blacklist),
+    publish_domain_promptlist: normalizeDomainList(capturePipeline.publish_domain_promptlist)
+  };
+}
+function updateCapturePipelineSettings(update) {
+  const raw = loadRawConfig();
+  const existing = getCapturePipelineSettings();
+  const next = {
+    auto_publish_checkpoints: typeof update.auto_publish_checkpoints === "boolean" ? update.auto_publish_checkpoints : existing.auto_publish_checkpoints,
+    publish_domain_blacklist: update.clear_publish_domain_blacklist ? [] : update.publish_domain_blacklist ? normalizeDomainList(update.publish_domain_blacklist) : existing.publish_domain_blacklist,
+    publish_domain_promptlist: update.clear_publish_domain_promptlist ? [] : update.publish_domain_promptlist ? normalizeDomainList(update.publish_domain_promptlist) : existing.publish_domain_promptlist
+  };
+  saveRawConfig({
+    ...raw,
+    capture_pipeline: next
+  });
+  return next;
+}
+function getBrowserAttachPreference() {
+  const raw = loadRawConfig();
+  const browser = raw.browser && typeof raw.browser === "object" ? raw.browser : {};
+  return typeof browser.attach_existing_chrome === "boolean" ? browser.attach_existing_chrome : undefined;
+}
+function getBrowserAttachEnabled() {
+  return getBrowserAttachPreference() !== false;
+}
+function setBrowserAttachEnabled(enabled2) {
+  const raw = loadRawConfig();
+  const browser = raw.browser && typeof raw.browser === "object" ? { ...raw.browser } : {};
+  browser.attach_existing_chrome = enabled2;
+  saveRawConfig({ ...raw, browser });
+  return enabled2;
+}
+function decideCheckpointPublish(domain) {
+  const settings = getCapturePipelineSettings();
+  if (!settings.auto_publish_checkpoints) {
+    return {
+      publishQueued: false,
+      mode: "disabled",
+      reason: "Auto-publish after sync/close is disabled in local settings."
+    };
+  }
+  const blacklisted = firstMatchingRule(domain, settings.publish_domain_blacklist);
+  if (blacklisted) {
+    return {
+      publishQueued: false,
+      mode: "blacklisted",
+      reason: `Auto-publish skipped because ${domain} matches blacklist entry ${blacklisted}.`,
+      matchedDomain: blacklisted
+    };
+  }
+  const prompted = firstMatchingRule(domain, settings.publish_domain_promptlist);
+  if (prompted) {
+    return {
+      publishQueued: false,
+      mode: "prompt",
+      reason: `Auto-publish paused because ${domain} matches prompt-list entry ${prompted}.`,
+      matchedDomain: prompted
+    };
+  }
+  return {
+    publishQueued: true,
+    mode: "auto",
+    reason: "Background publish is allowed for this checkpoint."
+  };
+}
+function decideExplicitPublish(domain, confirmPublish) {
+  const settings = getCapturePipelineSettings();
+  const blacklisted = firstMatchingRule(domain, settings.publish_domain_blacklist);
+  if (blacklisted && !confirmPublish) {
+    return {
+      allowed: false,
+      mode: "blacklisted",
+      reason: `Explicit publish requires confirmation because ${domain} matches blacklist entry ${blacklisted}.`,
+      matchedDomain: blacklisted
+    };
+  }
+  const prompted = firstMatchingRule(domain, settings.publish_domain_promptlist);
+  if (prompted && !confirmPublish) {
+    return {
+      allowed: false,
+      mode: "prompt",
+      reason: `Explicit publish requires confirmation because ${domain} matches prompt-list entry ${prompted}.`,
+      matchedDomain: prompted
+    };
+  }
+  return {
+    allowed: true,
+    mode: "allowed",
+    reason: "Explicit publish allowed."
+  };
+}
+var init_settings = __esm(() => {
+  init_domain();
+  init_paths();
+});
+
+// ../../../node_modules/ws/lib/constants.js
+var require_constants8 = __commonJS((exports, module) => {
+  module.exports = {
+    BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+    GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+    kStatusCode: Symbol("status-code"),
+    kWebSocket: Symbol("websocket"),
+    EMPTY_BUFFER: Buffer.alloc(0),
+    NOOP: () => {}
+  };
+});
+
+// ../../../node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build3 = __commonJS((exports, module) => {
+  var fs3 = __require("fs");
+  var path6 = __require("path");
+  var os3 = __require("os");
+  var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+  var vars = process.config && process.config.variables || {};
+  var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+  var abi = process.versions.modules;
+  var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+  var arch = process.env.npm_config_arch || os3.arch();
+  var platform3 = process.env.npm_config_platform || os3.platform();
+  var libc = process.env.LIBC || (isAlpine(platform3) ? "musl" : "glibc");
+  var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+  var uv = (process.versions.uv || "").split(".")[0];
+  module.exports = load3;
+  function load3(dir) {
+    return runtimeRequire(load3.resolve(dir));
+  }
+  load3.resolve = load3.path = function(dir) {
+    dir = path6.resolve(dir || ".");
+    try {
+      var name = runtimeRequire(path6.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+      if (process.env[name + "_PREBUILD"])
+        dir = process.env[name + "_PREBUILD"];
+    } catch (err) {}
+    if (!prebuildsOnly) {
+      var release = getFirst(path6.join(dir, "build/Release"), matchBuild);
+      if (release)
+        return release;
+      var debug = getFirst(path6.join(dir, "build/Debug"), matchBuild);
+      if (debug)
+        return debug;
+    }
+    var prebuild = resolve(dir);
+    if (prebuild)
+      return prebuild;
+    var nearby = resolve(path6.dirname(process.execPath));
+    if (nearby)
+      return nearby;
+    var target = [
+      "platform=" + platform3,
+      "arch=" + arch,
+      "runtime=" + runtime,
+      "abi=" + abi,
+      "uv=" + uv,
+      armv ? "armv=" + armv : "",
+      "libc=" + libc,
+      "node=" + process.versions.node,
+      process.versions.electron ? "electron=" + process.versions.electron : "",
+      typeof __webpack_require__ === "function" ? "webpack=true" : ""
+    ].filter(Boolean).join(" ");
+    throw new Error("No native build was found for " + target + `
+    loaded from: ` + dir + `
+`);
+    function resolve(dir2) {
+      var tuples = readdirSync5(path6.join(dir2, "prebuilds")).map(parseTuple);
+      var tuple = tuples.filter(matchTuple(platform3, arch)).sort(compareTuples)[0];
+      if (!tuple)
+        return;
+      var prebuilds = path6.join(dir2, "prebuilds", tuple.name);
+      var parsed = readdirSync5(prebuilds).map(parseTags);
+      var candidates = parsed.filter(matchTags(runtime, abi));
+      var winner = candidates.sort(compareTags(runtime))[0];
+      if (winner)
+        return path6.join(prebuilds, winner.file);
+    }
+  };
+  function readdirSync5(dir) {
+    try {
+      return fs3.readdirSync(dir);
+    } catch (err) {
+      return [];
+    }
+  }
+  function getFirst(dir, filter) {
+    var files = readdirSync5(dir).filter(filter);
+    return files[0] && path6.join(dir, files[0]);
+  }
+  function matchBuild(name) {
+    return /\.node$/.test(name);
+  }
+  function parseTuple(name) {
+    var arr = name.split("-");
+    if (arr.length !== 2)
+      return;
+    var platform4 = arr[0];
+    var architectures = arr[1].split("+");
+    if (!platform4)
+      return;
+    if (!architectures.length)
+      return;
+    if (!architectures.every(Boolean))
+      return;
+    return { name, platform: platform4, architectures };
+  }
+  function matchTuple(platform4, arch2) {
+    return function(tuple) {
+      if (tuple == null)
+        return false;
+      if (tuple.platform !== platform4)
+        return false;
+      return tuple.architectures.includes(arch2);
+    };
+  }
+  function compareTuples(a, b) {
+    return a.architectures.length - b.architectures.length;
+  }
+  function parseTags(file) {
+    var arr = file.split(".");
+    var extension = arr.pop();
+    var tags = { file, specificity: 0 };
+    if (extension !== "node")
+      return;
+    for (var i = 0;i < arr.length; i++) {
+      var tag = arr[i];
+      if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+        tags.runtime = tag;
+      } else if (tag === "napi") {
+        tags.napi = true;
+      } else if (tag.slice(0, 3) === "abi") {
+        tags.abi = tag.slice(3);
+      } else if (tag.slice(0, 2) === "uv") {
+        tags.uv = tag.slice(2);
+      } else if (tag.slice(0, 4) === "armv") {
+        tags.armv = tag.slice(4);
+      } else if (tag === "glibc" || tag === "musl") {
+        tags.libc = tag;
+      } else {
+        continue;
+      }
+      tags.specificity++;
+    }
+    return tags;
+  }
+  function matchTags(runtime2, abi2) {
+    return function(tags) {
+      if (tags == null)
+        return false;
+      if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags))
+        return false;
+      if (tags.abi && tags.abi !== abi2 && !tags.napi)
+        return false;
+      if (tags.uv && tags.uv !== uv)
+        return false;
+      if (tags.armv && tags.armv !== armv)
+        return false;
+      if (tags.libc && tags.libc !== libc)
+        return false;
+      return true;
+    };
+  }
+  function runtimeAgnostic(tags) {
+    return tags.runtime === "node" && tags.napi;
+  }
+  function compareTags(runtime2) {
+    return function(a, b) {
+      if (a.runtime !== b.runtime) {
+        return a.runtime === runtime2 ? -1 : 1;
+      } else if (a.abi !== b.abi) {
+        return a.abi ? -1 : 1;
+      } else if (a.specificity !== b.specificity) {
+        return a.specificity > b.specificity ? -1 : 1;
+      } else {
+        return 0;
+      }
+    };
+  }
+  function isNwjs() {
+    return !!(process.versions && process.versions.nw);
+  }
+  function isElectron() {
+    if (process.versions && process.versions.electron)
+      return true;
+    if (process.env.ELECTRON_RUN_AS_NODE)
+      return true;
+    return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+  }
+  function isAlpine(platform4) {
+    return platform4 === "linux" && fs3.existsSync("/etc/alpine-release");
+  }
+  load3.parseTags = parseTags;
+  load3.matchTags = matchTags;
+  load3.compareTags = compareTags;
+  load3.parseTuple = parseTuple;
+  load3.matchTuple = matchTuple;
+  load3.compareTuples = compareTuples;
+});
+
+// ../../../node_modules/node-gyp-build/index.js
+var require_node_gyp_build4 = __commonJS((exports, module) => {
+  var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+  if (typeof runtimeRequire.addon === "function") {
+    module.exports = runtimeRequire.addon.bind(runtimeRequire);
+  } else {
+    module.exports = require_node_gyp_build3();
+  }
+});
+
+// ../../../node_modules/bufferutil/fallback.js
+var require_fallback3 = __commonJS((exports, module) => {
+  var mask = (source, mask2, output, offset, length) => {
+    for (var i = 0;i < length; i++) {
+      output[offset + i] = source[i] ^ mask2[i & 3];
+    }
+  };
+  var unmask = (buffer, mask2) => {
+    const length = buffer.length;
+    for (var i = 0;i < length; i++) {
+      buffer[i] ^= mask2[i & 3];
+    }
+  };
+  module.exports = { mask, unmask };
+});
+
+// ../../../node_modules/bufferutil/index.js
+var require_bufferutil2 = __commonJS((exports, module) => {
+  var __dirname = "/Users/lekt9/node_modules/bufferutil";
+  try {
+    module.exports = require_node_gyp_build4()(__dirname);
+  } catch (e) {
+    module.exports = require_fallback3();
+  }
+});
+
+// ../../../node_modules/ws/lib/buffer-util.js
+var require_buffer_util2 = __commonJS((exports, module) => {
+  var { EMPTY_BUFFER } = require_constants8();
+  function concat3(list, totalLength) {
+    if (list.length === 0)
+      return EMPTY_BUFFER;
+    if (list.length === 1)
+      return list[0];
+    const target = Buffer.allocUnsafe(totalLength);
+    let offset = 0;
+    for (let i = 0;i < list.length; i++) {
+      const buf = list[i];
+      target.set(buf, offset);
+      offset += buf.length;
+    }
+    if (offset < totalLength)
+      return target.slice(0, offset);
+    return target;
+  }
+  function _mask(source, mask, output, offset, length) {
+    for (let i = 0;i < length; i++) {
+      output[offset + i] = source[i] ^ mask[i & 3];
+    }
+  }
+  function _unmask(buffer, mask) {
+    const length = buffer.length;
+    for (let i = 0;i < length; i++) {
+      buffer[i] ^= mask[i & 3];
+    }
+  }
+  function toArrayBuffer(buf) {
+    if (buf.byteLength === buf.buffer.byteLength) {
+      return buf.buffer;
+    }
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  function toBuffer(data) {
+    toBuffer.readOnly = true;
+    if (Buffer.isBuffer(data))
+      return data;
+    let buf;
+    if (data instanceof ArrayBuffer) {
+      buf = Buffer.from(data);
+    } else if (ArrayBuffer.isView(data)) {
+      buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    } else {
+      buf = Buffer.from(data);
+      toBuffer.readOnly = false;
+    }
+    return buf;
+  }
+  try {
+    const bufferUtil = require_bufferutil2();
+    const bu = bufferUtil.BufferUtil || bufferUtil;
+    module.exports = {
+      concat: concat3,
+      mask(source, mask, output, offset, length) {
+        if (length < 48)
+          _mask(source, mask, output, offset, length);
+        else
+          bu.mask(source, mask, output, offset, length);
+      },
+      toArrayBuffer,
+      toBuffer,
+      unmask(buffer, mask) {
+        if (buffer.length < 32)
+          _unmask(buffer, mask);
+        else
+          bu.unmask(buffer, mask);
+      }
+    };
+  } catch (e) {
+    module.exports = {
+      concat: concat3,
+      mask: _mask,
+      toArrayBuffer,
+      toBuffer,
+      unmask: _unmask
+    };
+  }
+});
+
+// ../../../node_modules/ws/lib/limiter.js
+var require_limiter2 = __commonJS((exports, module) => {
+  var kDone = Symbol("kDone");
+  var kRun = Symbol("kRun");
+
+  class Limiter {
+    constructor(concurrency) {
+      this[kDone] = () => {
+        this.pending--;
+        this[kRun]();
+      };
+      this.concurrency = concurrency || Infinity;
+      this.jobs = [];
+      this.pending = 0;
+    }
+    add(job) {
+      this.jobs.push(job);
+      this[kRun]();
+    }
+    [kRun]() {
+      if (this.pending === this.concurrency)
+        return;
+      if (this.jobs.length) {
+        const job = this.jobs.shift();
+        this.pending++;
+        job(this[kDone]);
+      }
+    }
+  }
+  module.exports = Limiter;
+});
+
+// ../../../node_modules/ws/lib/permessage-deflate.js
+var require_permessage_deflate2 = __commonJS((exports, module) => {
+  var zlib = __require("zlib");
+  var bufferUtil = require_buffer_util2();
+  var Limiter = require_limiter2();
+  var { kStatusCode, NOOP } = require_constants8();
+  var TRAILER = Buffer.from([0, 0, 255, 255]);
+  var kPerMessageDeflate = Symbol("permessage-deflate");
+  var kTotalLength = Symbol("total-length");
+  var kCallback = Symbol("callback");
+  var kBuffers = Symbol("buffers");
+  var kError = Symbol("error");
+  var zlibLimiter;
+
+  class PerMessageDeflate {
+    constructor(options, isServer, maxPayload) {
+      this._maxPayload = maxPayload | 0;
+      this._options = options || {};
+      this._threshold = this._options.threshold !== undefined ? this._options.threshold : 1024;
+      this._isServer = !!isServer;
+      this._deflate = null;
+      this._inflate = null;
+      this.params = null;
+      if (!zlibLimiter) {
+        const concurrency = this._options.concurrencyLimit !== undefined ? this._options.concurrencyLimit : 10;
+        zlibLimiter = new Limiter(concurrency);
+      }
+    }
+    static get extensionName() {
+      return "permessage-deflate";
+    }
+    offer() {
+      const params = {};
+      if (this._options.serverNoContextTakeover) {
+        params.server_no_context_takeover = true;
+      }
+      if (this._options.clientNoContextTakeover) {
+        params.client_no_context_takeover = true;
+      }
+      if (this._options.serverMaxWindowBits) {
+        params.server_max_window_bits = this._options.serverMaxWindowBits;
+      }
+      if (this._options.clientMaxWindowBits) {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      } else if (this._options.clientMaxWindowBits == null) {
+        params.client_max_window_bits = true;
+      }
+      return params;
+    }
+    accept(configurations) {
+      configurations = this.normalizeParams(configurations);
+      this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+      return this.params;
+    }
+    cleanup() {
+      if (this._inflate) {
+        this._inflate.close();
+        this._inflate = null;
+      }
+      if (this._deflate) {
+        const callback = this._deflate[kCallback];
+        this._deflate.close();
+        this._deflate = null;
+        if (callback) {
+          callback(new Error("The deflate stream was closed while data was being processed"));
+        }
+      }
+    }
+    acceptAsServer(offers) {
+      const opts = this._options;
+      const accepted = offers.find((params) => {
+        if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+          return false;
+        }
+        return true;
+      });
+      if (!accepted) {
+        throw new Error("None of the extension offers can be accepted");
+      }
+      if (opts.serverNoContextTakeover) {
+        accepted.server_no_context_takeover = true;
+      }
+      if (opts.clientNoContextTakeover) {
+        accepted.client_no_context_takeover = true;
+      }
+      if (typeof opts.serverMaxWindowBits === "number") {
+        accepted.server_max_window_bits = opts.serverMaxWindowBits;
+      }
+      if (typeof opts.clientMaxWindowBits === "number") {
+        accepted.client_max_window_bits = opts.clientMaxWindowBits;
+      } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+        delete accepted.client_max_window_bits;
+      }
+      return accepted;
+    }
+    acceptAsClient(response) {
+      const params = response[0];
+      if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+        throw new Error('Unexpected parameter "client_no_context_takeover"');
+      }
+      if (!params.client_max_window_bits) {
+        if (typeof this._options.clientMaxWindowBits === "number") {
+          params.client_max_window_bits = this._options.clientMaxWindowBits;
+        }
+      } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
+        throw new Error('Unexpected or invalid parameter "client_max_window_bits"');
+      }
+      return params;
+    }
+    normalizeParams(configurations) {
+      configurations.forEach((params) => {
+        Object.keys(params).forEach((key) => {
+          let value = params[key];
+          if (value.length > 1) {
+            throw new Error(`Parameter "${key}" must have only a single value`);
+          }
+          value = value[0];
+          if (key === "client_max_window_bits") {
+            if (value !== true) {
+              const num = +value;
+              if (!Number.isInteger(num) || num < 8 || num > 15) {
+                throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+              }
+              value = num;
+            } else if (!this._isServer) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else if (key === "server_max_window_bits") {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+            value = num;
+          } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+            if (value !== true) {
+              throw new TypeError(`Invalid value for parameter "${key}": ${value}`);
+            }
+          } else {
+            throw new Error(`Unknown parameter "${key}"`);
+          }
+          params[key] = value;
+        });
+      });
+      return configurations;
+    }
+    decompress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._decompress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    compress(data, fin, callback) {
+      zlibLimiter.add((done) => {
+        this._compress(data, fin, (err, result) => {
+          done();
+          callback(err, result);
+        });
+      });
+    }
+    _decompress(data, fin, callback) {
+      const endpoint = this._isServer ? "client" : "server";
+      if (!this._inflate) {
+        const key = `${endpoint}_max_window_bits`;
+        const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+        this._inflate = zlib.createInflateRaw({
+          ...this._options.zlibInflateOptions,
+          windowBits
+        });
+        this._inflate[kPerMessageDeflate] = this;
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+        this._inflate.on("error", inflateOnError);
+        this._inflate.on("data", inflateOnData);
+      }
+      this._inflate[kCallback] = callback;
+      this._inflate.write(data);
+      if (fin)
+        this._inflate.write(TRAILER);
+      this._inflate.flush(() => {
+        const err = this._inflate[kError];
+        if (err) {
+          this._inflate.close();
+          this._inflate = null;
+          callback(err);
+          return;
+        }
+        const data2 = bufferUtil.concat(this._inflate[kBuffers], this._inflate[kTotalLength]);
+        if (this._inflate._readableState.endEmitted) {
+          this._inflate.close();
+          this._inflate = null;
+        } else {
+          this._inflate[kTotalLength] = 0;
+          this._inflate[kBuffers] = [];
+          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+            this._inflate.reset();
+          }
+        }
+        callback(null, data2);
+      });
+    }
+    _compress(data, fin, callback) {
+      const endpoint = this._isServer ? "server" : "client";
+      if (!this._deflate) {
+        const key = `${endpoint}_max_window_bits`;
+        const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+        this._deflate = zlib.createDeflateRaw({
+          ...this._options.zlibDeflateOptions,
+          windowBits
+        });
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        this._deflate.on("error", NOOP);
+        this._deflate.on("data", deflateOnData);
+      }
+      this._deflate[kCallback] = callback;
+      this._deflate.write(data);
+      this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+        if (!this._deflate) {
+          return;
+        }
+        let data2 = bufferUtil.concat(this._deflate[kBuffers], this._deflate[kTotalLength]);
+        if (fin)
+          data2 = data2.slice(0, data2.length - 4);
+        this._deflate[kCallback] = null;
+        this._deflate[kTotalLength] = 0;
+        this._deflate[kBuffers] = [];
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._deflate.reset();
+        }
+        callback(null, data2);
+      });
+    }
+  }
+  module.exports = PerMessageDeflate;
+  function deflateOnData(chunk) {
+    this[kBuffers].push(chunk);
+    this[kTotalLength] += chunk.length;
+  }
+  function inflateOnData(chunk) {
+    this[kTotalLength] += chunk.length;
+    if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
+      this[kBuffers].push(chunk);
+      return;
+    }
+    this[kError] = new RangeError("Max payload size exceeded");
+    this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+    this[kError][kStatusCode] = 1009;
+    this.removeListener("data", inflateOnData);
+    this.reset();
+  }
+  function inflateOnError(err) {
+    this[kPerMessageDeflate]._inflate = null;
+    err[kStatusCode] = 1007;
+    this[kCallback](err);
+  }
+});
+
+// ../../../node_modules/ws/lib/validation.js
+var require_validation4 = __commonJS((exports, module) => {
+  function isValidStatusCode(code) {
+    return code >= 1000 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3000 && code <= 4999;
+  }
+  function _isValidUTF8(buf) {
+    const len = buf.length;
+    let i = 0;
+    while (i < len) {
+      if ((buf[i] & 128) === 0) {
+        i++;
+      } else if ((buf[i] & 224) === 192) {
+        if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+          return false;
+        }
+        i += 2;
+      } else if ((buf[i] & 240) === 224) {
+        if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+          return false;
+        }
+        i += 3;
+      } else if ((buf[i] & 248) === 240) {
+        if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+          return false;
+        }
+        i += 4;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+  try {
+    let isValidUTF8 = (()=>{throw new Error("Cannot require module "+"utf-8-validate");})();
+    if (typeof isValidUTF8 === "object") {
+      isValidUTF8 = isValidUTF8.Validation.isValidUTF8;
+    }
+    module.exports = {
+      isValidStatusCode,
+      isValidUTF8(buf) {
+        return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
+      }
+    };
+  } catch (e) {
+    module.exports = {
+      isValidStatusCode,
+      isValidUTF8: _isValidUTF8
+    };
+  }
+});
+
+// ../../../node_modules/ws/lib/receiver.js
+var require_receiver2 = __commonJS((exports, module) => {
+  var { Writable } = __require("stream");
+  var PerMessageDeflate = require_permessage_deflate2();
+  var {
+    BINARY_TYPES,
+    EMPTY_BUFFER,
+    kStatusCode,
+    kWebSocket
+  } = require_constants8();
+  var { concat: concat3, toArrayBuffer, unmask } = require_buffer_util2();
+  var { isValidStatusCode, isValidUTF8 } = require_validation4();
+  var GET_INFO = 0;
+  var GET_PAYLOAD_LENGTH_16 = 1;
+  var GET_PAYLOAD_LENGTH_64 = 2;
+  var GET_MASK = 3;
+  var GET_DATA = 4;
+  var INFLATING = 5;
+
+  class Receiver extends Writable {
+    constructor(binaryType, extensions, isServer, maxPayload, maxBufferedChunks, maxFragments) {
+      super();
+      this._binaryType = binaryType || BINARY_TYPES[0];
+      this[kWebSocket] = undefined;
+      this._extensions = extensions || {};
+      this._isServer = !!isServer;
+      this._maxBufferedChunks = maxBufferedChunks | 0;
+      this._maxFragments = maxFragments | 0;
+      this._maxPayload = maxPayload | 0;
+      this._bufferedBytes = 0;
+      this._buffers = [];
+      this._compressed = false;
+      this._payloadLength = 0;
+      this._mask = undefined;
+      this._fragmented = 0;
+      this._masked = false;
+      this._fin = false;
+      this._opcode = 0;
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragments = [];
+      this._state = GET_INFO;
+      this._loop = false;
+    }
+    _write(chunk, encoding, cb) {
+      if (this._opcode === 8 && this._state == GET_INFO)
+        return cb();
+      if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
+        return cb(error(RangeError, "Too many buffered chunks", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS"));
+      }
+      this._bufferedBytes += chunk.length;
+      this._buffers.push(chunk);
+      this.startLoop(cb);
+    }
+    consume(n) {
+      this._bufferedBytes -= n;
+      if (n === this._buffers[0].length)
+        return this._buffers.shift();
+      if (n < this._buffers[0].length) {
+        const buf = this._buffers[0];
+        this._buffers[0] = buf.slice(n);
+        return buf.slice(0, n);
+      }
+      const dst = Buffer.allocUnsafe(n);
+      do {
+        const buf = this._buffers[0];
+        const offset = dst.length - n;
+        if (n >= buf.length) {
+          dst.set(this._buffers.shift(), offset);
+        } else {
+          dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+          this._buffers[0] = buf.slice(n);
+        }
+        n -= buf.length;
+      } while (n > 0);
+      return dst;
+    }
+    startLoop(cb) {
+      let err;
+      this._loop = true;
+      do {
+        switch (this._state) {
+          case GET_INFO:
+            err = this.getInfo();
+            break;
+          case GET_PAYLOAD_LENGTH_16:
+            err = this.getPayloadLength16();
+            break;
+          case GET_PAYLOAD_LENGTH_64:
+            err = this.getPayloadLength64();
+            break;
+          case GET_MASK:
+            this.getMask();
+            break;
+          case GET_DATA:
+            err = this.getData(cb);
+            break;
+          default:
+            this._loop = false;
+            return;
+        }
+      } while (this._loop);
+      cb(err);
+    }
+    getInfo() {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      const buf = this.consume(2);
+      if ((buf[0] & 48) !== 0) {
+        this._loop = false;
+        return error(RangeError, "RSV2 and RSV3 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_2_3");
+      }
+      const compressed = (buf[0] & 64) === 64;
+      if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+        this._loop = false;
+        return error(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+      }
+      this._fin = (buf[0] & 128) === 128;
+      this._opcode = buf[0] & 15;
+      this._payloadLength = buf[1] & 127;
+      if (this._opcode === 0) {
+        if (compressed) {
+          this._loop = false;
+          return error(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+        }
+        if (!this._fragmented) {
+          this._loop = false;
+          return error(RangeError, "invalid opcode 0", true, 1002, "WS_ERR_INVALID_OPCODE");
+        }
+        this._opcode = this._fragmented;
+      } else if (this._opcode === 1 || this._opcode === 2) {
+        if (this._fragmented) {
+          this._loop = false;
+          return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+        }
+        this._compressed = compressed;
+      } else if (this._opcode > 7 && this._opcode < 11) {
+        if (!this._fin) {
+          this._loop = false;
+          return error(RangeError, "FIN must be set", true, 1002, "WS_ERR_EXPECTED_FIN");
+        }
+        if (compressed) {
+          this._loop = false;
+          return error(RangeError, "RSV1 must be clear", true, 1002, "WS_ERR_UNEXPECTED_RSV_1");
+        }
+        if (this._payloadLength > 125) {
+          this._loop = false;
+          return error(RangeError, `invalid payload length ${this._payloadLength}`, true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
+        }
+      } else {
+        this._loop = false;
+        return error(RangeError, `invalid opcode ${this._opcode}`, true, 1002, "WS_ERR_INVALID_OPCODE");
+      }
+      if (!this._fin && !this._fragmented)
+        this._fragmented = this._opcode;
+      this._masked = (buf[1] & 128) === 128;
+      if (this._isServer) {
+        if (!this._masked) {
+          this._loop = false;
+          return error(RangeError, "MASK must be set", true, 1002, "WS_ERR_EXPECTED_MASK");
+        }
+      } else if (this._masked) {
+        this._loop = false;
+        return error(RangeError, "MASK must be clear", true, 1002, "WS_ERR_UNEXPECTED_MASK");
+      }
+      if (this._payloadLength === 126)
+        this._state = GET_PAYLOAD_LENGTH_16;
+      else if (this._payloadLength === 127)
+        this._state = GET_PAYLOAD_LENGTH_64;
+      else
+        return this.haveLength();
+    }
+    getPayloadLength16() {
+      if (this._bufferedBytes < 2) {
+        this._loop = false;
+        return;
+      }
+      this._payloadLength = this.consume(2).readUInt16BE(0);
+      return this.haveLength();
+    }
+    getPayloadLength64() {
+      if (this._bufferedBytes < 8) {
+        this._loop = false;
+        return;
+      }
+      const buf = this.consume(8);
+      const num = buf.readUInt32BE(0);
+      if (num > Math.pow(2, 53 - 32) - 1) {
+        this._loop = false;
+        return error(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", false, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");
+      }
+      this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+      return this.haveLength();
+    }
+    haveLength() {
+      if (this._payloadLength && this._opcode < 8) {
+        this._totalPayloadLength += this._payloadLength;
+        if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+          this._loop = false;
+          return error(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
+        }
+      }
+      if (this._masked)
+        this._state = GET_MASK;
+      else
+        this._state = GET_DATA;
+    }
+    getMask() {
+      if (this._bufferedBytes < 4) {
+        this._loop = false;
+        return;
+      }
+      this._mask = this.consume(4);
+      this._state = GET_DATA;
+    }
+    getData(cb) {
+      let data = EMPTY_BUFFER;
+      if (this._payloadLength) {
+        if (this._bufferedBytes < this._payloadLength) {
+          this._loop = false;
+          return;
+        }
+        data = this.consume(this._payloadLength);
+        if (this._masked)
+          unmask(data, this._mask);
+      }
+      if (this._opcode > 7)
+        return this.controlMessage(data);
+      if (this._compressed) {
+        this._state = INFLATING;
+        this.decompress(data, cb);
+        return;
+      }
+      if (data.length) {
+        if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+          this._loop = false;
+          return error(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS");
+        }
+        this._messageLength = this._totalPayloadLength;
+        this._fragments.push(data);
+      }
+      return this.dataMessage();
+    }
+    decompress(data, cb) {
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+        if (err)
+          return cb(err);
+        if (buf.length) {
+          this._messageLength += buf.length;
+          if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+            return cb(error(RangeError, "Max payload size exceeded", false, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"));
+          }
+          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+            return cb(error(RangeError, "Too many message fragments", false, 1008, "WS_ERR_TOO_MANY_BUFFERED_PARTS"));
+          }
+          this._fragments.push(buf);
+        }
+        const er = this.dataMessage();
+        if (er)
+          return cb(er);
+        this.startLoop(cb);
+      });
+    }
+    dataMessage() {
+      if (this._fin) {
+        const messageLength = this._messageLength;
+        const fragments = this._fragments;
+        this._totalPayloadLength = 0;
+        this._messageLength = 0;
+        this._fragmented = 0;
+        this._fragments = [];
+        if (this._opcode === 2) {
+          let data;
+          if (this._binaryType === "nodebuffer") {
+            data = concat3(fragments, messageLength);
+          } else if (this._binaryType === "arraybuffer") {
+            data = toArrayBuffer(concat3(fragments, messageLength));
+          } else {
+            data = fragments;
+          }
+          this.emit("message", data);
+        } else {
+          const buf = concat3(fragments, messageLength);
+          if (!isValidUTF8(buf)) {
+            this._loop = false;
+            return error(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+          }
+          this.emit("message", buf.toString());
+        }
+      }
+      this._state = GET_INFO;
+    }
+    controlMessage(data) {
+      if (this._opcode === 8) {
+        this._loop = false;
+        if (data.length === 0) {
+          this.emit("conclude", 1005, "");
+          this.end();
+        } else if (data.length === 1) {
+          return error(RangeError, "invalid payload length 1", true, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
+        } else {
+          const code = data.readUInt16BE(0);
+          if (!isValidStatusCode(code)) {
+            return error(RangeError, `invalid status code ${code}`, true, 1002, "WS_ERR_INVALID_CLOSE_CODE");
+          }
+          const buf = data.slice(2);
+          if (!isValidUTF8(buf)) {
+            return error(Error, "invalid UTF-8 sequence", true, 1007, "WS_ERR_INVALID_UTF8");
+          }
+          this.emit("conclude", code, buf.toString());
+          this.end();
+        }
+      } else if (this._opcode === 9) {
+        this.emit("ping", data);
+      } else {
+        this.emit("pong", data);
+      }
+      this._state = GET_INFO;
+    }
+  }
+  module.exports = Receiver;
+  function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+    const err = new ErrorCtor(prefix ? `Invalid WebSocket frame: ${message}` : message);
+    Error.captureStackTrace(err, error);
+    err.code = errorCode;
+    err[kStatusCode] = statusCode;
+    return err;
+  }
+});
+
+// ../../../node_modules/ws/lib/sender.js
+var require_sender2 = __commonJS((exports, module) => {
+  var net = __require("net");
+  var tls = __require("tls");
+  var { randomFillSync } = __require("crypto");
+  var PerMessageDeflate = require_permessage_deflate2();
+  var { EMPTY_BUFFER } = require_constants8();
+  var { isValidStatusCode } = require_validation4();
+  var { mask: applyMask, toBuffer } = require_buffer_util2();
+  var mask = Buffer.alloc(4);
+
+  class Sender {
+    constructor(socket, extensions) {
+      this._extensions = extensions || {};
+      this._socket = socket;
+      this._firstFragment = true;
+      this._compress = false;
+      this._bufferedBytes = 0;
+      this._deflating = false;
+      this._queue = [];
+    }
+    static frame(data, options) {
+      const merge = options.mask && options.readOnly;
+      let offset = options.mask ? 6 : 2;
+      let payloadLength = data.length;
+      if (data.length >= 65536) {
+        offset += 8;
+        payloadLength = 127;
+      } else if (data.length > 125) {
+        offset += 2;
+        payloadLength = 126;
+      }
+      const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+      target[0] = options.fin ? options.opcode | 128 : options.opcode;
+      if (options.rsv1)
+        target[0] |= 64;
+      target[1] = payloadLength;
+      if (payloadLength === 126) {
+        target.writeUInt16BE(data.length, 2);
+      } else if (payloadLength === 127) {
+        target.writeUInt32BE(0, 2);
+        target.writeUInt32BE(data.length, 6);
+      }
+      if (!options.mask)
+        return [target, data];
+      randomFillSync(mask, 0, 4);
+      target[1] |= 128;
+      target[offset - 4] = mask[0];
+      target[offset - 3] = mask[1];
+      target[offset - 2] = mask[2];
+      target[offset - 1] = mask[3];
+      if (merge) {
+        applyMask(data, mask, target, offset, data.length);
+        return [target];
+      }
+      applyMask(data, mask, data, 0, data.length);
+      return [target, data];
+    }
+    close(code, data, mask2, cb) {
+      let buf;
+      if (code === undefined) {
+        buf = EMPTY_BUFFER;
+      } else if (typeof code !== "number" || !isValidStatusCode(code)) {
+        throw new TypeError("First argument must be a valid error code number");
+      } else if (data === undefined || data === "") {
+        buf = Buffer.allocUnsafe(2);
+        buf.writeUInt16BE(code, 0);
+      } else {
+        const length = Buffer.byteLength(data);
+        if (length > 123) {
+          throw new RangeError("The message must not be greater than 123 bytes");
+        }
+        buf = Buffer.allocUnsafe(2 + length);
+        buf.writeUInt16BE(code, 0);
+        buf.write(data, 2);
+      }
+      if (this._deflating) {
+        this.enqueue([this.doClose, buf, mask2, cb]);
+      } else {
+        this.doClose(buf, mask2, cb);
+      }
+    }
+    doClose(data, mask2, cb) {
+      this.sendFrame(Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 8,
+        mask: mask2,
+        readOnly: false
+      }), cb);
+    }
+    ping(data, mask2, cb) {
+      const buf = toBuffer(data);
+      if (buf.length > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      if (this._deflating) {
+        this.enqueue([this.doPing, buf, mask2, toBuffer.readOnly, cb]);
+      } else {
+        this.doPing(buf, mask2, toBuffer.readOnly, cb);
+      }
+    }
+    doPing(data, mask2, readOnly, cb) {
+      this.sendFrame(Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 9,
+        mask: mask2,
+        readOnly
+      }), cb);
+    }
+    pong(data, mask2, cb) {
+      const buf = toBuffer(data);
+      if (buf.length > 125) {
+        throw new RangeError("The data size must not be greater than 125 bytes");
+      }
+      if (this._deflating) {
+        this.enqueue([this.doPong, buf, mask2, toBuffer.readOnly, cb]);
+      } else {
+        this.doPong(buf, mask2, toBuffer.readOnly, cb);
+      }
+    }
+    doPong(data, mask2, readOnly, cb) {
+      this.sendFrame(Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 10,
+        mask: mask2,
+        readOnly
+      }), cb);
+    }
+    send(data, options, cb) {
+      const buf = toBuffer(data);
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      let opcode = options.binary ? 2 : 1;
+      let rsv1 = options.compress;
+      if (this._firstFragment) {
+        this._firstFragment = false;
+        if (rsv1 && perMessageDeflate) {
+          rsv1 = buf.length >= perMessageDeflate._threshold;
+        }
+        this._compress = rsv1;
+      } else {
+        rsv1 = false;
+        opcode = 0;
+      }
+      if (options.fin)
+        this._firstFragment = true;
+      if (perMessageDeflate) {
+        const opts = {
+          fin: options.fin,
+          rsv1,
+          opcode,
+          mask: options.mask,
+          readOnly: toBuffer.readOnly
+        };
+        if (this._deflating) {
+          this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+        } else {
+          this.dispatch(buf, this._compress, opts, cb);
+        }
+      } else {
+        this.sendFrame(Sender.frame(buf, {
+          fin: options.fin,
+          rsv1: false,
+          opcode,
+          mask: options.mask,
+          readOnly: toBuffer.readOnly
+        }), cb);
+      }
+    }
+    dispatch(data, compress, options, cb) {
+      if (!compress) {
+        this.sendFrame(Sender.frame(data, options), cb);
+        return;
+      }
+      const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+      this._bufferedBytes += data.length;
+      this._deflating = true;
+      perMessageDeflate.compress(data, options.fin, (_, buf) => {
+        if (this._socket.destroyed) {
+          const err = new Error("The socket was closed while data was being compressed");
+          if (typeof cb === "function")
+            cb(err);
+          for (let i = 0;i < this._queue.length; i++) {
+            const callback = this._queue[i][4];
+            if (typeof callback === "function")
+              callback(err);
+          }
+          return;
+        }
+        this._bufferedBytes -= data.length;
+        this._deflating = false;
+        options.readOnly = false;
+        this.sendFrame(Sender.frame(buf, options), cb);
+        this.dequeue();
+      });
+    }
+    dequeue() {
+      while (!this._deflating && this._queue.length) {
+        const params = this._queue.shift();
+        this._bufferedBytes -= params[1].length;
+        Reflect.apply(params[0], this, params.slice(1));
+      }
+    }
+    enqueue(params) {
+      this._bufferedBytes += params[1].length;
+      this._queue.push(params);
+    }
+    sendFrame(list, cb) {
+      if (list.length === 2) {
+        this._socket.cork();
+        this._socket.write(list[0]);
+        this._socket.write(list[1], cb);
+        this._socket.uncork();
+      } else {
+        this._socket.write(list[0], cb);
+      }
+    }
+  }
+  module.exports = Sender;
+});
+
+// ../../../node_modules/ws/lib/event-target.js
+var require_event_target2 = __commonJS((exports, module) => {
+  class Event2 {
+    constructor(type, target) {
+      this.target = target;
+      this.type = type;
+    }
+  }
+
+  class MessageEvent extends Event2 {
+    constructor(data, target) {
+      super("message", target);
+      this.data = data;
+    }
+  }
+
+  class CloseEvent extends Event2 {
+    constructor(code, reason, target) {
+      super("close", target);
+      this.wasClean = target._closeFrameReceived && target._closeFrameSent;
+      this.reason = reason;
+      this.code = code;
+    }
+  }
+
+  class OpenEvent extends Event2 {
+    constructor(target) {
+      super("open", target);
+    }
+  }
+
+  class ErrorEvent extends Event2 {
+    constructor(error, target) {
+      super("error", target);
+      this.message = error.message;
+      this.error = error;
+    }
+  }
+  var EventTarget2 = {
+    addEventListener(type, listener, options) {
+      if (typeof listener !== "function")
+        return;
+      function onMessage(data) {
+        listener.call(this, new MessageEvent(data, this));
+      }
+      function onClose(code, message) {
+        listener.call(this, new CloseEvent(code, message, this));
+      }
+      function onError(error) {
+        listener.call(this, new ErrorEvent(error, this));
+      }
+      function onOpen() {
+        listener.call(this, new OpenEvent(this));
+      }
+      const method = options && options.once ? "once" : "on";
+      if (type === "message") {
+        onMessage._listener = listener;
+        this[method](type, onMessage);
+      } else if (type === "close") {
+        onClose._listener = listener;
+        this[method](type, onClose);
+      } else if (type === "error") {
+        onError._listener = listener;
+        this[method](type, onError);
+      } else if (type === "open") {
+        onOpen._listener = listener;
+        this[method](type, onOpen);
+      } else {
+        this[method](type, listener);
+      }
+    },
+    removeEventListener(type, listener) {
+      const listeners = this.listeners(type);
+      for (let i = 0;i < listeners.length; i++) {
+        if (listeners[i] === listener || listeners[i]._listener === listener) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+    }
+  };
+  module.exports = EventTarget2;
+});
+
+// ../../../node_modules/ws/lib/extension.js
+var require_extension2 = __commonJS((exports, module) => {
+  var tokenChars = [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    1,
+    0,
+    1,
+    0
+  ];
+  function push(dest, name, elem) {
+    if (dest[name] === undefined)
+      dest[name] = [elem];
+    else
+      dest[name].push(elem);
+  }
+  function parse2(header) {
+    const offers = Object.create(null);
+    if (header === undefined || header === "")
+      return offers;
+    let params = Object.create(null);
+    let mustUnescape = false;
+    let isEscaping = false;
+    let inQuotes = false;
+    let extensionName;
+    let paramName;
+    let start = -1;
+    let end = -1;
+    let i = 0;
+    for (;i < header.length; i++) {
+      const code = header.charCodeAt(i);
+      if (extensionName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (code === 32 || code === 9) {
+          if (end === -1 && start !== -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          const name = header.slice(start, end);
+          if (code === 44) {
+            push(offers, name, params);
+            params = Object.create(null);
+          } else {
+            extensionName = name;
+          }
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (paramName === undefined) {
+        if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (code === 32 || code === 9) {
+          if (end === -1 && start !== -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          push(params, header.slice(start, end), true);
+          if (code === 44) {
+            push(offers, extensionName, params);
+            params = Object.create(null);
+            extensionName = undefined;
+          }
+          start = end = -1;
+        } else if (code === 61 && start !== -1 && end === -1) {
+          paramName = header.slice(start, i);
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else {
+        if (isEscaping) {
+          if (tokenChars[code] !== 1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (start === -1)
+            start = i;
+          else if (!mustUnescape)
+            mustUnescape = true;
+          isEscaping = false;
+        } else if (inQuotes) {
+          if (tokenChars[code] === 1) {
+            if (start === -1)
+              start = i;
+          } else if (code === 34 && start !== -1) {
+            inQuotes = false;
+            end = i;
+          } else if (code === 92) {
+            isEscaping = true;
+          } else {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+        } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
+          inQuotes = true;
+        } else if (end === -1 && tokenChars[code] === 1) {
+          if (start === -1)
+            start = i;
+        } else if (start !== -1 && (code === 32 || code === 9)) {
+          if (end === -1)
+            end = i;
+        } else if (code === 59 || code === 44) {
+          if (start === -1) {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+          }
+          if (end === -1)
+            end = i;
+          let value = header.slice(start, end);
+          if (mustUnescape) {
+            value = value.replace(/\\/g, "");
+            mustUnescape = false;
+          }
+          push(params, paramName, value);
+          if (code === 44) {
+            push(offers, extensionName, params);
+            params = Object.create(null);
+            extensionName = undefined;
+          }
+          paramName = undefined;
+          start = end = -1;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      }
+    }
+    if (start === -1 || inQuotes) {
+      throw new SyntaxError("Unexpected end of input");
+    }
+    if (end === -1)
+      end = i;
+    const token = header.slice(start, end);
+    if (extensionName === undefined) {
+      push(offers, token, params);
+    } else {
+      if (paramName === undefined) {
+        push(params, token, true);
+      } else if (mustUnescape) {
+        push(params, paramName, token.replace(/\\/g, ""));
+      } else {
+        push(params, paramName, token);
+      }
+      push(offers, extensionName, params);
+    }
+    return offers;
+  }
+  function format(extensions) {
+    return Object.keys(extensions).map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations))
+        configurations = [configurations];
+      return configurations.map((params) => {
+        return [extension].concat(Object.keys(params).map((k) => {
+          let values = params[k];
+          if (!Array.isArray(values))
+            values = [values];
+          return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
+        })).join("; ");
+      }).join(", ");
+    }).join(", ");
+  }
+  module.exports = { format, parse: parse2 };
+});
+
+// ../../../node_modules/ws/lib/websocket.js
+var require_websocket2 = __commonJS((exports, module) => {
+  var EventEmitter = __require("events");
+  var https = __require("https");
+  var http2 = __require("http");
+  var net = __require("net");
+  var tls = __require("tls");
+  var { randomBytes: randomBytes8, createHash: createHash14 } = __require("crypto");
+  var { Readable } = __require("stream");
+  var { URL: URL2 } = __require("url");
+  var PerMessageDeflate = require_permessage_deflate2();
+  var Receiver = require_receiver2();
+  var Sender = require_sender2();
+  var {
+    BINARY_TYPES,
+    EMPTY_BUFFER,
+    GUID,
+    kStatusCode,
+    kWebSocket,
+    NOOP
+  } = require_constants8();
+  var { addEventListener, removeEventListener } = require_event_target2();
+  var { format, parse: parse2 } = require_extension2();
+  var { toBuffer } = require_buffer_util2();
+  var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+  var protocolVersions = [8, 13];
+  var closeTimeout = 30 * 1000;
+
+  class WebSocket2 extends EventEmitter {
+    constructor(address, protocols, options) {
+      super();
+      this._binaryType = BINARY_TYPES[0];
+      this._closeCode = 1006;
+      this._closeFrameReceived = false;
+      this._closeFrameSent = false;
+      this._closeMessage = "";
+      this._closeTimer = null;
+      this._extensions = {};
+      this._protocol = "";
+      this._readyState = WebSocket2.CONNECTING;
+      this._receiver = null;
+      this._sender = null;
+      this._socket = null;
+      if (address !== null) {
+        this._bufferedAmount = 0;
+        this._isServer = false;
+        this._redirects = 0;
+        if (Array.isArray(protocols)) {
+          protocols = protocols.join(", ");
+        } else if (typeof protocols === "object" && protocols !== null) {
+          options = protocols;
+          protocols = undefined;
+        }
+        initAsClient(this, address, protocols, options);
+      } else {
+        this._isServer = true;
+      }
+    }
+    get binaryType() {
+      return this._binaryType;
+    }
+    set binaryType(type) {
+      if (!BINARY_TYPES.includes(type))
+        return;
+      this._binaryType = type;
+      if (this._receiver)
+        this._receiver._binaryType = type;
+    }
+    get bufferedAmount() {
+      if (!this._socket)
+        return this._bufferedAmount;
+      return this._socket._writableState.length + this._sender._bufferedBytes;
+    }
+    get extensions() {
+      return Object.keys(this._extensions).join();
+    }
+    get onclose() {
+      return;
+    }
+    set onclose(listener) {}
+    get onerror() {
+      return;
+    }
+    set onerror(listener) {}
+    get onopen() {
+      return;
+    }
+    set onopen(listener) {}
+    get onmessage() {
+      return;
+    }
+    set onmessage(listener) {}
+    get protocol() {
+      return this._protocol;
+    }
+    get readyState() {
+      return this._readyState;
+    }
+    get url() {
+      return this._url;
+    }
+    setSocket(socket, head, maxPayload, maxBufferedChunks, maxFragments) {
+      const receiver = new Receiver(this.binaryType, this._extensions, this._isServer, maxPayload, maxBufferedChunks, maxFragments);
+      this._sender = new Sender(socket, this._extensions);
+      this._receiver = receiver;
+      this._socket = socket;
+      receiver[kWebSocket] = this;
+      socket[kWebSocket] = this;
+      receiver.on("conclude", receiverOnConclude);
+      receiver.on("drain", receiverOnDrain);
+      receiver.on("error", receiverOnError);
+      receiver.on("message", receiverOnMessage);
+      receiver.on("ping", receiverOnPing);
+      receiver.on("pong", receiverOnPong);
+      socket.setTimeout(0);
+      socket.setNoDelay();
+      if (head.length > 0)
+        socket.unshift(head);
+      socket.on("close", socketOnClose);
+      socket.on("data", socketOnData);
+      socket.on("end", socketOnEnd);
+      socket.on("error", socketOnError);
+      this._readyState = WebSocket2.OPEN;
+      this.emit("open");
+    }
+    emitClose() {
+      if (!this._socket) {
+        this._readyState = WebSocket2.CLOSED;
+        this.emit("close", this._closeCode, this._closeMessage);
+        return;
+      }
+      if (this._extensions[PerMessageDeflate.extensionName]) {
+        this._extensions[PerMessageDeflate.extensionName].cleanup();
+      }
+      this._receiver.removeAllListeners();
+      this._readyState = WebSocket2.CLOSED;
+      this.emit("close", this._closeCode, this._closeMessage);
+    }
+    close(code, data) {
+      if (this.readyState === WebSocket2.CLOSED)
+        return;
+      if (this.readyState === WebSocket2.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        return abortHandshake(this, this._req, msg);
+      }
+      if (this.readyState === WebSocket2.CLOSING) {
+        if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+          this._socket.end();
+        }
+        return;
+      }
+      this._readyState = WebSocket2.CLOSING;
+      this._sender.close(code, data, !this._isServer, (err) => {
+        if (err)
+          return;
+        this._closeFrameSent = true;
+        if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
+          this._socket.end();
+        }
+      });
+      this._closeTimer = setTimeout(this._socket.destroy.bind(this._socket), closeTimeout);
+    }
+    ping(data, mask, cb) {
+      if (this.readyState === WebSocket2.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket2.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+    }
+    pong(data, mask, cb) {
+      if (this.readyState === WebSocket2.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof data === "function") {
+        cb = data;
+        data = mask = undefined;
+      } else if (typeof mask === "function") {
+        cb = mask;
+        mask = undefined;
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket2.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      if (mask === undefined)
+        mask = !this._isServer;
+      this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+    }
+    send(data, options, cb) {
+      if (this.readyState === WebSocket2.CONNECTING) {
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      }
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (typeof data === "number")
+        data = data.toString();
+      if (this.readyState !== WebSocket2.OPEN) {
+        sendAfterClose(this, data, cb);
+        return;
+      }
+      const opts = {
+        binary: typeof data !== "string",
+        mask: !this._isServer,
+        compress: true,
+        fin: true,
+        ...options
+      };
+      if (!this._extensions[PerMessageDeflate.extensionName]) {
+        opts.compress = false;
+      }
+      this._sender.send(data || EMPTY_BUFFER, opts, cb);
+    }
+    terminate() {
+      if (this.readyState === WebSocket2.CLOSED)
+        return;
+      if (this.readyState === WebSocket2.CONNECTING) {
+        const msg = "WebSocket was closed before the connection was established";
+        return abortHandshake(this, this._req, msg);
+      }
+      if (this._socket) {
+        this._readyState = WebSocket2.CLOSING;
+        this._socket.destroy();
+      }
+    }
+  }
+  Object.defineProperty(WebSocket2, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
+    enumerable: true,
+    value: readyStates.indexOf("CONNECTING")
+  });
+  Object.defineProperty(WebSocket2, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket2.prototype, "OPEN", {
+    enumerable: true,
+    value: readyStates.indexOf("OPEN")
+  });
+  Object.defineProperty(WebSocket2, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CLOSING", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSING")
+  });
+  Object.defineProperty(WebSocket2, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  Object.defineProperty(WebSocket2.prototype, "CLOSED", {
+    enumerable: true,
+    value: readyStates.indexOf("CLOSED")
+  });
+  [
+    "binaryType",
+    "bufferedAmount",
+    "extensions",
+    "protocol",
+    "readyState",
+    "url"
+  ].forEach((property) => {
+    Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
+  });
+  ["open", "error", "close", "message"].forEach((method) => {
+    Object.defineProperty(WebSocket2.prototype, `on${method}`, {
+      enumerable: true,
+      get() {
+        const listeners = this.listeners(method);
+        for (let i = 0;i < listeners.length; i++) {
+          if (listeners[i]._listener)
+            return listeners[i]._listener;
+        }
+        return;
+      },
+      set(listener) {
+        const listeners = this.listeners(method);
+        for (let i = 0;i < listeners.length; i++) {
+          if (listeners[i]._listener)
+            this.removeListener(method, listeners[i]);
+        }
+        this.addEventListener(method, listener);
+      }
+    });
+  });
+  WebSocket2.prototype.addEventListener = addEventListener;
+  WebSocket2.prototype.removeEventListener = removeEventListener;
+  module.exports = WebSocket2;
+  function initAsClient(websocket, address, protocols, options) {
+    const opts = {
+      protocolVersion: protocolVersions[1],
+      maxBufferedChunks: 1024 * 1024,
+      maxFragments: 128 * 1024,
+      maxPayload: 100 * 1024 * 1024,
+      perMessageDeflate: true,
+      followRedirects: false,
+      maxRedirects: 10,
+      ...options,
+      createConnection: undefined,
+      socketPath: undefined,
+      hostname: undefined,
+      protocol: undefined,
+      timeout: undefined,
+      method: undefined,
+      host: undefined,
+      path: undefined,
+      port: undefined
+    };
+    if (!protocolVersions.includes(opts.protocolVersion)) {
+      throw new RangeError(`Unsupported protocol version: ${opts.protocolVersion} ` + `(supported versions: ${protocolVersions.join(", ")})`);
+    }
+    let parsedUrl;
+    if (address instanceof URL2) {
+      parsedUrl = address;
+      websocket._url = address.href;
+    } else {
+      parsedUrl = new URL2(address);
+      websocket._url = address;
+    }
+    const isUnixSocket = parsedUrl.protocol === "ws+unix:";
+    if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
+      const err = new Error(`Invalid URL: ${websocket.url}`);
+      if (websocket._redirects === 0) {
+        throw err;
+      } else {
+        emitErrorAndClose(websocket, err);
+        return;
+      }
+    }
+    const isSecure = parsedUrl.protocol === "wss:" || parsedUrl.protocol === "https:";
+    const defaultPort = isSecure ? 443 : 80;
+    const key = randomBytes8(16).toString("base64");
+    const get = isSecure ? https.get : http2.get;
+    let perMessageDeflate;
+    opts.createConnection = isSecure ? tlsConnect : netConnect;
+    opts.defaultPort = opts.defaultPort || defaultPort;
+    opts.port = parsedUrl.port || defaultPort;
+    opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+    opts.headers = {
+      "Sec-WebSocket-Version": opts.protocolVersion,
+      "Sec-WebSocket-Key": key,
+      Connection: "Upgrade",
+      Upgrade: "websocket",
+      ...opts.headers
+    };
+    opts.path = parsedUrl.pathname + parsedUrl.search;
+    opts.timeout = opts.handshakeTimeout;
+    if (opts.perMessageDeflate) {
+      perMessageDeflate = new PerMessageDeflate(opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, false, opts.maxPayload);
+      opts.headers["Sec-WebSocket-Extensions"] = format({
+        [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+      });
+    }
+    if (protocols) {
+      opts.headers["Sec-WebSocket-Protocol"] = protocols;
+    }
+    if (opts.origin) {
+      if (opts.protocolVersion < 13) {
+        opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+      } else {
+        opts.headers.Origin = opts.origin;
+      }
+    }
+    if (parsedUrl.username || parsedUrl.password) {
+      opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+    }
+    if (isUnixSocket) {
+      const parts = opts.path.split(":");
+      opts.socketPath = parts[0];
+      opts.path = parts[1];
+    }
+    if (opts.followRedirects) {
+      if (websocket._redirects === 0) {
+        websocket._originalUnixSocket = isUnixSocket;
+        websocket._originalSecure = isSecure;
+        websocket._originalHostOrSocketPath = isUnixSocket ? opts.socketPath : parsedUrl.host;
+        const headers = options && options.headers;
+        options = { ...options, headers: {} };
+        if (headers) {
+          for (const [key2, value] of Object.entries(headers)) {
+            options.headers[key2.toLowerCase()] = value;
+          }
+        }
+      } else {
+        const isSameHost = isUnixSocket ? websocket._originalUnixSocket ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalUnixSocket ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
+        if (!isSameHost || websocket._originalSecure && !isSecure) {
+          delete opts.headers.authorization;
+          delete opts.headers.cookie;
+          if (!isSameHost)
+            delete opts.headers.host;
+          opts.auth = undefined;
+        }
+      }
+      if (opts.auth && !options.headers.authorization) {
+        options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
+      }
+    }
+    let req = websocket._req = get(opts);
+    if (opts.timeout) {
+      req.on("timeout", () => {
+        abortHandshake(websocket, req, "Opening handshake has timed out");
+      });
+    }
+    req.on("error", (err) => {
+      if (req === null || req.aborted)
+        return;
+      req = websocket._req = null;
+      emitErrorAndClose(websocket, err);
+    });
+    req.on("response", (res) => {
+      const location = res.headers.location;
+      const statusCode = res.statusCode;
+      if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+        if (++websocket._redirects > opts.maxRedirects) {
+          abortHandshake(websocket, req, "Maximum redirects exceeded");
+          return;
+        }
+        req.abort();
+        let addr;
+        try {
+          addr = new URL2(location, address);
+        } catch (err) {
+          emitErrorAndClose(websocket, err);
+          return;
+        }
+        initAsClient(websocket, addr, protocols, options);
+      } else if (!websocket.emit("unexpected-response", req, res)) {
+        abortHandshake(websocket, req, `Unexpected server response: ${res.statusCode}`);
+      }
+    });
+    req.on("upgrade", (res, socket, head) => {
+      websocket.emit("upgrade", res);
+      if (websocket.readyState !== WebSocket2.CONNECTING)
+        return;
+      req = websocket._req = null;
+      const upgrade = res.headers.upgrade;
+      if (upgrade === undefined || upgrade.toLowerCase() !== "websocket") {
+        abortHandshake(websocket, socket, "Invalid Upgrade header");
+        return;
+      }
+      const digest = createHash14("sha1").update(key + GUID).digest("base64");
+      if (res.headers["sec-websocket-accept"] !== digest) {
+        abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
+        return;
+      }
+      const serverProt = res.headers["sec-websocket-protocol"];
+      const protList = (protocols || "").split(/, */);
+      let protError;
+      if (!protocols && serverProt) {
+        protError = "Server sent a subprotocol but none was requested";
+      } else if (protocols && !serverProt) {
+        protError = "Server sent no subprotocol";
+      } else if (serverProt && !protList.includes(serverProt)) {
+        protError = "Server sent an invalid subprotocol";
+      }
+      if (protError) {
+        abortHandshake(websocket, socket, protError);
+        return;
+      }
+      if (serverProt)
+        websocket._protocol = serverProt;
+      const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+      if (secWebSocketExtensions !== undefined) {
+        if (!perMessageDeflate) {
+          const message = "Server sent a Sec-WebSocket-Extensions header but no extension " + "was requested";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        let extensions;
+        try {
+          extensions = parse2(secWebSocketExtensions);
+        } catch (err) {
+          const message = "Invalid Sec-WebSocket-Extensions header";
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+        const extensionNames = Object.keys(extensions);
+        if (extensionNames.length) {
+          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+            const message = "Server indicated an extension that was not requested";
+            abortHandshake(websocket, socket, message);
+            return;
+          }
+          try {
+            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+          } catch (err) {
+            const message = "Invalid Sec-WebSocket-Extensions header";
+            abortHandshake(websocket, socket, message);
+            return;
+          }
+          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      }
+      websocket.setSocket(socket, head, opts.maxPayload, opts.maxBufferedChunks, opts.maxFragments);
+    });
+  }
+  function emitErrorAndClose(websocket, err) {
+    websocket._readyState = WebSocket2.CLOSING;
+    websocket.emit("error", err);
+    websocket.emitClose();
+  }
+  function netConnect(options) {
+    options.path = options.socketPath;
+    return net.connect(options);
+  }
+  function tlsConnect(options) {
+    options.path = undefined;
+    if (!options.servername && options.servername !== "") {
+      options.servername = net.isIP(options.host) ? "" : options.host;
+    }
+    return tls.connect(options);
+  }
+  function abortHandshake(websocket, stream, message) {
+    websocket._readyState = WebSocket2.CLOSING;
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshake);
+    if (stream.setHeader) {
+      stream.abort();
+      if (stream.socket && !stream.socket.destroyed) {
+        stream.socket.destroy();
+      }
+      stream.once("abort", websocket.emitClose.bind(websocket));
+      websocket.emit("error", err);
+    } else {
+      stream.destroy(err);
+      stream.once("error", websocket.emit.bind(websocket, "error"));
+      stream.once("close", websocket.emitClose.bind(websocket));
+    }
+  }
+  function sendAfterClose(websocket, data, cb) {
+    if (data) {
+      const length = toBuffer(data).length;
+      if (websocket._socket)
+        websocket._sender._bufferedBytes += length;
+      else
+        websocket._bufferedAmount += length;
+    }
+    if (cb) {
+      const err = new Error(`WebSocket is not open: readyState ${websocket.readyState} ` + `(${readyStates[websocket.readyState]})`);
+      cb(err);
+    }
+  }
+  function receiverOnConclude(code, reason) {
+    const websocket = this[kWebSocket];
+    websocket._closeFrameReceived = true;
+    websocket._closeMessage = reason;
+    websocket._closeCode = code;
+    if (websocket._socket[kWebSocket] === undefined)
+      return;
+    websocket._socket.removeListener("data", socketOnData);
+    process.nextTick(resume, websocket._socket);
+    if (code === 1005)
+      websocket.close();
+    else
+      websocket.close(code, reason);
+  }
+  function receiverOnDrain() {
+    this[kWebSocket]._socket.resume();
+  }
+  function receiverOnError(err) {
+    const websocket = this[kWebSocket];
+    if (websocket._socket[kWebSocket] !== undefined) {
+      websocket._socket.removeListener("data", socketOnData);
+      process.nextTick(resume, websocket._socket);
+      websocket.close(err[kStatusCode]);
+    }
+    websocket.emit("error", err);
+  }
+  function receiverOnFinish() {
+    this[kWebSocket].emitClose();
+  }
+  function receiverOnMessage(data) {
+    this[kWebSocket].emit("message", data);
+  }
+  function receiverOnPing(data) {
+    const websocket = this[kWebSocket];
+    websocket.pong(data, !websocket._isServer, NOOP);
+    websocket.emit("ping", data);
+  }
+  function receiverOnPong(data) {
+    this[kWebSocket].emit("pong", data);
+  }
+  function resume(stream) {
+    stream.resume();
+  }
+  function socketOnClose() {
+    const websocket = this[kWebSocket];
+    this.removeListener("close", socketOnClose);
+    this.removeListener("data", socketOnData);
+    this.removeListener("end", socketOnEnd);
+    websocket._readyState = WebSocket2.CLOSING;
+    let chunk;
+    if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
+      websocket._receiver.write(chunk);
+    }
+    websocket._receiver.end();
+    this[kWebSocket] = undefined;
+    clearTimeout(websocket._closeTimer);
+    if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
+      websocket.emitClose();
+    } else {
+      websocket._receiver.on("error", receiverOnFinish);
+      websocket._receiver.on("finish", receiverOnFinish);
     }
-    fn[Symbol.for("skip-override")] = options.encapsulate !== true;
-    fn[Symbol.for("fastify.display-name")] = options.name;
-    fn[Symbol.for("plugin-meta")] = options;
-    if (!fn.default) {
-      fn.default = fn;
+  }
+  function socketOnData(chunk) {
+    if (!this[kWebSocket]._receiver.write(chunk)) {
+      this.pause();
     }
-    const camelCase = toCamelCase(options.name);
-    if (!autoName && !fn[camelCase]) {
-      fn[camelCase] = fn;
+  }
+  function socketOnEnd() {
+    const websocket = this[kWebSocket];
+    websocket._readyState = WebSocket2.CLOSING;
+    websocket._receiver.end();
+    this.end();
+  }
+  function socketOnError() {
+    const websocket = this[kWebSocket];
+    this.removeListener("error", socketOnError);
+    this.on("error", NOOP);
+    if (websocket) {
+      websocket._readyState = WebSocket2.CLOSING;
+      this.destroy();
     }
-    return fn;
   }
-  module.exports = plugin;
-  module.exports.default = plugin;
-  module.exports.fastifyPlugin = plugin;
 });
 
-// node_modules/.bun/@fastify+cors@11.2.0/node_modules/@fastify/cors/vary.js
-var require_vary = __commonJS((exports, module) => {
-  var { FifoMap: FifoCache } = require_toad_cache();
-  var validFieldnameRE = /^[!#$%&'*+\-.^\w`|~]+$/u;
-  function validateFieldname(fieldname) {
-    if (validFieldnameRE.test(fieldname) === false) {
-      throw new TypeError("Fieldname contains invalid characters.");
+// ../../../node_modules/ws/lib/stream.js
+var require_stream2 = __commonJS((exports, module) => {
+  var { Duplex } = __require("stream");
+  function emitClose(stream) {
+    stream.emit("close");
+  }
+  function duplexOnEnd() {
+    if (!this.destroyed && this._writableState.finished) {
+      this.destroy();
     }
   }
-  function parse2(header) {
-    header = header.trim().toLowerCase();
-    const result = [];
-    if (header.length === 0) {} else if (header.indexOf(",") === -1) {
-      result.push(header);
-    } else {
-      const il = header.length;
-      let i = 0;
-      let pos = 0;
-      let char;
-      for (i;i < il; ++i) {
-        char = header[i];
-        if (char === " ") {
-          pos = i + 1;
-        } else if (char === ",") {
-          if (pos !== i) {
-            result.push(header.slice(pos, i));
-          }
-          pos = i + 1;
-        }
-      }
-      if (pos !== i) {
-        result.push(header.slice(pos, i));
-      }
+  function duplexOnError(err) {
+    this.removeListener("error", duplexOnError);
+    this.destroy();
+    if (this.listenerCount("error") === 0) {
+      this.emit("error", err);
     }
-    return result;
   }
-  function createAddFieldnameToVary(fieldname) {
-    const headerCache = new FifoCache(1000);
-    validateFieldname(fieldname);
-    return function(reply) {
-      let header = reply.getHeader("Vary");
-      if (!header) {
-        reply.header("Vary", fieldname);
-        return;
+  function createWebSocketStream(ws, options) {
+    let resumeOnReceiverDrain = true;
+    let terminateOnDestroy = true;
+    function receiverOnDrain() {
+      if (resumeOnReceiverDrain)
+        ws._socket.resume();
+    }
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once("open", function open() {
+        ws._receiver.removeAllListeners("drain");
+        ws._receiver.on("drain", receiverOnDrain);
+      });
+    } else {
+      ws._receiver.removeAllListeners("drain");
+      ws._receiver.on("drain", receiverOnDrain);
+    }
+    const duplex = new Duplex({
+      ...options,
+      autoDestroy: false,
+      emitClose: false,
+      objectMode: false,
+      writableObjectMode: false
+    });
+    ws.on("message", function message(msg) {
+      if (!duplex.push(msg)) {
+        resumeOnReceiverDrain = false;
+        ws._socket.pause();
       }
-      if (header === "*") {
+    });
+    ws.once("error", function error(err) {
+      if (duplex.destroyed)
+        return;
+      terminateOnDestroy = false;
+      duplex.destroy(err);
+    });
+    ws.once("close", function close() {
+      if (duplex.destroyed)
+        return;
+      duplex.push(null);
+    });
+    duplex._destroy = function(err, callback) {
+      if (ws.readyState === ws.CLOSED) {
+        callback(err);
+        process.nextTick(emitClose, duplex);
         return;
       }
-      if (fieldname === "*") {
-        reply.header("Vary", "*");
+      let called = false;
+      ws.once("error", function error(err2) {
+        called = true;
+        callback(err2);
+      });
+      ws.once("close", function close() {
+        if (!called)
+          callback(err);
+        process.nextTick(emitClose, duplex);
+      });
+      if (terminateOnDestroy)
+        ws.terminate();
+    };
+    duplex._final = function(callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._final(callback);
+        });
         return;
       }
-      if (Array.isArray(header)) {
-        header = header.join(", ");
+      if (ws._socket === null)
+        return;
+      if (ws._socket._writableState.finished) {
+        callback();
+        if (duplex._readableState.endEmitted)
+          duplex.destroy();
+      } else {
+        ws._socket.once("finish", function finish() {
+          callback();
+        });
+        ws.close();
       }
-      if (headerCache.get(header) === undefined) {
-        const vals = parse2(header);
-        if (vals.indexOf("*") !== -1) {
-          headerCache.set(header, "*");
-        } else if (vals.indexOf(fieldname.toLowerCase()) === -1) {
-          headerCache.set(header, header + ", " + fieldname);
-        } else {
-          headerCache.set(header, null);
-        }
+    };
+    duplex._read = function() {
+      if ((ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) && !resumeOnReceiverDrain) {
+        resumeOnReceiverDrain = true;
+        if (!ws._receiver._writableState.needDrain)
+          ws._socket.resume();
       }
-      const cached3 = headerCache.get(header);
-      if (cached3 !== null) {
-        reply.header("Vary", cached3);
+    };
+    duplex._write = function(chunk, encoding, callback) {
+      if (ws.readyState === ws.CONNECTING) {
+        ws.once("open", function open() {
+          duplex._write(chunk, encoding, callback);
+        });
+        return;
       }
+      ws.send(chunk, callback);
     };
+    duplex.on("end", duplexOnEnd);
+    duplex.on("error", duplexOnError);
+    return duplex;
   }
-  exports.createAddFieldnameToVary = createAddFieldnameToVary;
-  exports.addOriginToVaryHeader = createAddFieldnameToVary("Origin");
-  exports.addAccessControlRequestHeadersToVaryHeader = createAddFieldnameToVary("Access-Control-Request-Headers");
-  exports.parse = parse2;
+  module.exports = createWebSocketStream;
 });
 
-// node_modules/.bun/@fastify+cors@11.2.0/node_modules/@fastify/cors/index.js
-var require_cors = __commonJS((exports, module) => {
-  var fp = require_plugin2();
-  var {
-    addAccessControlRequestHeadersToVaryHeader,
-    addOriginToVaryHeader
-  } = require_vary();
-  var defaultOptions = {
-    origin: "*",
-    methods: "GET,HEAD,POST",
-    hook: "onRequest",
-    preflightContinue: false,
-    optionsSuccessStatus: 204,
-    credentials: false,
-    exposedHeaders: null,
-    allowedHeaders: null,
-    maxAge: null,
-    preflight: true,
-    strictPreflight: true
-  };
-  var validHooks = [
-    "onRequest",
-    "preParsing",
-    "preValidation",
-    "preHandler",
-    "preSerialization",
-    "onSend"
-  ];
-  var hookWithPayload = [
-    "preSerialization",
-    "preParsing",
-    "onSend"
-  ];
-  function validateHook(value, next) {
-    if (validHooks.indexOf(value) !== -1) {
-      return;
-    }
-    next(new TypeError("@fastify/cors: Invalid hook option provided."));
-  }
-  function fastifyCors(fastify, opts, next) {
-    fastify.decorateRequest("corsPreflightEnabled", false);
-    let hideOptionsRoute = true;
-    let logLevel;
-    if (typeof opts === "function") {
-      handleCorsOptionsDelegator(opts, fastify, { hook: defaultOptions.hook }, next);
-    } else if (opts.delegator) {
-      const { delegator, ...options } = opts;
-      handleCorsOptionsDelegator(delegator, fastify, options, next);
-    } else {
-      const corsOptions = normalizeCorsOptions(opts);
-      validateHook(corsOptions.hook, next);
-      if (hookWithPayload.indexOf(corsOptions.hook) !== -1) {
-        fastify.addHook(corsOptions.hook, function handleCors(req, reply, _payload, next2) {
-          addCorsHeadersHandler(fastify, corsOptions, req, reply, next2);
-        });
-      } else {
-        fastify.addHook(corsOptions.hook, function handleCors(req, reply, next2) {
-          addCorsHeadersHandler(fastify, corsOptions, req, reply, next2);
-        });
-      }
-    }
-    if (opts.logLevel !== undefined)
-      logLevel = opts.logLevel;
-    if (opts.hideOptionsRoute !== undefined)
-      hideOptionsRoute = opts.hideOptionsRoute;
-    fastify.options("*", { schema: { hide: hideOptionsRoute }, logLevel }, (req, reply) => {
-      if (!req.corsPreflightEnabled) {
-        reply.callNotFound();
-        return;
+// ../../../node_modules/ws/lib/websocket-server.js
+var require_websocket_server2 = __commonJS((exports, module) => {
+  var EventEmitter = __require("events");
+  var http2 = __require("http");
+  var https = __require("https");
+  var net = __require("net");
+  var tls = __require("tls");
+  var { createHash: createHash14 } = __require("crypto");
+  var PerMessageDeflate = require_permessage_deflate2();
+  var WebSocket2 = require_websocket2();
+  var { format, parse: parse2 } = require_extension2();
+  var { GUID, kWebSocket } = require_constants8();
+  var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+  var RUNNING = 0;
+  var CLOSING = 1;
+  var CLOSED = 2;
+
+  class WebSocketServer extends EventEmitter {
+    constructor(options, callback) {
+      super();
+      options = {
+        maxBufferedChunks: 1024 * 1024,
+        maxFragments: 128 * 1024,
+        maxPayload: 100 * 1024 * 1024,
+        perMessageDeflate: false,
+        handleProtocols: null,
+        clientTracking: true,
+        verifyClient: null,
+        noServer: false,
+        backlog: null,
+        server: null,
+        host: null,
+        path: null,
+        port: null,
+        ...options
+      };
+      if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
+        throw new TypeError('One and only one of the "port", "server", or "noServer" options ' + "must be specified");
       }
-      reply.send();
-    });
-    next();
-  }
-  function handleCorsOptionsDelegator(optionsResolver, fastify, opts, next) {
-    const hook = opts?.hook || defaultOptions.hook;
-    validateHook(hook, next);
-    if (optionsResolver.length === 2) {
-      if (hookWithPayload.indexOf(hook) !== -1) {
-        fastify.addHook(hook, function handleCors(req, reply, _payload, next2) {
-          handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next2);
-        });
-      } else {
-        fastify.addHook(hook, function handleCors(req, reply, next2) {
-          handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next2);
+      if (options.port != null) {
+        this._server = http2.createServer((req, res) => {
+          const body = http2.STATUS_CODES[426];
+          res.writeHead(426, {
+            "Content-Length": body.length,
+            "Content-Type": "text/plain"
+          });
+          res.end(body);
         });
+        this._server.listen(options.port, options.host, options.backlog, callback);
+      } else if (options.server) {
+        this._server = options.server;
       }
-    } else {
-      if (hookWithPayload.indexOf(hook) !== -1) {
-        fastify.addHook(hook, function handleCors(req, reply, _payload, next2) {
-          const ret = optionsResolver(req);
-          if (ret && typeof ret.then === "function") {
-            ret.then((options) => addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next2)).catch(next2);
-            return;
-          }
-          next2(new Error("Invalid CORS origin option"));
-        });
-      } else {
-        fastify.addHook(hook, function handleCors(req, reply, next2) {
-          const ret = optionsResolver(req);
-          if (ret && typeof ret.then === "function") {
-            ret.then((options) => addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next2)).catch(next2);
-            return;
+      if (this._server) {
+        const emitConnection = this.emit.bind(this, "connection");
+        this._removeListeners = addListeners(this._server, {
+          listening: this.emit.bind(this, "listening"),
+          error: this.emit.bind(this, "error"),
+          upgrade: (req, socket, head) => {
+            this.handleUpgrade(req, socket, head, emitConnection);
           }
-          next2(new Error("Invalid CORS origin option"));
         });
       }
+      if (options.perMessageDeflate === true)
+        options.perMessageDeflate = {};
+      if (options.clientTracking)
+        this.clients = new Set;
+      this.options = options;
+      this._state = RUNNING;
     }
-  }
-  function handleCorsOptionsCallbackDelegator(optionsResolver, fastify, req, reply, next) {
-    optionsResolver(req, (err, options) => {
-      if (err) {
-        next(err);
-      } else {
-        addCorsHeadersHandler(fastify, normalizeCorsOptions(options, true), req, reply, next);
+    address() {
+      if (this.options.noServer) {
+        throw new Error('The server is operating in "noServer" mode');
       }
-    });
-  }
-  function normalizeCorsOptions(opts, dynamic) {
-    const corsOptions = { ...defaultOptions, ...opts };
-    if (Array.isArray(opts.origin) && opts.origin.indexOf("*") !== -1) {
-      corsOptions.origin = "*";
-    }
-    if (Number.isInteger(corsOptions.cacheControl)) {
-      corsOptions.cacheControl = `max-age=${corsOptions.cacheControl}`;
-    } else if (typeof corsOptions.cacheControl !== "string") {
-      corsOptions.cacheControl = null;
-    }
-    corsOptions.dynamic = dynamic || false;
-    return corsOptions;
-  }
-  function addCorsHeadersHandler(fastify, globalOptions, req, reply, next) {
-    const options = { ...globalOptions, ...req.routeOptions.config?.cors };
-    if (typeof options.origin !== "string" && options.origin !== false || options.dynamic) {
-      addOriginToVaryHeader(reply);
+      if (!this._server)
+        return null;
+      return this._server.address();
     }
-    const resolveOriginOption = typeof options.origin === "function" ? resolveOriginWrapper(fastify, options.origin) : (_, cb) => cb(null, options.origin);
-    resolveOriginOption(req, (error, resolvedOriginOption) => {
-      if (error !== null) {
-        return next(error);
+    close(cb) {
+      if (cb)
+        this.once("close", cb);
+      if (this._state === CLOSED) {
+        process.nextTick(emitClose, this);
+        return;
       }
-      if (resolvedOriginOption === false) {
-        return next();
+      if (this._state === CLOSING)
+        return;
+      this._state = CLOSING;
+      if (this.clients) {
+        for (const client of this.clients)
+          client.terminate();
       }
-      if (req.routeOptions.config?.cors === false) {
-        return next();
+      const server = this._server;
+      if (server) {
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+        if (this.options.port != null) {
+          server.close(emitClose.bind(undefined, this));
+          return;
+        }
       }
-      if (!resolvedOriginOption) {
-        return next(new Error("Invalid CORS origin option"));
+      process.nextTick(emitClose, this);
+    }
+    shouldHandle(req) {
+      if (this.options.path) {
+        const index = req.url.indexOf("?");
+        const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+        if (pathname !== this.options.path)
+          return false;
       }
-      addCorsHeaders(req, reply, resolvedOriginOption, options);
-      if (req.raw.method === "OPTIONS" && options.preflight === true) {
-        if (options.strictPreflight === true && (!req.headers.origin || !req.headers["access-control-request-method"])) {
-          reply.status(400).type("text/plain").send("Invalid Preflight Request");
-          return;
+      return true;
+    }
+    handleUpgrade(req, socket, head, cb) {
+      socket.on("error", socketOnError);
+      const key = req.headers["sec-websocket-key"] !== undefined ? req.headers["sec-websocket-key"].trim() : false;
+      const upgrade = req.headers.upgrade;
+      const version2 = +req.headers["sec-websocket-version"];
+      const extensions = {};
+      if (req.method !== "GET" || upgrade === undefined || upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version2 !== 8 && version2 !== 13 || !this.shouldHandle(req)) {
+        return abortHandshake(socket, 400);
+      }
+      if (this.options.perMessageDeflate) {
+        const perMessageDeflate = new PerMessageDeflate(this.options.perMessageDeflate, true, this.options.maxPayload);
+        try {
+          const offers = parse2(req.headers["sec-websocket-extensions"]);
+          if (offers[PerMessageDeflate.extensionName]) {
+            perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+            extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+          }
+        } catch (err) {
+          return abortHandshake(socket, 400);
         }
-        req.corsPreflightEnabled = true;
-        addPreflightHeaders(req, reply, options);
-        if (!options.preflightContinue) {
-          reply.code(options.optionsSuccessStatus).header("Content-Length", "0").send();
+      }
+      if (this.options.verifyClient) {
+        const info = {
+          origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
+          secure: !!(req.socket.authorized || req.socket.encrypted),
+          req
+        };
+        if (this.options.verifyClient.length === 2) {
+          this.options.verifyClient(info, (verified, code, message, headers) => {
+            if (!verified) {
+              return abortHandshake(socket, code || 401, message, headers);
+            }
+            this.completeUpgrade(key, extensions, req, socket, head, cb);
+          });
           return;
         }
+        if (!this.options.verifyClient(info))
+          return abortHandshake(socket, 401);
       }
-      return next();
-    });
-  }
-  function addCorsHeaders(req, reply, originOption, corsOptions) {
-    const origin = getAccessControlAllowOriginHeader(req.headers.origin, originOption);
-    if (origin) {
-      reply.header("Access-Control-Allow-Origin", origin);
-    }
-    if (corsOptions.credentials) {
-      reply.header("Access-Control-Allow-Credentials", "true");
-    }
-    if (corsOptions.exposedHeaders !== null) {
-      reply.header("Access-Control-Expose-Headers", Array.isArray(corsOptions.exposedHeaders) ? corsOptions.exposedHeaders.join(", ") : corsOptions.exposedHeaders);
+      this.completeUpgrade(key, extensions, req, socket, head, cb);
     }
-  }
-  function addPreflightHeaders(req, reply, corsOptions) {
-    reply.header("Access-Control-Allow-Methods", Array.isArray(corsOptions.methods) ? corsOptions.methods.join(", ") : corsOptions.methods);
-    if (corsOptions.allowedHeaders === null) {
-      addAccessControlRequestHeadersToVaryHeader(reply);
-      const reqAllowedHeaders = req.headers["access-control-request-headers"];
-      if (reqAllowedHeaders !== undefined) {
-        reply.header("Access-Control-Allow-Headers", reqAllowedHeaders);
+    completeUpgrade(key, extensions, req, socket, head, cb) {
+      if (!socket.readable || !socket.writable)
+        return socket.destroy();
+      if (socket[kWebSocket]) {
+        throw new Error("server.handleUpgrade() was called more than once with the same " + "socket, possibly due to a misconfiguration");
       }
-    } else {
-      reply.header("Access-Control-Allow-Headers", Array.isArray(corsOptions.allowedHeaders) ? corsOptions.allowedHeaders.join(", ") : corsOptions.allowedHeaders);
-    }
-    if (corsOptions.maxAge !== null) {
-      reply.header("Access-Control-Max-Age", String(corsOptions.maxAge));
-    }
-    if (corsOptions.cacheControl) {
-      reply.header("Cache-Control", corsOptions.cacheControl);
+      if (this._state > RUNNING)
+        return abortHandshake(socket, 503);
+      const digest = createHash14("sha1").update(key + GUID).digest("base64");
+      const headers = [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${digest}`
+      ];
+      const ws = new WebSocket2(null);
+      let protocol = req.headers["sec-websocket-protocol"];
+      if (protocol) {
+        protocol = protocol.split(",").map(trim3);
+        if (this.options.handleProtocols) {
+          protocol = this.options.handleProtocols(protocol, req);
+        } else {
+          protocol = protocol[0];
+        }
+        if (protocol) {
+          headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+          ws._protocol = protocol;
+        }
+      }
+      if (extensions[PerMessageDeflate.extensionName]) {
+        const params = extensions[PerMessageDeflate.extensionName].params;
+        const value = format({
+          [PerMessageDeflate.extensionName]: [params]
+        });
+        headers.push(`Sec-WebSocket-Extensions: ${value}`);
+        ws._extensions = extensions;
+      }
+      this.emit("headers", headers, req);
+      socket.write(headers.concat(`\r
+`).join(`\r
+`));
+      socket.removeListener("error", socketOnError);
+      ws.setSocket(socket, head, this.options.maxPayload, this.options.maxBufferedChunks, this.options.maxFragments);
+      if (this.clients) {
+        this.clients.add(ws);
+        ws.on("close", () => this.clients.delete(ws));
+      }
+      cb(ws, req);
     }
   }
-  function resolveOriginWrapper(fastify, origin) {
-    return function(req, cb) {
-      const result = origin.call(fastify, req.headers.origin, cb);
-      if (result && typeof result.then === "function") {
-        result.then((res) => cb(null, res), cb);
+  module.exports = WebSocketServer;
+  function addListeners(server, map) {
+    for (const event of Object.keys(map))
+      server.on(event, map[event]);
+    return function removeListeners() {
+      for (const event of Object.keys(map)) {
+        server.removeListener(event, map[event]);
       }
     };
   }
-  function getAccessControlAllowOriginHeader(reqOrigin, originOption) {
-    if (typeof originOption === "string") {
-      return originOption;
-    }
-    return isRequestOriginAllowed(reqOrigin, originOption) ? reqOrigin : false;
-  }
-  function isRequestOriginAllowed(reqOrigin, allowedOrigin) {
-    if (Array.isArray(allowedOrigin)) {
-      for (let i = 0;i < allowedOrigin.length; ++i) {
-        if (isRequestOriginAllowed(reqOrigin, allowedOrigin[i])) {
-          return true;
-        }
-      }
-      return false;
-    } else if (typeof allowedOrigin === "string") {
-      return reqOrigin === allowedOrigin;
-    } else if (allowedOrigin instanceof RegExp) {
-      allowedOrigin.lastIndex = 0;
-      return allowedOrigin.test(reqOrigin);
-    } else {
-      return !!allowedOrigin;
-    }
+  function emitClose(server) {
+    server._state = CLOSED;
+    server.emit("close");
   }
-  var _fastifyCors = fp(fastifyCors, {
-    fastify: "5.x",
-    name: "@fastify/cors"
-  });
-  module.exports = _fastifyCors;
-  module.exports.fastifyCors = _fastifyCors;
-  module.exports.default = _fastifyCors;
-});
-
-// .tmp-runtime-src/ratelimit/index.ts
-async function registerRateLimiter(_app) {}
-var ROUTE_LIMITS;
-var init_ratelimit = __esm(() => {
-  ROUTE_LIMITS = {
-    "/v1/intent/resolve": { max: 20, timeWindow: "1 minute" },
-    "/v1/skills/:skill_id/execute": { max: 30, timeWindow: "1 minute" },
-    "/v1/skills": { max: 5, timeWindow: "1 minute" },
-    "/v1/auth/login": { max: 3, timeWindow: "5 minutes" },
-    "/v1/feedback": { max: 60, timeWindow: "1 minute" }
-  };
-});
-
-// .tmp-runtime-src/logger.ts
-import fs2 from "node:fs";
-import path5 from "node:path";
-function logDir() {
-  return path5.join(getUnbrowseHome2(), "logs");
-}
-function getLogFile() {
-  const date = new Date().toISOString().slice(0, 10);
-  return path5.join(logDir(), `unbrowse-${date}.log`);
-}
-function ensureLogDir() {
-  fs2.mkdirSync(logDir(), { recursive: true });
-}
-function log(module, message) {
-  const ts = new Date().toTimeString().slice(0, 8);
-  const line = `[${ts}] [${module}] ${message}`;
-  console.error(line);
-  try {
-    ensureLogDir();
-    fs2.appendFileSync(getLogFile(), line + `
-`);
-  } catch {}
-}
-function tsMs() {
-  const d = new Date;
-  const hh = String(d.getHours()).padStart(2, "0");
-  const mm = String(d.getMinutes()).padStart(2, "0");
-  const ss = String(d.getSeconds()).padStart(2, "0");
-  const ms = String(d.getMilliseconds()).padStart(3, "0");
-  return `${hh}:${mm}:${ss}.${ms}`;
-}
-function traceLine(message) {
-  const line = `[${tsMs()}] [trace] ${message}`;
-  console.log(line);
-  try {
-    ensureLogDir();
-    fs2.appendFileSync(getLogFile(), line + `
-`);
-  } catch {}
-}
-async function traceAsync(scope, sid, phase, fn) {
-  if (!TRACE_ENABLED)
-    return fn();
-  const sidShort = (sid ?? "-").slice(0, 8);
-  const tag = `sid=${sidShort} scope=${scope} phase=${phase}`;
-  const start = Date.now();
-  traceLine(`${tag} BEGIN`);
-  const heartbeat = setInterval(() => {
-    traceLine(`${tag} SLOW elapsed=${Date.now() - start}ms`);
-  }, TRACE_SLOW_MS);
-  heartbeat.unref?.();
-  try {
-    const result = await fn();
-    clearInterval(heartbeat);
-    traceLine(`${tag} END dur=${Date.now() - start}ms`);
-    return result;
-  } catch (err) {
-    clearInterval(heartbeat);
-    const msg = err instanceof Error ? err.message : String(err);
-    traceLine(`${tag} THREW dur=${Date.now() - start}ms err=${msg}`);
-    throw err;
+  function socketOnError() {
+    this.destroy();
   }
-}
-var TRACE_ENABLED, TRACE_SLOW_MS;
-var init_logger = __esm(() => {
-  init_paths();
-  TRACE_ENABLED = (() => {
-    const v = process.env.UNBROWSE_TRACE;
-    return v != null && v !== "" && v !== "0";
-  })();
-  TRACE_SLOW_MS = (() => {
-    const n = parseInt(process.env.UNBROWSE_TRACE_SLOW_MS ?? "5000", 10);
-    return Number.isFinite(n) && n > 0 ? n : 5000;
-  })();
-});
-
-// .tmp-runtime-src/domain.ts
-var exports_domain = {};
-__export(exports_domain, {
-  isSameBrandDomain: () => isSameBrandDomain,
-  isDomainMatch: () => isDomainMatch,
-  getRegistrableDomain: () => getRegistrableDomain,
-  getBrandName: () => getBrandName
-});
-function getBrandName(hostname4) {
-  const h = hostname4.replace(/^\./, "").toLowerCase();
-  const parts = h.split(".");
-  if (parts.length >= 3) {
-    const lastTwo = parts.slice(-2).join(".");
-    if (GEO_TLD_SUFFIXES.has(lastTwo) || CC_TLDS.has(lastTwo)) {
-      return parts[parts.length - 3] ?? parts[0] ?? h;
+  function abortHandshake(socket, code, message, headers) {
+    if (socket.writable) {
+      message = message || http2.STATUS_CODES[code];
+      headers = {
+        Connection: "close",
+        "Content-Type": "text/html",
+        "Content-Length": Buffer.byteLength(message),
+        ...headers
+      };
+      socket.write(`HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join(`\r
+`) + `\r
+\r
+` + message);
     }
+    socket.removeListener("error", socketOnError);
+    socket.destroy();
   }
-  return parts[parts.length - 2] ?? parts[0] ?? h;
-}
-function isSameBrandDomain(a, b) {
-  return getBrandName(a) === getBrandName(b);
-}
-function getRegistrableDomain(hostname4) {
-  const parts = hostname4.split(".");
-  if (parts.length >= 3) {
-    const lastTwo = parts.slice(-2).join(".");
-    if (CC_TLDS.has(lastTwo) || GEO_TLD_SUFFIXES.has(lastTwo)) {
-      return parts.slice(-3).join(".");
-    }
+  function trim3(str) {
+    return str.trim();
   }
-  return parts.slice(-2).join(".");
-}
-function isDomainMatch(cookieDomain, targetDomain) {
-  const c = cookieDomain.replace(/^\./, "").toLowerCase();
-  const t = targetDomain.replace(/^\./, "").toLowerCase();
-  return t === c || t.endsWith("." + c);
-}
-var CC_TLDS, GEO_TLD_SUFFIXES;
-var init_domain = __esm(() => {
-  CC_TLDS = new Set([
-    "co.uk",
-    "co.nz",
-    "co.jp",
-    "co.kr",
-    "co.in",
-    "com.br",
-    "com.au",
-    "com.cn",
-    "com.mx",
-    "com.ar",
-    "com.tw",
-    "org.uk",
-    "gov.uk",
-    "ac.uk",
-    "net.au",
-    "org.au"
-  ]);
-  GEO_TLD_SUFFIXES = new Set([
-    "com.sg",
-    "com.hk",
-    "com.my",
-    "com.ph",
-    "com.vn",
-    "com.id",
-    "com.th",
-    "com.np",
-    "com.pk",
-    "com.bd",
-    "com.lk",
-    "com.mm",
-    "com.kh",
-    "com.eg",
-    "com.sa",
-    "com.qa",
-    "com.ae",
-    "com.kw",
-    "com.jo",
-    "com.lb",
-    "com.bh",
-    "com.om",
-    "com.iq",
-    "co.id",
-    "co.th",
-    "co.nz",
-    "co.jp",
-    "co.kr",
-    "co.in",
-    "co.uk",
-    "co.za",
-    "co.zw",
-    "co.ke",
-    "co.tz",
-    "co.ug"
-  ]);
 });
 
-// .tmp-runtime-src/settings.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join23 } from "node:path";
-function sanitizeProfileName3(value) {
-  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function getConfigDir3() {
-  if (process.env.UNBROWSE_CONFIG_DIR)
-    return process.env.UNBROWSE_CONFIG_DIR;
-  const profile = sanitizeProfileName3(process.env.UNBROWSE_PROFILE ?? "");
-  return profile ? join23(getUnbrowseHome2(), "profiles", profile) : getUnbrowseHome2();
-}
-function getUnbrowseConfigPath() {
-  return join23(getConfigDir3(), "config.json");
-}
-function loadRawConfig() {
-  try {
-    const configPath2 = getUnbrowseConfigPath();
-    if (existsSync22(configPath2)) {
-      const parsed = JSON.parse(readFileSync19(configPath2, "utf-8"));
-      if (parsed && typeof parsed === "object")
-        return parsed;
-    }
-  } catch {}
-  return {};
-}
-function saveRawConfig(config) {
-  const configDir = getConfigDir3();
-  if (!existsSync22(configDir))
-    mkdirSync11(configDir, { recursive: true });
-  writeFileSync9(getUnbrowseConfigPath(), JSON.stringify(config, null, 2), { mode: 384 });
-}
-function normalizeDomainRule(value) {
-  let normalized = value.trim().toLowerCase();
-  if (!normalized)
-    return "";
-  normalized = normalized.replace(/^\*\./, "");
-  if (normalized.startsWith("http://") || normalized.startsWith("https://")) {
-    try {
-      normalized = new URL(normalized).hostname.toLowerCase();
-    } catch {
-      normalized = normalized.replace(/^https?:\/\//, "");
-    }
-  }
-  normalized = normalized.split("/")[0] ?? normalized;
-  normalized = normalized.replace(/:\d+$/, "");
-  normalized = normalized.replace(/^www\./, "");
-  return normalized;
-}
-function normalizeDomainList(values) {
-  if (!Array.isArray(values))
-    return [];
-  const normalized = values.filter((value) => typeof value === "string").map(normalizeDomainRule).filter(Boolean);
-  return Array.from(new Set(normalized)).sort();
-}
-function matchesDomainRule(domain, rule) {
-  const host = normalizeDomainRule(domain);
-  const target = normalizeDomainRule(rule);
-  if (!host || !target)
-    return false;
-  if (host === target || host.endsWith(`.${target}`))
-    return true;
-  try {
-    return getRegistrableDomain(host) === target;
-  } catch {
-    return false;
-  }
-}
-function firstMatchingRule(domain, rules) {
-  return rules.find((rule) => matchesDomainRule(domain, rule));
-}
-function getCapturePipelineSettings() {
-  const raw = loadRawConfig();
-  const capturePipeline = raw.capture_pipeline && typeof raw.capture_pipeline === "object" ? raw.capture_pipeline : {};
-  return {
-    auto_publish_checkpoints: capturePipeline.auto_publish_checkpoints !== false,
-    publish_domain_blacklist: normalizeDomainList(capturePipeline.publish_domain_blacklist),
-    publish_domain_promptlist: normalizeDomainList(capturePipeline.publish_domain_promptlist)
-  };
-}
-function updateCapturePipelineSettings(update) {
-  const raw = loadRawConfig();
-  const existing = getCapturePipelineSettings();
-  const next = {
-    auto_publish_checkpoints: typeof update.auto_publish_checkpoints === "boolean" ? update.auto_publish_checkpoints : existing.auto_publish_checkpoints,
-    publish_domain_blacklist: update.clear_publish_domain_blacklist ? [] : update.publish_domain_blacklist ? normalizeDomainList(update.publish_domain_blacklist) : existing.publish_domain_blacklist,
-    publish_domain_promptlist: update.clear_publish_domain_promptlist ? [] : update.publish_domain_promptlist ? normalizeDomainList(update.publish_domain_promptlist) : existing.publish_domain_promptlist
-  };
-  saveRawConfig({
-    ...raw,
-    capture_pipeline: next
-  });
-  return next;
-}
-function getBrowserAttachPreference() {
-  const raw = loadRawConfig();
-  const browser = raw.browser && typeof raw.browser === "object" ? raw.browser : {};
-  return typeof browser.attach_existing_chrome === "boolean" ? browser.attach_existing_chrome : undefined;
-}
-function getBrowserAttachEnabled() {
-  return getBrowserAttachPreference() !== false;
-}
-function setBrowserAttachEnabled(enabled2) {
-  const raw = loadRawConfig();
-  const browser = raw.browser && typeof raw.browser === "object" ? { ...raw.browser } : {};
-  browser.attach_existing_chrome = enabled2;
-  saveRawConfig({ ...raw, browser });
-  return enabled2;
-}
-function decideCheckpointPublish(domain) {
-  const settings = getCapturePipelineSettings();
-  if (!settings.auto_publish_checkpoints) {
-    return {
-      publishQueued: false,
-      mode: "disabled",
-      reason: "Auto-publish after sync/close is disabled in local settings."
-    };
-  }
-  const blacklisted = firstMatchingRule(domain, settings.publish_domain_blacklist);
-  if (blacklisted) {
-    return {
-      publishQueued: false,
-      mode: "blacklisted",
-      reason: `Auto-publish skipped because ${domain} matches blacklist entry ${blacklisted}.`,
-      matchedDomain: blacklisted
-    };
-  }
-  const prompted = firstMatchingRule(domain, settings.publish_domain_promptlist);
-  if (prompted) {
-    return {
-      publishQueued: false,
-      mode: "prompt",
-      reason: `Auto-publish paused because ${domain} matches prompt-list entry ${prompted}.`,
-      matchedDomain: prompted
-    };
-  }
-  return {
-    publishQueued: true,
-    mode: "auto",
-    reason: "Background publish is allowed for this checkpoint."
-  };
-}
-function decideExplicitPublish(domain, confirmPublish) {
-  const settings = getCapturePipelineSettings();
-  const blacklisted = firstMatchingRule(domain, settings.publish_domain_blacklist);
-  if (blacklisted && !confirmPublish) {
-    return {
-      allowed: false,
-      mode: "blacklisted",
-      reason: `Explicit publish requires confirmation because ${domain} matches blacklist entry ${blacklisted}.`,
-      matchedDomain: blacklisted
-    };
-  }
-  const prompted = firstMatchingRule(domain, settings.publish_domain_promptlist);
-  if (prompted && !confirmPublish) {
-    return {
-      allowed: false,
-      mode: "prompt",
-      reason: `Explicit publish requires confirmation because ${domain} matches prompt-list entry ${prompted}.`,
-      matchedDomain: prompted
-    };
-  }
-  return {
-    allowed: true,
-    mode: "allowed",
-    reason: "Explicit publish allowed."
-  };
-}
-var init_settings = __esm(() => {
-  init_domain();
-  init_paths();
+// ../../../node_modules/ws/index.js
+var require_ws2 = __commonJS((exports, module) => {
+  var WebSocket2 = require_websocket2();
+  WebSocket2.createWebSocketStream = require_stream2();
+  WebSocket2.Server = require_websocket_server2();
+  WebSocket2.Receiver = require_receiver2();
+  WebSocket2.Sender = require_sender2();
+  module.exports = WebSocket2;
 });
 
 // .tmp-runtime-src/kuri/client.ts
@@ -109979,7 +112594,7 @@ async function setCookieViaCDP(wsUrl, cookie) {
       resolve(false);
     }, 3000);
     try {
-      const ws = new ((()=>{throw new Error("Cannot require module "+"ws");})())(wsUrl);
+      const ws = new (require_ws2())(wsUrl);
       ws.on("open", () => {
         ws.send(JSON.stringify({
           id: 1,
@@ -152475,7 +155090,7 @@ var require_dbcs_codec = __commonJS((exports) => {
           if (resCode !== undefined) {
             dbcsCode = resCode;
             nextChar = uCode;
-          }
+          } else {}
         }
         seqObj = undefined;
       } else if (uCode >= 0) {
@@ -152536,7 +155151,7 @@ var require_dbcs_codec = __commonJS((exports) => {
           newBuf[j++] = dbcsCode >> 8;
           newBuf[j++] = dbcsCode & 255;
         }
-      }
+      } else {}
       this.seqObj = undefined;
     }
     if (this.leadSurrogate !== -1) {
@@ -155319,7 +157934,7 @@ var require_errors8 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/core/constants.js
-var require_constants8 = __commonJS((exports, module) => {
+var require_constants9 = __commonJS((exports, module) => {
   var wellknownHeaderNames = [
     "Accept",
     "Accept-Encoding",
@@ -155445,7 +158060,7 @@ var require_tree = __commonJS((exports, module) => {
   var {
     wellknownHeaderNames,
     headerNameLowerCasedRecord
-  } = require_constants8();
+  } = require_constants9();
 
   class TstNode {
     value = null;
@@ -155563,7 +158178,7 @@ var require_util3 = __commonJS((exports, module) => {
   var { EventEmitter: EE } = __require("node:events");
   var timers = require_timers();
   var { InvalidArgumentError, ConnectTimeoutError } = require_errors8();
-  var { headerNameLowerCasedRecord } = require_constants8();
+  var { headerNameLowerCasedRecord } = require_constants9();
   var { tree } = require_tree();
   var [nodeMajor, nodeMinor] = process.versions.node.split(".", 2).map((v) => Number(v));
 
@@ -156552,7 +159167,7 @@ var require_request3 = __commonJS((exports, module) => {
     getProtocolFromUrlString
   } = require_util3();
   var { channels } = require_diagnostics();
-  var { headerNameLowerCasedRecord } = require_constants8();
+  var { headerNameLowerCasedRecord } = require_constants9();
   var invalidPathRegex = /[^\u0021-\u00ff]/;
   var kHandler = Symbol("handler");
 
@@ -157331,7 +159946,7 @@ var require_utils8 = __commonJS((exports) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/llhttp/constants.js
-var require_constants9 = __commonJS((exports) => {
+var require_constants10 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.SPECIAL_HEADERS = exports.MINOR = exports.MAJOR = exports.HTAB_SP_VCHAR_OBS_TEXT = exports.QUOTED_STRING = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.HEX = exports.URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.STATUSES_HTTP = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.HEADER_STATE = exports.FINISH = exports.STATUSES = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = undefined;
   var utils_1 = require_utils8();
@@ -157923,7 +160538,7 @@ var require_llhttp_simd_wasm = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/fetch/constants.js
-var require_constants10 = __commonJS((exports, module) => {
+var require_constants11 = __commonJS((exports, module) => {
   var corsSafeListedMethods = ["GET", "HEAD", "POST"];
   var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
   var nullBodyStatus = [101, 204, 205, 304];
@@ -159149,7 +161764,7 @@ var require_webidl = __commonJS((exports, module) => {
 var require_util4 = __commonJS((exports, module) => {
   var { Transform } = __require("node:stream");
   var zlib = __require("node:zlib");
-  var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants10();
+  var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants11();
   var { getGlobalOrigin } = require_global();
   var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
   var { performance: performance2 } = __require("node:perf_hooks");
@@ -160615,7 +163230,7 @@ var require_client_h1 = __commonJS((exports, module) => {
     kHTTPContext,
     kClosed
   } = require_symbols4();
-  var constants = require_constants9();
+  var constants = require_constants10();
   var EMPTY_BUF = Buffer.alloc(0);
   var FastBuffer = Buffer[Symbol.species];
   var removeAllListeners = util.removeAllListeners;
@@ -171179,7 +173794,7 @@ var require_response2 = __commonJS((exports, module) => {
   var {
     redirectStatusSet,
     nullBodyStatus
-  } = require_constants10();
+  } = require_constants11();
   var { webidl } = require_webidl();
   var { URLSerializer } = require_data_url();
   var { kConstruct } = require_symbols4();
@@ -171566,7 +174181,7 @@ var require_request4 = __commonJS((exports, module) => {
     requestCredentials,
     requestCache,
     requestDuplex
-  } = require_constants10();
+  } = require_constants11();
   var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util;
   var { webidl } = require_webidl();
   var { URLSerializer } = require_data_url();
@@ -172360,7 +174975,7 @@ var require_fetch = __commonJS((exports, module) => {
     safeMethodsSet,
     requestBodyHeader,
     subresourceSet
-  } = require_constants10();
+  } = require_constants11();
   var EE = __require("node:events");
   var { Readable, pipeline, finished, isErrored, isReadable } = __require("node:stream");
   var { addAbortListener, bufferToLowerCasedHeaderName } = require_util3();
@@ -173055,7 +175670,7 @@ var require_fetch = __commonJS((exports, module) => {
       request.cache = "no-store";
     }
     const newConnection = forceNewConnection ? "yes" : "no";
-    if (request.mode === "websocket") {}
+    if (request.mode === "websocket") {} else {}
     let requestBody = null;
     if (request.body == null && fetchParams.processRequestEndOfBody) {
       queueMicrotask(() => fetchParams.processRequestEndOfBody());
@@ -173988,7 +176603,7 @@ var require_cachestorage = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/cookies/constants.js
-var require_constants11 = __commonJS((exports, module) => {
+var require_constants12 = __commonJS((exports, module) => {
   var maxAttributeValueSize = 1024;
   var maxNameValuePairSize = 4096;
   module.exports = {
@@ -174142,7 +176757,7 @@ var require_util6 = __commonJS((exports, module) => {
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/cookies/parse.js
 var require_parse6 = __commonJS((exports, module) => {
   var { collectASequenceOfCodePointsFast } = require_infra();
-  var { maxNameValuePairSize, maxAttributeValueSize } = require_constants11();
+  var { maxNameValuePairSize, maxAttributeValueSize } = require_constants12();
   var { isCTLExcludingHtab } = require_util6();
   var assert = __require("node:assert");
   var { unescape: qsUnescape } = __require("node:querystring");
@@ -174659,7 +177274,7 @@ var require_events3 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/constants.js
-var require_constants12 = __commonJS((exports, module) => {
+var require_constants13 = __commonJS((exports, module) => {
   var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
   var staticPropertyDescriptors = {
     enumerable: true,
@@ -174713,7 +177328,7 @@ var require_constants12 = __commonJS((exports, module) => {
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/util.js
 var require_util7 = __commonJS((exports, module) => {
-  var { states, opcodes } = require_constants12();
+  var { states, opcodes } = require_constants13();
   var { isUtf8 } = __require("node:buffer");
   var { removeHTTPWhitespace } = require_data_url();
   var { collectASequenceOfCodePointsFast } = require_infra();
@@ -174866,7 +177481,7 @@ var require_util7 = __commonJS((exports, module) => {
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/frame.js
 var require_frame = __commonJS((exports, module) => {
   var { runtimeFeatures } = require_runtime_features();
-  var { maxUnsigned16Bit, opcodes } = require_constants12();
+  var { maxUnsigned16Bit, opcodes } = require_constants13();
   var BUFFER_SIZE = 8 * 1024;
   var buffer = null;
   var bufIdx = BUFFER_SIZE;
@@ -174962,7 +177577,7 @@ var require_frame = __commonJS((exports, module) => {
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/connection.js
 var require_connection = __commonJS((exports, module) => {
-  var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants12();
+  var { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require_constants13();
   var { parseExtensions, isClosed, isClosing, isEstablished, isConnecting, validateCloseCodeAndReason } = require_util7();
   var { makeRequest } = require_request4();
   var { fetching } = require_fetch();
@@ -175114,7 +177729,7 @@ var require_connection = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/permessage-deflate.js
-var require_permessage_deflate2 = __commonJS((exports, module) => {
+var require_permessage_deflate3 = __commonJS((exports, module) => {
   var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib");
   var { isValidClientWindowBits } = require_util7();
   var { MessageSizeExceededError } = require_errors8();
@@ -175199,10 +177814,10 @@ var require_permessage_deflate2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/receiver.js
-var require_receiver2 = __commonJS((exports, module) => {
+var require_receiver3 = __commonJS((exports, module) => {
   var { Writable } = __require("node:stream");
   var assert = __require("node:assert");
-  var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants12();
+  var { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require_constants13();
   var {
     isValidStatusCode,
     isValidOpcode,
@@ -175214,7 +177829,7 @@ var require_receiver2 = __commonJS((exports, module) => {
   } = require_util7();
   var { failWebsocketConnection } = require_connection();
   var { WebsocketFrameSend } = require_frame();
-  var { PerMessageDeflate } = require_permessage_deflate2();
+  var { PerMessageDeflate } = require_permessage_deflate3();
   var { MessageSizeExceededError } = require_errors8();
 
   class ByteParser extends Writable {
@@ -175491,9 +178106,9 @@ var require_receiver2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/sender.js
-var require_sender2 = __commonJS((exports, module) => {
+var require_sender3 = __commonJS((exports, module) => {
   var { WebsocketFrameSend } = require_frame();
-  var { opcodes, sendHints } = require_constants12();
+  var { opcodes, sendHints } = require_constants13();
   var FixedQueue = require_fixed_queue();
 
   class SendQueue {
@@ -175569,12 +178184,12 @@ var require_sender2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/undici@7.25.0/node_modules/undici/lib/web/websocket/websocket.js
-var require_websocket2 = __commonJS((exports, module) => {
+var require_websocket3 = __commonJS((exports, module) => {
   var { isArrayBuffer } = __require("node:util/types");
   var { webidl } = require_webidl();
   var { URLSerializer } = require_data_url();
   var { environmentSettingsObject } = require_util4();
-  var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require_constants12();
+  var { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require_constants13();
   var {
     isConnecting,
     isEstablished,
@@ -175587,11 +178202,11 @@ var require_websocket2 = __commonJS((exports, module) => {
     getURLRecord
   } = require_util7();
   var { establishWebSocketConnection, closeWebSocketConnection, failWebsocketConnection } = require_connection();
-  var { ByteParser } = require_receiver2();
+  var { ByteParser } = require_receiver3();
   var { kEnumerableProperty } = require_util3();
   var { getGlobalDispatcher } = require_global2();
   var { ErrorEvent, CloseEvent, createFastMessageEvent } = require_events3();
-  var { SendQueue } = require_sender2();
+  var { SendQueue } = require_sender3();
   var { WebsocketFrameSend } = require_frame();
   var { channels } = require_diagnostics();
   function getSocketAddress(socket) {
@@ -176093,13 +178708,13 @@ var require_websocketerror = __commonJS((exports, module) => {
 var require_websocketstream = __commonJS((exports, module) => {
   var { createDeferredPromise } = require_promise2();
   var { environmentSettingsObject } = require_util4();
-  var { states, opcodes, sentCloseFrameState } = require_constants12();
+  var { states, opcodes, sentCloseFrameState } = require_constants13();
   var { webidl } = require_webidl();
   var { getURLRecord, isValidSubprotocol, isEstablished, utf8Decode } = require_util7();
   var { establishWebSocketConnection, failWebsocketConnection, closeWebSocketConnection } = require_connection();
   var { channels } = require_diagnostics();
   var { WebsocketFrameSend } = require_frame();
-  var { ByteParser } = require_receiver2();
+  var { ByteParser } = require_receiver3();
   var { WebSocketError, createUnvalidatedWebSocketError } = require_websocketerror();
   var { kEnumerableProperty } = require_util3();
   var { utf8DecodeBytes } = require_encoding2();
@@ -176896,7 +179511,7 @@ function makeDispatcher(fn) {
     }, handler);
   };
 }
-var __filename = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/undici@7.25.0/node_modules/undici/index.js", Client, Dispatcher, Pool, BalancedPool, RoundRobinPool, Agent, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RetryAgent, H2CClient, errors, util, InvalidArgumentError, api3, buildConnector, MockClient, MockCallHistory, MockCallHistoryLog, MockAgent, MockPool, SnapshotAgent, mockErrors, RetryHandler, getGlobalDispatcher, setGlobalDispatcher, DecoratorHandler, RedirectHandler, $interceptors, $cacheStores, SqliteCacheStore, $util, fetchImpl, $Headers, $Response, $Request, $FormData, setGlobalOrigin, getGlobalOrigin, CacheStorage, kConstruct, $caches, deleteCookie, getCookies2, getSetCookies, setCookie2, parseCookie, parseMIMEType, serializeAMimeType, CloseEvent, ErrorEvent, MessageEvent, WebSocket2, ping, $WebSocketStream, $WebSocketError, $request, $stream, $pipeline, $connect, $upgrade, EventSource;
+var __filename = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/undici@7.25.0/node_modules/undici/index.js", Client, Dispatcher, Pool, BalancedPool, RoundRobinPool, Agent, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RetryAgent, H2CClient, errors, util, InvalidArgumentError, api3, buildConnector, MockClient, MockCallHistory, MockCallHistoryLog, MockAgent, MockPool, SnapshotAgent, mockErrors, RetryHandler, getGlobalDispatcher, setGlobalDispatcher, DecoratorHandler, RedirectHandler, $interceptors, $cacheStores, SqliteCacheStore, $util, fetchImpl, $Headers, $Response, $Request, $FormData, setGlobalOrigin, getGlobalOrigin, CacheStorage, kConstruct, $caches, deleteCookie, getCookies2, getSetCookies, setCookie2, parseCookie, parseMIMEType, serializeAMimeType, CloseEvent, ErrorEvent, MessageEvent, WebSocket2, ping, $WebSocketStream, $WebSocketError, $request, $stream, $pipeline, $connect, $upgrade, EventSource;
 var init_undici = __esm(() => {
   Client = require_client();
   Dispatcher = require_dispatcher();
@@ -176956,7 +179571,7 @@ var init_undici = __esm(() => {
   ({ deleteCookie, getCookies: getCookies2, getSetCookies, setCookie: setCookie2, parseCookie } = require_cookies());
   ({ parseMIMEType, serializeAMimeType } = require_data_url());
   ({ CloseEvent, ErrorEvent, MessageEvent } = require_events3());
-  ({ WebSocket: WebSocket2, ping } = require_websocket2());
+  ({ WebSocket: WebSocket2, ping } = require_websocket3());
   $WebSocketStream = require_websocketstream().WebSocketStream;
   $WebSocketError = require_websocketerror().WebSocketError;
   $request = makeDispatcher(api3.request);
@@ -187842,7 +190457,7 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
     const startedAt2 = new Date().toISOString();
     const traceId = nanoid();
     try {
-      const { WebSocket: WebSocket3 } = await import("ws");
+      const { WebSocket: WebSocket3 } = await Promise.resolve().then(() => __toESM(require_ws2(), 1));
       const messages = [];
       await new Promise((resolve2, reject) => {
         const ws = new WebSocket3(endpoint.url_template);
@@ -247689,7 +250304,7 @@ var require_errors9 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/constants.js
-var require_constants13 = __commonJS((exports, module) => {
+var require_constants14 = __commonJS((exports, module) => {
   module.exports = {
     BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
     GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
@@ -247701,8 +250316,8 @@ var require_constants13 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/buffer-util.js
-var require_buffer_util2 = __commonJS((exports, module) => {
-  var { EMPTY_BUFFER } = require_constants13();
+var require_buffer_util3 = __commonJS((exports, module) => {
+  var { EMPTY_BUFFER } = require_constants14();
   function concat3(list, totalLength) {
     if (list.length === 0)
       return EMPTY_BUFFER;
@@ -247783,7 +250398,7 @@ var require_buffer_util2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/limiter.js
-var require_limiter2 = __commonJS((exports, module) => {
+var require_limiter3 = __commonJS((exports, module) => {
   var kDone = Symbol("kDone");
   var kRun = Symbol("kRun");
 
@@ -247815,11 +250430,11 @@ var require_limiter2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/permessage-deflate.js
-var require_permessage_deflate3 = __commonJS((exports, module) => {
+var require_permessage_deflate4 = __commonJS((exports, module) => {
   var zlib = __require("zlib");
-  var bufferUtil = require_buffer_util2();
-  var Limiter = require_limiter2();
-  var { kStatusCode, NOOP } = require_constants13();
+  var bufferUtil = require_buffer_util3();
+  var Limiter = require_limiter3();
+  var { kStatusCode, NOOP } = require_constants14();
   var TRAILER = Buffer.from([0, 0, 255, 255]);
   var kPerMessageDeflate = Symbol("permessage-deflate");
   var kTotalLength = Symbol("total-length");
@@ -248074,7 +250689,7 @@ var require_permessage_deflate3 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/validation.js
-var require_validation4 = __commonJS((exports, module) => {
+var require_validation5 = __commonJS((exports, module) => {
   function isValidStatusCode(code) {
     return code >= 1000 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3000 && code <= 4999;
   }
@@ -248125,17 +250740,17 @@ var require_validation4 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/receiver.js
-var require_receiver3 = __commonJS((exports, module) => {
+var require_receiver4 = __commonJS((exports, module) => {
   var { Writable } = __require("stream");
-  var PerMessageDeflate = require_permessage_deflate3();
+  var PerMessageDeflate = require_permessage_deflate4();
   var {
     BINARY_TYPES,
     EMPTY_BUFFER,
     kStatusCode,
     kWebSocket
-  } = require_constants13();
-  var { concat: concat3, toArrayBuffer, unmask } = require_buffer_util2();
-  var { isValidStatusCode, isValidUTF8 } = require_validation4();
+  } = require_constants14();
+  var { concat: concat3, toArrayBuffer, unmask } = require_buffer_util3();
+  var { isValidStatusCode, isValidUTF8 } = require_validation5();
   var GET_INFO = 0;
   var GET_PAYLOAD_LENGTH_16 = 1;
   var GET_PAYLOAD_LENGTH_64 = 2;
@@ -248446,14 +251061,14 @@ var require_receiver3 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/sender.js
-var require_sender3 = __commonJS((exports, module) => {
+var require_sender4 = __commonJS((exports, module) => {
   var net2 = __require("net");
   var tls = __require("tls");
   var { randomFillSync } = __require("crypto");
-  var PerMessageDeflate = require_permessage_deflate3();
-  var { EMPTY_BUFFER } = require_constants13();
-  var { isValidStatusCode } = require_validation4();
-  var { mask: applyMask, toBuffer } = require_buffer_util2();
+  var PerMessageDeflate = require_permessage_deflate4();
+  var { EMPTY_BUFFER } = require_constants14();
+  var { isValidStatusCode } = require_validation5();
+  var { mask: applyMask, toBuffer } = require_buffer_util3();
   var mask = Buffer.alloc(4);
 
   class Sender {
@@ -248669,7 +251284,7 @@ var require_sender3 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/event-target.js
-var require_event_target2 = __commonJS((exports, module) => {
+var require_event_target3 = __commonJS((exports, module) => {
   class Event2 {
     constructor(type, target) {
       this.target = target;
@@ -248752,7 +251367,7 @@ var require_event_target2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/extension.js
-var require_extension2 = __commonJS((exports, module) => {
+var require_extension3 = __commonJS((exports, module) => {
   var tokenChars = [
     0,
     0,
@@ -249047,7 +251662,7 @@ var require_extension2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/websocket.js
-var require_websocket3 = __commonJS((exports, module) => {
+var require_websocket4 = __commonJS((exports, module) => {
   var EventEmitter = __require("events");
   var https = __require("https");
   var http2 = __require("http");
@@ -249056,9 +251671,9 @@ var require_websocket3 = __commonJS((exports, module) => {
   var { randomBytes: randomBytes16, createHash: createHash26 } = __require("crypto");
   var { Readable } = __require("stream");
   var { URL: URL2 } = __require("url");
-  var PerMessageDeflate = require_permessage_deflate3();
-  var Receiver = require_receiver3();
-  var Sender = require_sender3();
+  var PerMessageDeflate = require_permessage_deflate4();
+  var Receiver = require_receiver4();
+  var Sender = require_sender4();
   var {
     BINARY_TYPES,
     EMPTY_BUFFER,
@@ -249066,10 +251681,10 @@ var require_websocket3 = __commonJS((exports, module) => {
     kStatusCode,
     kWebSocket,
     NOOP
-  } = require_constants13();
-  var { addEventListener, removeEventListener } = require_event_target2();
-  var { format, parse: parse9 } = require_extension2();
-  var { toBuffer } = require_buffer_util2();
+  } = require_constants14();
+  var { addEventListener, removeEventListener } = require_event_target3();
+  var { format, parse: parse9 } = require_extension3();
+  var { toBuffer } = require_buffer_util3();
   var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
   var protocolVersions = [8, 13];
   var closeTimeout = 30 * 1000;
@@ -249693,7 +252308,7 @@ var require_websocket3 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/stream.js
-var require_stream2 = __commonJS((exports, module) => {
+var require_stream3 = __commonJS((exports, module) => {
   var { Duplex } = __require("stream");
   function emitClose(stream) {
     stream.emit("close");
@@ -249813,17 +252428,17 @@ var require_stream2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/lib/websocket-server.js
-var require_websocket_server2 = __commonJS((exports, module) => {
+var require_websocket_server3 = __commonJS((exports, module) => {
   var EventEmitter = __require("events");
   var http2 = __require("http");
   var https = __require("https");
   var net2 = __require("net");
   var tls = __require("tls");
   var { createHash: createHash26 } = __require("crypto");
-  var PerMessageDeflate = require_permessage_deflate3();
-  var WebSocket3 = require_websocket3();
-  var { format, parse: parse9 } = require_extension2();
-  var { GUID, kWebSocket } = require_constants13();
+  var PerMessageDeflate = require_permessage_deflate4();
+  var WebSocket3 = require_websocket4();
+  var { format, parse: parse9 } = require_extension3();
+  var { GUID, kWebSocket } = require_constants14();
   var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
   var RUNNING = 0;
   var CLOSING = 1;
@@ -250053,12 +252668,12 @@ var require_websocket_server2 = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/ws@7.5.10+84634d09670b738c/node_modules/ws/index.js
-var require_ws2 = __commonJS((exports, module) => {
-  var WebSocket3 = require_websocket3();
-  WebSocket3.createWebSocketStream = require_stream2();
-  WebSocket3.Server = require_websocket_server2();
-  WebSocket3.Receiver = require_receiver3();
-  WebSocket3.Sender = require_sender3();
+var require_ws3 = __commonJS((exports, module) => {
+  var WebSocket3 = require_websocket4();
+  WebSocket3.createWebSocketStream = require_stream3();
+  WebSocket3.Server = require_websocket_server3();
+  WebSocket3.Receiver = require_receiver4();
+  WebSocket3.Sender = require_sender4();
   module.exports = WebSocket3;
 });
 
@@ -250148,7 +252763,7 @@ var require_chrome = __commonJS((exports, module) => {
   var util2 = __require("util");
   var formatUrl = __require("url").format;
   var parseUrl = __require("url").parse;
-  var WebSocket3 = require_ws2();
+  var WebSocket3 = require_ws3();
   var api5 = require_api2();
   var defaults = require_defaults2();
   var devtools = require_devtools();
@@ -250566,7 +253181,7 @@ var init_types2 = __esm(() => {
 });
 
 // node_modules/.bun/semver@7.8.1/node_modules/semver/internal/constants.js
-var require_constants14 = __commonJS((exports, module) => {
+var require_constants15 = __commonJS((exports, module) => {
   var SEMVER_SPEC_VERSION = "2.0.0";
   var MAX_LENGTH = 256;
   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
@@ -250605,7 +253220,7 @@ var require_re2 = __commonJS((exports, module) => {
     MAX_SAFE_COMPONENT_LENGTH,
     MAX_SAFE_BUILD_LENGTH,
     MAX_LENGTH
-  } = require_constants14();
+  } = require_constants15();
   var debug = require_debug3();
   exports = module.exports = {};
   var re = exports.re = [];
@@ -250725,7 +253340,7 @@ var require_identifiers2 = __commonJS((exports, module) => {
 // node_modules/.bun/semver@7.8.1/node_modules/semver/classes/semver.js
 var require_semver3 = __commonJS((exports, module) => {
   var debug = require_debug3();
-  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants14();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants15();
   var { safeRe: re, t } = require_re2();
   var parseOptions = require_parse_options2();
   var { compareIdentifiers } = require_identifiers2();
@@ -251301,7 +253916,7 @@ var require_coerce2 = __commonJS((exports, module) => {
 // node_modules/.bun/semver@7.8.1/node_modules/semver/functions/truncate.js
 var require_truncate = __commonJS((exports, module) => {
   var parse9 = require_parse7();
-  var constants = require_constants14();
+  var constants = require_constants15();
   var SemVer = require_semver3();
   var truncate = (version2, truncation, options) => {
     if (!constants.RELEASE_TYPES.includes(truncation)) {
@@ -251528,7 +254143,7 @@ var require_range3 = __commonJS((exports, module) => {
     tildeTrimReplace,
     caretTrimReplace
   } = require_re2();
-  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants14();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants15();
   var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
   var isNullSet = (c) => c.value === "<0.0.0-0";
   var isAny = (c) => c.value === "";
@@ -252300,7 +254915,7 @@ var require_subset2 = __commonJS((exports, module) => {
 // node_modules/.bun/semver@7.8.1/node_modules/semver/index.js
 var require_semver4 = __commonJS((exports, module) => {
   var internalRe = require_re2();
-  var constants = require_constants14();
+  var constants = require_constants15();
   var SemVer = require_semver3();
   var identifiers = require_identifiers2();
   var parse9 = require_parse7();
@@ -255339,7 +257954,7 @@ var require_smartbuffer = __commonJS((exports) => {
 });
 
 // node_modules/.bun/socks@2.8.9/node_modules/socks/build/common/constants.js
-var require_constants15 = __commonJS((exports) => {
+var require_constants16 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.SOCKS5_NO_ACCEPTABLE_AUTH = exports.SOCKS5_CUSTOM_AUTH_END = exports.SOCKS5_CUSTOM_AUTH_START = exports.SOCKS_INCOMING_PACKET_SIZES = exports.SocksClientState = exports.Socks5Response = exports.Socks5HostType = exports.Socks5Auth = exports.Socks4Response = exports.SocksCommand = exports.ERRORS = exports.DEFAULT_TIMEOUT = undefined;
   var DEFAULT_TIMEOUT = 30000;
@@ -255542,7 +258157,7 @@ var require_common5 = __commonJS((exports) => {
 });
 
 // node_modules/.bun/ip-address@10.2.0/node_modules/ip-address/dist/v4/constants.js
-var require_constants16 = __commonJS((exports) => {
+var require_constants17 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = undefined;
   exports.BITS = 32;
@@ -255588,7 +258203,7 @@ var require_ipv4 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.Address4 = undefined;
   var common = __importStar(require_common5());
-  var constants = __importStar(require_constants16());
+  var constants = __importStar(require_constants17());
   var address_error_1 = require_address_error();
   var isCorrect4 = common.isCorrect(constants.BITS);
 
@@ -255823,7 +258438,7 @@ var require_ipv4 = __commonJS((exports) => {
 });
 
 // node_modules/.bun/ip-address@10.2.0/node_modules/ip-address/dist/v6/constants.js
-var require_constants17 = __commonJS((exports) => {
+var require_constants18 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = undefined;
   exports.BITS = 128;
@@ -255951,7 +258566,7 @@ var require_regular_expressions = __commonJS((exports) => {
   exports.padGroup = padGroup;
   exports.simpleRegularExpression = simpleRegularExpression;
   exports.possibleElisions = possibleElisions;
-  var v6 = __importStar(require_constants17());
+  var v6 = __importStar(require_constants18());
   function groupPossibilities(possibilities) {
     return `(${possibilities.join("|")})`;
   }
@@ -256042,8 +258657,8 @@ var require_ipv6 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.Address6 = undefined;
   var common = __importStar(require_common5());
-  var constants4 = __importStar(require_constants16());
-  var constants6 = __importStar(require_constants17());
+  var constants4 = __importStar(require_constants17());
+  var constants6 = __importStar(require_constants18());
   var helpers2 = __importStar(require_helpers2());
   var ipv4_1 = require_ipv4();
   var regular_expressions_1 = require_regular_expressions();
@@ -256815,7 +259430,7 @@ var require_helpers3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.ipToBuffer = exports.int32ToIpv4 = exports.ipv4ToInt32 = exports.validateSocksClientChainOptions = exports.validateSocksClientOptions = undefined;
   var util_1 = require_util9();
-  var constants_1 = require_constants15();
+  var constants_1 = require_constants16();
   var stream = __require("stream");
   var ip_address_1 = require_ip_address();
   var net2 = __require("net");
@@ -256994,7 +259609,7 @@ var require_socksclient = __commonJS((exports) => {
   var events_1 = __require("events");
   var net2 = __require("net");
   var smart_buffer_1 = require_smartbuffer();
-  var constants_1 = require_constants15();
+  var constants_1 = require_constants16();
   var helpers_1 = require_helpers3();
   var receivebuffer_1 = require_receivebuffer();
   var util_1 = require_util9();
@@ -276615,7 +279230,7 @@ var require_ffi_WASM_RELEASE_SYNC = __commonJS((exports) => {
 
 // node_modules/.bun/@tootallnate+quickjs-emscripten@0.23.0/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.js
 var require_emscripten_module_WASM_RELEASE_SYNC = __commonJS((exports, module) => {
-  var __dirname = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/@tootallnate+quickjs-emscripten@0.23.0/node_modules/@tootallnate/quickjs-emscripten/dist/generated", __filename = "/Users/lewis/act-runner/work/48768e304e69e0e9/hostexecutor/node_modules/.bun/@tootallnate+quickjs-emscripten@0.23.0/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.js";
+  var __dirname = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/@tootallnate+quickjs-emscripten@0.23.0/node_modules/@tootallnate/quickjs-emscripten/dist/generated", __filename = "/Users/lekt9/Projects/unbrowse-ecosystem/unbrowse/node_modules/.bun/@tootallnate+quickjs-emscripten@0.23.0/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.js";
   var QuickJSRaw = (() => {
     var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : undefined;
     if (typeof __filename !== "undefined")
@@ -283483,7 +286098,7 @@ var require_extract = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/tar-stream@3.2.0/node_modules/tar-stream/constants.js
-var require_constants18 = __commonJS((exports, module) => {
+var require_constants19 = __commonJS((exports, module) => {
   var constants = {
     S_IFMT: 61440,
     S_IFDIR: 16384,
@@ -283503,7 +286118,7 @@ var require_constants18 = __commonJS((exports, module) => {
 var require_pack = __commonJS((exports, module) => {
   var { Readable, Writable, getStreamError } = require_streamx();
   var b4a = require_b4a();
-  var constants = require_constants18();
+  var constants = require_constants19();
   var headers = require_headers2();
   var DMODE = 493;
   var FMODE = 420;
@@ -285798,7 +288413,8 @@ var init_lib2 = __esm(() => {
     require: (path28) => {
       if (true) {
         return __require(path28);
-      }
+      } else
+        ;
     }
   });
   yargsParser.detailed = function(args, opts) {