rnxsim 0.0.0 → 0.1.313

package/dist-lib/host/fetch-proxy-handler.cjs

@@ -0,0 +1,373 @@
+/*! rnx v0.1.313 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/fetch-proxy-handler.ts
+var fetch_proxy_handler_exports = {};
+__export(fetch_proxy_handler_exports, {
+  buildAppApiProxyHeaders: () => buildAppApiProxyHeaders,
+  buildFetchProxyHeaders: () => buildFetchProxyHeaders,
+  handleAppApiRequest: () => handleAppApiRequest,
+  handleFetchProxyRequest: () => handleFetchProxyRequest,
+  isAppApiRequestUrl: () => isAppApiRequestUrl,
+  isFetchProxyRequestUrl: () => isFetchProxyRequestUrl
+});
+module.exports = __toCommonJS(fetch_proxy_handler_exports);
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+var import_promises = require("stream/promises");
+
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/host/fetch-proxy-overrides.ts
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+
+// src/host/fetch-proxy-handler.ts
+var STRIP_FETCH_PROXY_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "user-agent",
+  "accept-encoding",
+  "cookie",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "content-length",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest",
+  "sec-ch-ua",
+  "sec-ch-ua-mobile",
+  "sec-ch-ua-platform"
+]);
+var FETCH_PROXY_CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET,POST,PUT,DELETE,PATCH,OPTIONS",
+  "access-control-allow-headers": "*",
+  "access-control-expose-headers": "*",
+  "access-control-max-age": "3600"
+};
+var APP_API_HEADER_REWRITES = /* @__PURE__ */ new Set([
+  "host",
+  "origin",
+  "referer",
+  "sec-fetch-site",
+  "sec-fetch-mode",
+  "sec-fetch-dest"
+]);
+function loopbackTlsOptions(targetUrl) {
+  if (targetUrl.protocol !== "https:") return {};
+  return isLoopbackHost(targetUrl.hostname) ? { rejectUnauthorized: false } : {};
+}
+function applyFetchProxyCors(res) {
+  for (const [key, value] of Object.entries(FETCH_PROXY_CORS_HEADERS)) {
+    res.setHeader(key, value);
+  }
+}
+function formatFetchProxyError(targetUrl, err) {
+  const details = [];
+  const error = err;
+  if (error?.code) details.push(error.code);
+  if (error?.message) details.push(error.message);
+  if (error?.cause?.code) details.push(error.cause.code);
+  if (error?.cause?.message) details.push(error.cause.message);
+  const uniqueDetails = [...new Set(details.filter(Boolean))];
+  const message = uniqueDetails.join(" | ") || String(err);
+  if (targetUrl.includes("stored-in-.env.local")) {
+    return `${message} | upstream url still contains placeholder env values`;
+  }
+  return message;
+}
+function buildFetchProxyHeaders(reqHeaders, targetUrl) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (STRIP_FETCH_PROXY_HEADERS.has(key.toLowerCase())) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  Object.assign(
+    headers,
+    targetUrl ? getFetchProxyTargetHeaders(targetUrl) : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT }
+  );
+  return headers;
+}
+function buildAppApiProxyHeaders(reqHeaders, targetUrl) {
+  const headers = {};
+  for (const [key, value] of Object.entries(reqHeaders)) {
+    if (!value) continue;
+    if (APP_API_HEADER_REWRITES.has(key.toLowerCase())) continue;
+    headers[key] = value;
+  }
+  headers.host = targetUrl.host;
+  headers.origin = targetUrl.origin;
+  headers.referer = `${targetUrl.origin}/`;
+  return headers;
+}
+function isFetchProxyRequestUrl(rawUrl) {
+  return rawUrl?.startsWith("/__fetch-proxy?") || rawUrl?.startsWith("/__proxy?") || false;
+}
+function isAppApiRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  if (rawUrl.startsWith("/__app-api?")) return true;
+  if (rawUrl.startsWith("/__app-api/")) return true;
+  return false;
+}
+async function handleFetchProxyRequest(req, res) {
+  if (req.method === "OPTIONS") {
+    applyFetchProxyCors(res);
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const params = new URLSearchParams((req.url || "").split("?")[1] || "");
+  const targetUrl = params.get("url");
+  if (!targetUrl) {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("missing url param");
+    return;
+  }
+  let upstreamUrl;
+  try {
+    upstreamUrl = new URL(targetUrl);
+  } catch {
+    applyFetchProxyCors(res);
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("invalid url param");
+    return;
+  }
+  let body;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length > 0) {
+      body = Buffer.concat(chunks);
+    }
+  }
+  const originalMethod = req.method || "GET";
+  const proxy = async (targetUrl2, method, nextBody, redirects) => {
+    const transport = targetUrl2.protocol === "https:" ? import_https.default : import_http.default;
+    const targetHeaders = buildFetchProxyHeaders(req.headers, targetUrl2);
+    if (targetUrl2.origin !== upstreamUrl.origin) {
+      delete targetHeaders.authorization;
+      delete targetHeaders["proxy-authorization"];
+    }
+    if (method === "GET" || method === "HEAD") {
+      delete targetHeaders["content-length"];
+      delete targetHeaders["content-type"];
+    } else if (nextBody) {
+      targetHeaders["content-length"] = String(nextBody.byteLength);
+    }
+    const proxyRes = await new Promise((resolve, reject) => {
+      const proxyReq = transport.request(
+        {
+          hostname: targetUrl2.hostname,
+          port: targetUrl2.port || (targetUrl2.protocol === "https:" ? 443 : 80),
+          path: targetUrl2.pathname + targetUrl2.search,
+          method,
+          headers: targetHeaders,
+          ...loopbackTlsOptions(targetUrl2)
+        },
+        resolve
+      );
+      const abort = () => proxyReq.destroy(new Error("fetch proxy client disconnected"));
+      req.once("aborted", abort);
+      proxyReq.once("close", () => req.off("aborted", abort));
+      proxyReq.once("error", reject);
+      if (nextBody === void 0) proxyReq.end();
+      else proxyReq.end(nextBody);
+    });
+    const status = proxyRes.statusCode ?? 502;
+    const location = proxyRes.headers.location;
+    if (location && (status === 301 || status === 302 || status === 303 || status === 307 || status === 308)) {
+      if (redirects >= 10) {
+        proxyRes.destroy();
+        throw new Error("too many redirects");
+      }
+      const switchToGet = (status === 301 || status === 302) && method === "POST" || status === 303 && method !== "GET" && method !== "HEAD";
+      const redirectUrl = new URL(location, targetUrl2);
+      proxyRes.resume();
+      await (0, import_promises.finished)(proxyRes);
+      await proxy(
+        redirectUrl,
+        switchToGet ? "GET" : method,
+        switchToGet ? void 0 : nextBody,
+        redirects + 1
+      );
+      return;
+    }
+    for (const [key, value] of Object.entries(proxyRes.headers)) {
+      const lowerKey = key.toLowerCase();
+      if (value === void 0 || lowerKey === "set-cookie" || lowerKey === "connection" || lowerKey === "keep-alive" || lowerKey === "proxy-authenticate" || lowerKey === "proxy-authorization" || lowerKey === "te" || lowerKey === "trailer" || lowerKey === "transfer-encoding" || lowerKey === "upgrade" || lowerKey.startsWith("access-control-")) {
+        continue;
+      }
+      res.setHeader(key, value);
+    }
+    applyFetchProxyCors(res);
+    const setCookie = proxyRes.headers["set-cookie"] ?? [];
+    if (setCookie.length > 0) {
+      res.setHeader(
+        "x-sootsim-set-cookie",
+        (Array.isArray(setCookie) ? setCookie : [setCookie]).join(", ")
+      );
+    }
+    res.statusCode = status;
+    await (0, import_promises.pipeline)(proxyRes, res);
+  };
+  try {
+    await proxy(upstreamUrl, originalMethod, body, 0);
+  } catch (err) {
+    if (res.headersSent) {
+      res.destroy(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    applyFetchProxyCors(res);
+    res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end(`fetch proxy error: ${formatFetchProxyError(upstreamUrl.href, err)}`);
+  }
+}
+function handleAppApiRequest(req, res) {
+  const reqUrl = req.url || "";
+  let targetPath = "";
+  let targetOrigin = "";
+  if (reqUrl.startsWith("/__app-api?")) {
+    const parsed = new URL(reqUrl, "http://sootsim.local");
+    targetPath = parsed.searchParams.get("path") || "";
+    targetOrigin = parsed.searchParams.get("origin")?.trim() || "";
+  } else if (reqUrl.startsWith("/__app-api/")) {
+    targetPath = reqUrl.slice("/__app-api".length);
+  } else {
+    return false;
+  }
+  if (!targetOrigin) {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: missing origin query param");
+    return true;
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": req.headers.origin || "*",
+      "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+      "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] || "*",
+      "Access-Control-Allow-Credentials": "true",
+      "Access-Control-Max-Age": "86400"
+    });
+    res.end();
+    return true;
+  }
+  let targetUrl;
+  try {
+    targetUrl = new URL(targetPath, targetOrigin);
+  } catch {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("app-api: invalid origin or path");
+    return true;
+  }
+  const transport = targetUrl.protocol === "https:" ? import_https.default : import_http.default;
+  const fwdHeaders = buildAppApiProxyHeaders(req.headers, targetUrl);
+  const proxyReq = transport.request(
+    {
+      hostname: targetUrl.hostname,
+      port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
+      path: targetUrl.pathname + targetUrl.search,
+      method: req.method,
+      headers: fwdHeaders,
+      ...loopbackTlsOptions(targetUrl)
+    },
+    (proxyRes) => {
+      const exposedHeaders = Object.keys(proxyRes.headers).filter((name) => {
+        const lower = name.toLowerCase();
+        return !lower.startsWith("access-control-") && lower !== "set-cookie";
+      }).join(", ");
+      res.writeHead(proxyRes.statusCode ?? 502, {
+        ...proxyRes.headers,
+        "access-control-allow-origin": req.headers.origin || "*",
+        "access-control-allow-credentials": "true",
+        "access-control-expose-headers": exposedHeaders
+      });
+      proxyRes.pipe(res);
+    }
+  );
+  proxyReq.on("error", (err) => {
+    res.statusCode = 502;
+    res.end(`app proxy error: ${err.message}`);
+  });
+  req.pipe(proxyReq);
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAppApiProxyHeaders,
+  buildFetchProxyHeaders,
+  handleAppApiRequest,
+  handleFetchProxyRequest,
+  isAppApiRequestUrl,
+  isFetchProxyRequestUrl
+});

package/dist-lib/host/fetch-proxy-overrides.cjs

@@ -0,0 +1,63 @@
+/*! rnx v0.1.313 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/fetch-proxy-overrides.ts
+var fetch_proxy_overrides_exports = {};
+__export(fetch_proxy_overrides_exports, {
+  FETCH_PROXY_BROWSER_USER_AGENT: () => FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders: () => getFetchProxyTargetHeaders
+});
+module.exports = __toCommonJS(fetch_proxy_overrides_exports);
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders
+});

package/dist-lib/host/fetch-proxy-overrides.mjs

@@ -0,0 +1,37 @@
+/*! rnx v0.1.313 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/host/fetch-proxy-overrides.ts
+var FETCH_PROXY_BROWSER_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+var HOST_HEADER_OVERRIDES = [
+  {
+    hostSuffix: "uniswap.org",
+    headers: {
+      origin: "https://app.uniswap.org",
+      referer: "https://app.uniswap.org/"
+    },
+    // uniswap's native gateway accepts the app origin, but forcing a desktop
+    // browser ua on native api posts returns a bogus 414/tcp-stack response.
+    suppressBrowserUserAgent: true
+  }
+];
+function headerOverridesFor(hostname) {
+  const host = hostname.toLowerCase();
+  for (const override of HOST_HEADER_OVERRIDES) {
+    if (host === override.hostSuffix || host.endsWith(`.${override.hostSuffix}`)) {
+      return override;
+    }
+  }
+  return void 0;
+}
+function getFetchProxyTargetHeaders(targetUrl) {
+  const hostOverrides = headerOverridesFor(targetUrl.hostname);
+  return {
+    "accept-encoding": "identity",
+    ...hostOverrides?.suppressBrowserUserAgent ? {} : { "user-agent": FETCH_PROXY_BROWSER_USER_AGENT },
+    ...hostOverrides?.headers
+  };
+}
+export {
+  FETCH_PROXY_BROWSER_USER_AGENT,
+  getFetchProxyTargetHeaders
+};

package/dist-lib/host/websocket-proxy.cjs

@@ -0,0 +1,214 @@
+/*! rnx v0.1.313 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/host/websocket-proxy.ts
+var websocket_proxy_exports = {};
+__export(websocket_proxy_exports, {
+  WEBSOCKET_PROXY_PATH: () => WEBSOCKET_PROXY_PATH,
+  handleWebSocketProxyUpgrade: () => handleWebSocketProxyUpgrade,
+  isWebSocketProxyRequestUrl: () => isWebSocketProxyRequestUrl
+});
+module.exports = __toCommonJS(websocket_proxy_exports);
+var import_ws = require("ws");
+var WEBSOCKET_PROXY_PATH = "/__websocket-proxy";
+var STRIP_UPSTREAM_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "upgrade",
+  "transfer-encoding",
+  "content-length",
+  "sec-websocket-accept",
+  "sec-websocket-extensions",
+  "sec-websocket-key",
+  "sec-websocket-protocol",
+  "sec-websocket-version"
+]);
+function rejectUpgrade(socket, status, message) {
+  try {
+    socket.write(
+      `HTTP/1.1 ${status} ${message}\r
+Connection: close\r
+Content-Type: text/plain\r
+Content-Length: ${message.length}\r
+\r
+${message}`
+    );
+  } catch {
+  }
+  socket.destroy();
+}
+function isSameOriginUpgrade(req) {
+  const origin = req.headers.origin;
+  const host = req.headers.host;
+  if (!origin || !host) return false;
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}
+function decodeProxyHeaders(encoded) {
+  if (!encoded) return {};
+  const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const headers = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value == null) continue;
+    if (STRIP_UPSTREAM_HEADERS.has(key.toLowerCase())) continue;
+    headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return headers;
+}
+function getDefaultWebSocketOrigin(targetUrl) {
+  const origin = new URL(targetUrl.href);
+  origin.protocol = targetUrl.protocol === "wss:" ? "https:" : "http:";
+  return origin.origin;
+}
+function getRequestedProtocols(req) {
+  const header = req.headers["sec-websocket-protocol"];
+  const value = Array.isArray(header) ? header.join(",") : header || "";
+  return value.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function safeClose(ws, code, reason) {
+  if (ws.readyState === import_ws.WebSocket.CLOSED || ws.readyState === import_ws.WebSocket.CLOSING) {
+    return;
+  }
+  try {
+    ws.close(code, reason);
+  } catch {
+    ws.terminate();
+  }
+}
+function connectProxyPair(clientWs, upstream) {
+  let closing = false;
+  const closeBoth = (source, target, code, reason) => {
+    if (closing) return;
+    closing = true;
+    safeClose(target, code, reason.toString());
+    if (source.readyState === import_ws.WebSocket.OPEN) {
+      safeClose(source, code, reason.toString());
+    }
+  };
+  clientWs.on("message", (data, isBinary) => {
+    if (upstream.readyState === import_ws.WebSocket.OPEN) {
+      upstream.send(data, { binary: isBinary });
+    }
+  });
+  upstream.on("message", (data, isBinary) => {
+    if (clientWs.readyState === import_ws.WebSocket.OPEN) {
+      clientWs.send(data, { binary: isBinary });
+    }
+  });
+  clientWs.on("close", (code, reason) => closeBoth(clientWs, upstream, code, reason));
+  upstream.on("close", (code, reason) => closeBoth(upstream, clientWs, code, reason));
+  clientWs.on("error", () => safeClose(upstream, 1011, "proxy client error"));
+  upstream.on("error", () => safeClose(clientWs, 1011, "upstream websocket error"));
+}
+function createUpstreamWebSocket(targetUrl, protocols, headers, forwardOrigin) {
+  const upstreamHeaders = { ...headers };
+  const originKeys = Object.keys(upstreamHeaders).filter(
+    (key) => key.toLowerCase() === "origin"
+  );
+  if (forwardOrigin && originKeys.length === 0) {
+    upstreamHeaders.origin = getDefaultWebSocketOrigin(targetUrl);
+  } else if (!forwardOrigin) {
+    for (const key of originKeys) delete upstreamHeaders[key];
+  }
+  if (Object.keys(upstreamHeaders).length === 0)
+    return new import_ws.WebSocket(targetUrl.href, protocols);
+  return new import_ws.WebSocket(targetUrl.href, protocols, {
+    headers: upstreamHeaders
+  });
+}
+function isWebSocketProxyRequestUrl(rawUrl) {
+  if (!rawUrl) return false;
+  try {
+    return new URL(rawUrl, "http://localhost").pathname === WEBSOCKET_PROXY_PATH;
+  } catch {
+    return false;
+  }
+}
+function handleWebSocketProxyUpgrade(req, socket, head, forwardOrigin = true) {
+  if (!isWebSocketProxyRequestUrl(req.url)) return false;
+  if (!isSameOriginUpgrade(req)) {
+    rejectUpgrade(socket, 403, "forbidden websocket proxy origin");
+    return true;
+  }
+  let targetUrl;
+  let headers;
+  try {
+    const requestUrl = new URL(req.url || "/", "http://localhost");
+    const target = requestUrl.searchParams.get("url");
+    if (!target) {
+      rejectUpgrade(socket, 400, "missing websocket proxy url");
+      return true;
+    }
+    targetUrl = new URL(target);
+    if (targetUrl.protocol !== "ws:" && targetUrl.protocol !== "wss:") {
+      rejectUpgrade(socket, 400, "invalid websocket proxy protocol");
+      return true;
+    }
+    headers = decodeProxyHeaders(requestUrl.searchParams.get("headers"));
+  } catch {
+    rejectUpgrade(socket, 400, "invalid websocket proxy request");
+    return true;
+  }
+  const protocols = getRequestedProtocols(req);
+  const upstream = createUpstreamWebSocket(targetUrl, protocols, headers, forwardOrigin);
+  let completed = false;
+  socket.once("close", () => {
+    if (!completed) upstream.terminate();
+  });
+  upstream.once("open", () => {
+    if (completed) return;
+    completed = true;
+    const selectedProtocol = upstream.protocol;
+    const proxyServer = new import_ws.WebSocketServer({
+      noServer: true,
+      clientTracking: false,
+      handleProtocols(requestedProtocols) {
+        return selectedProtocol || requestedProtocols.values().next().value || false;
+      }
+    });
+    proxyServer.handleUpgrade(req, socket, head, (clientWs) => {
+      connectProxyPair(clientWs, upstream);
+    });
+  });
+  upstream.once("error", () => {
+    if (completed) return;
+    completed = true;
+    rejectUpgrade(socket, 502, "upstream websocket error");
+  });
+  upstream.once("close", () => {
+    if (completed) return;
+    completed = true;
+    rejectUpgrade(socket, 502, "upstream websocket closed");
+  });
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WEBSOCKET_PROXY_PATH,
+  handleWebSocketProxyUpgrade,
+  isWebSocketProxyRequestUrl
+});