@barqel/barq 1.0.1 → 1.0.2

package/dist/node-patch.js

@@ -1,6 +1,10 @@
 // src/internal/node-compat.ts
+import cluster from "node:cluster";
 import crypto from "node:crypto";
+import fs from "node:fs";
 import http from "node:http";
+import https from "node:https";
+import { cpus as cpus2 } from "node:os";
 import { Readable } from "node:stream";
 
 // src/app.ts
@@ -495,6 +499,86 @@ function parseIpAddress(value) {
   return bytes;
 }
 
+// src/errors.ts
+class HttpError extends Error {
+  status;
+  body;
+  headers;
+  constructor(status, body, headers) {
+    if (!Number.isInteger(status) || status < 100 || status > 599) {
+      throw new Error(`Invalid HTTP status code: ${status}. Must be an integer between 100 and 599.`);
+    }
+    super(typeof body === "string" ? body : `HTTP ${status}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.body = body ?? { error: defaultStatusText(status) };
+    if (headers !== undefined)
+      this.headers = headers;
+  }
+}
+function defaultStatusText(status) {
+  switch (status) {
+    case 400:
+      return "Bad Request";
+    case 401:
+      return "Unauthorized";
+    case 403:
+      return "Forbidden";
+    case 404:
+      return "Not Found";
+    case 405:
+      return "Method Not Allowed";
+    case 408:
+      return "Request Timeout";
+    case 409:
+      return "Conflict";
+    case 413:
+      return "Payload Too Large";
+    case 418:
+      return "I'm a teapot";
+    case 422:
+      return "Unprocessable Entity";
+    case 429:
+      return "Too Many Requests";
+    case 500:
+      return "Internal Server Error";
+    case 502:
+      return "Bad Gateway";
+    case 503:
+      return "Service Unavailable";
+    case 504:
+      return "Gateway Timeout";
+    default:
+      return status >= 500 ? "Internal Server Error" : "Error";
+  }
+}
+function safeJson(status, body, headers) {
+  try {
+    const init = headers !== undefined ? { status, headers } : { status };
+    return json(body, init);
+  } catch {
+    return new Response("Internal Server Error", {
+      status: 500,
+      headers: { "content-type": "text/plain; charset=utf-8" }
+    });
+  }
+}
+function errorToResponse(err, development) {
+  if (err instanceof Response) {
+    return err;
+  }
+  if (err instanceof HttpError) {
+    return safeJson(err.status, err.body, err.headers);
+  }
+  if (development) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : undefined;
+    return safeJson(500, { error: "Internal Server Error", message, stack });
+  }
+  return safeJson(500, { error: "Internal Server Error" });
+}
+var createErrorResponse = errorToResponse;
+
 // src/internal/pathname.ts
 function decodeSegment(seg) {
   if (seg.indexOf("%") === -1)
@@ -541,9 +625,6 @@ function hasDotSegment(path) {
   }
   return false;
 }
-function hasEncodedSlash(path) {
-  return path.includes("%2f") || path.includes("%2F");
-}
 function targetStart(url) {
   if (url.charCodeAt(0) === 47)
     return 0;
@@ -596,11 +677,11 @@ function scanPathname(url) {
       end = hash;
   }
   const raw = url.slice(slash, end);
+  if (raw.indexOf("%00") !== -1 || raw.indexOf("\x00") !== -1) {
+    throw new HttpError(400, { error: "Bad Request" });
+  }
   if (raw.indexOf(".") === -1 && raw.indexOf("%") === -1)
     return raw;
-  if (hasEncodedSlash(raw)) {
-    return raw;
-  }
   return hasDotSegment(raw) ? normalizeDotSegments(raw) : raw;
 }
 function parseRequestTarget(url) {
@@ -626,11 +707,10 @@ function parseRequestTarget(url) {
       query = hash !== -1 && hash > end ? url.slice(end + 1, hash) : url.slice(end + 1);
     }
     const raw = url.slice(slash, end);
-    if (hasEncodedSlash(raw)) {
-      pathname = raw;
-    } else {
-      pathname = hasDotSegment(raw) ? normalizeDotSegments(raw) : raw;
+    if (raw.indexOf("%00") !== -1 || raw.indexOf("\x00") !== -1) {
+      throw new HttpError(400, { error: "Bad Request" });
     }
+    pathname = hasDotSegment(raw) ? normalizeDotSegments(raw) : raw;
   }
   return { pathname, query };
 }
@@ -654,17 +734,20 @@ function findQueryParam(url, name, startPos) {
   const queryStart = startPos !== undefined && startPos >= 0 ? startPos : url.indexOf("?");
   if (queryStart === -1)
     return null;
+  const hashPos = url.indexOf("#", queryStart);
+  const len = hashPos === -1 ? url.length : hashPos;
   let s = queryStart + 1;
-  const len = url.length;
   const nameLen = name.length;
   while (s < len) {
     if (url.startsWith(name, s)) {
       const eqPos = s + nameLen;
+      if (eqPos >= len)
+        return "";
       const nextChar = url.charCodeAt(eqPos);
       if (nextChar === 61) {
         const valStart = eqPos + 1;
         let amp = url.indexOf("&", valStart);
-        if (amp === -1)
+        if (amp === -1 || amp > len)
           amp = len;
         const val = url.slice(valStart, amp);
         if (val.indexOf("+") === -1 && val.indexOf("%") === -1) {
@@ -672,12 +755,12 @@ function findQueryParam(url, name, startPos) {
         }
         return decodeQueryComponent(val);
       }
-      if (nextChar === 38 || eqPos === len) {
+      if (nextChar === 38) {
         return "";
       }
     }
     const amp = url.indexOf("&", s);
-    if (amp === -1)
+    if (amp === -1 || amp >= len)
       break;
     s = amp + 1;
   }
@@ -688,12 +771,13 @@ function findQueryParamAll(url, name) {
   const queryStart = url.indexOf("?");
   if (queryStart === -1)
     return res;
-  const len = url.length;
+  const hashPos = url.indexOf("#", queryStart);
+  const len = hashPos === -1 ? url.length : hashPos;
   let s = queryStart + 1;
   const nLen = name.length;
   while (s < len) {
     let amp = url.indexOf("&", s);
-    if (amp === -1)
+    if (amp === -1 || amp > len)
       amp = len;
     let eq = url.indexOf("=", s);
     if (eq === -1 || eq > amp)
@@ -718,12 +802,13 @@ function parseAllQueryParams(url) {
   const qIdx = url.indexOf("?");
   if (qIdx === -1)
     return Object.create(null);
-  const len = url.length;
+  const hashPos = url.indexOf("#", qIdx);
+  const len = hashPos === -1 ? url.length : hashPos;
   const res = Object.create(null);
   let s = qIdx + 1;
   while (s < len) {
     let amp = url.indexOf("&", s);
-    if (amp === -1)
+    if (amp === -1 || amp > len)
       amp = len;
     let eq = url.indexOf("=", s);
     if (eq === -1 || eq > amp)
@@ -866,12 +951,10 @@ class Context {
       this._getLazy().ip = directIp;
       return directIp;
     }
-    for (const name of ["cf-connecting-ip", "x-real-ip"]) {
-      const candidate = this.req.headers.get(name)?.trim();
-      if (candidate && isValidIpAddress(candidate)) {
-        this._getLazy().ip = candidate;
-        return candidate;
-      }
+    const realIp = this.req.headers.get("x-real-ip")?.trim();
+    if (realIp && isValidIpAddress(realIp)) {
+      this._getLazy().ip = realIp;
+      return realIp;
     }
     this._getLazy().ip = directIp;
     return directIp;
@@ -985,86 +1068,6 @@ class Context {
   }
 }
 
-// src/errors.ts
-class HttpError extends Error {
-  status;
-  body;
-  headers;
-  constructor(status, body, headers) {
-    if (!Number.isInteger(status) || status < 100 || status > 599) {
-      throw new Error(`Invalid HTTP status code: ${status}. Must be an integer between 100 and 599.`);
-    }
-    super(typeof body === "string" ? body : `HTTP ${status}`);
-    this.name = "HttpError";
-    this.status = status;
-    this.body = body ?? { error: defaultStatusText(status) };
-    if (headers !== undefined)
-      this.headers = headers;
-  }
-}
-function defaultStatusText(status) {
-  switch (status) {
-    case 400:
-      return "Bad Request";
-    case 401:
-      return "Unauthorized";
-    case 403:
-      return "Forbidden";
-    case 404:
-      return "Not Found";
-    case 405:
-      return "Method Not Allowed";
-    case 408:
-      return "Request Timeout";
-    case 409:
-      return "Conflict";
-    case 413:
-      return "Payload Too Large";
-    case 418:
-      return "I'm a teapot";
-    case 422:
-      return "Unprocessable Entity";
-    case 429:
-      return "Too Many Requests";
-    case 500:
-      return "Internal Server Error";
-    case 502:
-      return "Bad Gateway";
-    case 503:
-      return "Service Unavailable";
-    case 504:
-      return "Gateway Timeout";
-    default:
-      return status >= 500 ? "Internal Server Error" : "Error";
-  }
-}
-function safeJson(status, body, headers) {
-  try {
-    const init = headers !== undefined ? { status, headers } : { status };
-    return json(body, init);
-  } catch {
-    return new Response("Internal Server Error", {
-      status: 500,
-      headers: { "content-type": "text/plain; charset=utf-8" }
-    });
-  }
-}
-function errorToResponse(err, development) {
-  if (err instanceof Response) {
-    return err;
-  }
-  if (err instanceof HttpError) {
-    return safeJson(err.status, err.body, err.headers);
-  }
-  if (development) {
-    const message = err instanceof Error ? err.message : String(err);
-    const stack = err instanceof Error ? err.stack : undefined;
-    return safeJson(500, { error: "Internal Server Error", message, stack });
-  }
-  return safeJson(500, { error: "Internal Server Error" });
-}
-var createErrorResponse = errorToResponse;
-
 // src/internal/scan.ts
 var ESCAPE_JSON_CHARS_RE = /[\u0000-\u001f"\\]/;
 function escapeJsonString(value) {
@@ -2071,13 +2074,13 @@ async function stopServer(server, hardTimeoutMs) {
   let forced = false;
   let stopPromise = null;
   try {
-    stopPromise = server.stop().then(() => {});
+    stopPromise = Promise.resolve(server.stop()).then(() => {});
     await Promise.race([
       stopPromise,
       new Promise((resolve) => {
         timer = setTimeout(() => {
           forced = true;
-          stopPromise = server.stop(true).then(() => {});
+          stopPromise = Promise.resolve(server.stop(true)).then(() => {});
           resolve();
         }, hardTimeoutMs);
         timer?.unref?.();
@@ -2107,7 +2110,6 @@ var METHOD_BITS = {
   HEAD: 1 << 5,
   OPTIONS: 1 << 6
 };
-var _ALL_METHODS_BITMASK = (1 << 7) - 1;
 var STATIC_CHILD_SCAN_THRESHOLD = 4;
 function methodBit(method) {
   return METHOD_BITS[method] ?? 0;
@@ -2159,10 +2161,10 @@ function cloneNode(node) {
 var MAX_OPTIONAL_PARAMS = 8;
 function parsePattern(pattern) {
   if (pattern.length === 0 || pattern.charCodeAt(0) !== 47) {
-    throw new Error(`Invalid route pattern "${pattern}": must start with '/'`);
+    throw new Error(`Invalid route pattern "${pattern}": must start with /`);
   }
   if (pattern.indexOf("#") !== -1) {
-    throw new Error(`Invalid route pattern "${pattern}": must not contain '#'`);
+    throw new Error(`Invalid route pattern "${pattern}": must not contain #`);
   }
   let p = pattern;
   if (p.length > 1 && p.charCodeAt(p.length - 1) === 47) {
@@ -2176,7 +2178,7 @@ function parsePattern(pattern) {
     const end = slash === -1 ? p.length : slash;
     const seg = p.slice(i, end);
     if (seg.length === 0) {
-      throw new Error(`Invalid route pattern "${pattern}": empty segment ('//')`);
+      throw new Error(`Invalid route pattern "${pattern}": empty segment (//)`);
     }
     const c0 = seg.charCodeAt(0);
     if (seg.includes("?") && !(c0 === 58 && seg.endsWith("?") && seg.indexOf("?") === seg.length - 1)) {
@@ -2198,7 +2200,7 @@ function parsePattern(pattern) {
       segments.push(optional ? { kind: "param", name, optional: true } : { kind: "param", name });
     } else if (c0 === 42) {
       if (end !== p.length) {
-        throw new Error(`Invalid route pattern "${pattern}": wildcard '*' must be the final segment`);
+        throw new Error(`Invalid route pattern "${pattern}": wildcard * must be the final segment`);
       }
       const name = seg.length > 1 ? seg.slice(1) : null;
       if (name !== null) {
@@ -2290,7 +2292,7 @@ function matchNode(rootNode, pathname, startI, method, paramNames, paramValues,
         child = staticChildren.get(pathname.slice(i, segEnd));
       }
       if (child !== undefined) {
-        const hasParamChildren = node.paramChildren !== null && node.paramChildren.size > 0;
+        const hasParamChildren = node.paramChild !== null || node.paramChildren !== null && node.paramChildren.size > 0;
         if (!hasParamChildren && node.wildcardChild === null) {
           node = child;
           i = nextI;
@@ -2306,9 +2308,39 @@ function matchNode(rootNode, pathname, startI, method, paramNames, paramValues,
         }
       }
     }
-    const paramChildren = node.paramChildren ?? (node.paramChild !== null && node.paramName !== null ? new Map([[node.paramName, node.paramChild]]) : null);
-    if (paramChildren !== null && paramChildren.size > 0) {
-      for (const [paramName, child] of paramChildren) {
+    if (node.paramChild !== null && node.paramName !== null) {
+      const child = node.paramChild;
+      const paramName = node.paramName;
+      if (nextI >= len && child.handlers !== null) {
+        let leafH = child.handlers[method];
+        if (leafH === undefined && method === "HEAD")
+          leafH = child.handlers.GET;
+        if (leafH !== undefined) {
+          const paramVal = pathname.indexOf("%", i) !== -1 ? decodeParam(pathname.slice(i, segEnd)) : pathname.slice(i, segEnd);
+          const p = {
+            [paramName]: paramVal,
+            [MATCH_HANDLER]: leafH
+          };
+          if (depth === 0)
+            return p;
+          for (let k = 0;k < depth; k++) {
+            p[paramNames[k]] = paramValues[k];
+          }
+          return p;
+        }
+      }
+      paramNames[depth] = paramName;
+      paramValues[depth] = decodeParam(pathname.slice(i, segEnd));
+      const res = matchNode(child, pathname, nextI, method, paramNames, paramValues, depth + 1);
+      if (res !== null) {
+        if (MATCH_NOT_ALLOWED in res) {
+          notAllowedCandidate ??= res;
+        } else {
+          return res;
+        }
+      }
+    } else if (node.paramChildren !== null && node.paramChildren.size > 0) {
+      for (const [paramName, child] of node.paramChildren) {
         if (nextI >= len && child.handlers !== null) {
           let leafH = child.handlers[method];
           if (leafH === undefined && method === "HEAD")
@@ -2475,17 +2507,6 @@ class SegmentTrie {
         this.maxStaticLength = cleanPattern.length;
       }
     }
-    for (const seg of segments) {
-      if (seg.kind === "static") {} else if (seg.kind === "param") {
-        if (isPureStatic) {
-          throw new Error(`Internal error: param segment in pure static route`);
-        }
-      } else {
-        if (isPureStatic) {
-          throw new Error(`Internal error: wildcard segment in pure static route`);
-        }
-      }
-    }
     let node = this.root;
     for (const seg of segments) {
       if (seg.kind === "static") {
@@ -2868,12 +2889,6 @@ var FAST_JSON_HEADERS = new Headers({
 var FAST_TEXT_HEADERS = new Headers({
   "content-type": "text/plain; charset=utf-8"
 });
-var _FAST_JSON_INIT = Object.freeze({
-  headers: FAST_JSON_HEADERS
-});
-var _FAST_TEXT_INIT = Object.freeze({
-  headers: FAST_TEXT_HEADERS
-});
 
 class ReadonlySetView {
   source;
@@ -3054,12 +3069,16 @@ class FastLightContext {
     return this;
   }
   get url() {
-    return this._url ?? (this._url = this.req.url);
+    if (this._url === undefined) {
+      this._url = this.req.url;
+    }
+    return this._url;
   }
   get pathname() {
-    if (this._pathname !== undefined)
-      return this._pathname;
-    return this._pathname = scanPathname(this.url);
+    if (this._pathname === undefined) {
+      this._pathname = scanPathname(this.url);
+    }
+    return this._pathname;
   }
   queryParam(name) {
     let u = this._url;
@@ -3093,6 +3112,19 @@ class FastLightContext {
     return this.req.body;
   }
 }
+var lightContextPool = [];
+function acquireLightContext(req, params) {
+  const popped = lightContextPool.pop();
+  if (popped !== undefined) {
+    return popped.init(req, params);
+  }
+  return new FastLightContext(req, params);
+}
+function releaseLightContext(ctx) {
+  if (lightContextPool.length < 128) {
+    lightContextPool.push(ctx);
+  }
+}
 function reportWebSocketError(handler, ws, error) {
   if (!handler) {
     console.error("Unhandled WebSocket callback error:", error);
@@ -3193,12 +3225,12 @@ function canonicalizeRoutePattern(pattern) {
 }
 function validateRoutePattern(pattern) {
   if (pattern.length === 0 || pattern.charCodeAt(0) !== 47) {
-    throw new Error(`Invalid route pattern "${pattern}": must start with '/'`);
+    throw new Error(`Invalid route pattern "${pattern}": must start with /`);
   }
   if (pattern === "/")
     return;
   if (pattern.indexOf("#") !== -1) {
-    throw new Error(`Invalid route pattern "${pattern}": must not contain '#'`);
+    throw new Error(`Invalid route pattern "${pattern}": must not contain #`);
   }
   const segments = pattern.split("/");
   if (segments.length - 1 > MAX_ROUTE_SEGMENTS) {
@@ -3207,11 +3239,11 @@ function validateRoutePattern(pattern) {
   for (let i = 1;i < segments.length; i++) {
     const seg = segments[i];
     if (seg.length === 0) {
-      throw new Error(`Invalid route pattern "${pattern}": empty segment ('//')`);
+      throw new Error(`Invalid route pattern "${pattern}": empty segment (//)`);
     }
     const decoded = decodeSegment2(seg);
     if (decoded === "." || decoded === "..") {
-      throw new Error(`Invalid route pattern "${pattern}": dot segments '.', '..' not allowed in route patterns`);
+      throw new Error(`Invalid route pattern "${pattern}": dot segments ., .. not allowed in route patterns`);
     }
   }
 }
@@ -3685,11 +3717,15 @@ class App {
             }
           } else if (nr.isParamsOnly && raw) {
             const analysis = analyzeHandler(raw);
-            if (analysis.paramSerializer && raw.constructor.name !== "AsyncFunction") {
+            if (analysis.paramSerializer) {
               const serializer = analysis.paramSerializer;
               const responseInit = { headers: FAST_JSON_HEADERS };
               methodMap[nr.method] = (req) => {
                 const params = req.params ?? EMPTY_PARAMS;
+                const syncRes = raw({ params });
+                if (isThenable(syncRes)) {
+                  return Promise.resolve(syncRes).then((val) => val instanceof Response ? val : typeof val === "object" && val !== null ? Response.json(val) : new Response(String(val)));
+                }
                 return new Response(serializer(params), responseInit);
               };
             } else {
@@ -3724,48 +3760,36 @@ class App {
                 methodMap.HEAD = () => new Response(null, { headers: FAST_JSON_HEADERS });
             }
           } else if (nr.isLightweight && raw) {
-            const isAsync = raw.constructor.name === "AsyncFunction";
-            const reusedLightCtx = new FastLightContext(null, EMPTY_PARAMS);
-            let lightCtxInUse = false;
             methodMap[nr.method] = (req) => {
               const params = isDyn ? req.params ?? EMPTY_PARAMS : EMPTY_PARAMS;
-              const useFresh = isAsync || lightCtxInUse;
-              const ctx = useFresh ? new FastLightContext(req, params) : reusedLightCtx.init(req, params);
-              if (!useFresh)
-                lightCtxInUse = true;
+              const ctx = acquireLightContext(req, params);
               let res;
               try {
                 res = raw(ctx);
               } catch (err) {
-                if (!useFresh)
-                  lightCtxInUse = false;
+                releaseLightContext(ctx);
                 return errorToResponse(err, this.development);
               }
               if (typeof res === "object" && res !== null) {
                 if (res instanceof Response) {
-                  if (!useFresh)
-                    lightCtxInUse = false;
+                  releaseLightContext(ctx);
                   return res;
                 }
                 if (!isThenable(res)) {
-                  if (!useFresh)
-                    lightCtxInUse = false;
+                  releaseLightContext(ctx);
                   return Response.json(res);
                 }
               } else if (typeof res === "string") {
-                if (!useFresh)
-                  lightCtxInUse = false;
+                releaseLightContext(ctx);
                 return new Response(res, { headers: FAST_TEXT_HEADERS });
               } else if (!isThenable(res)) {
-                if (!useFresh)
-                  lightCtxInUse = false;
+                releaseLightContext(ctx);
                 return new Response(JSON.stringify(res), {
                   headers: FAST_JSON_HEADERS
                 });
               }
               return Promise.resolve(res).then((r) => {
-                if (!useFresh)
-                  lightCtxInUse = false;
+                releaseLightContext(ctx);
                 if (r instanceof Response)
                   return r;
                 if (typeof r === "object" && r !== null)
@@ -3776,8 +3800,7 @@ class App {
                   return new Response(r, { headers: FAST_TEXT_HEADERS });
                 return finalizeValue(r);
               }).catch((err) => {
-                if (!useFresh)
-                  lightCtxInUse = false;
+                releaseLightContext(ctx);
                 return errorToResponse(err, this.development);
               });
             };
@@ -3824,7 +3847,7 @@ class App {
                   return isThenable(res) ? res.then(stripBody) : stripBody(res);
                 }
               }
-              return new Response(`{"error":"Method Not Allowed"}`, {
+              return new Response('{"error":"Method Not Allowed"}', {
                 status: 405,
                 headers: {
                   "content-type": "application/json; charset=utf-8",
@@ -3973,6 +3996,8 @@ class App {
       throw new Error("Cannot start cluster without an application entry file");
     }
     const processes = [];
+    let crashCount = 0;
+    let lastReset = Date.now();
     const spawnWorker = () => {
       const proc = Bun.spawn([process.execPath, "run", entry], {
         env: {
@@ -3984,10 +4009,25 @@ class App {
       });
       proc.exited.then((_code) => {
         if (this.stopPromise === null && this.clusterProcesses !== null) {
+          const now = Date.now();
+          if (now - lastReset > 5000) {
+            crashCount = 0;
+            lastReset = now;
+          }
+          crashCount++;
           const idx = processes.indexOf(proc);
           if (idx !== -1) {
             processes.splice(idx, 1);
           }
+          if (crashCount > 15) {
+            console.error("[Barq Cluster] Workers restarting too fast. Throttling respawn.");
+            setTimeout(() => {
+              if (this.stopPromise === null && this.clusterProcesses !== null) {
+                processes.push(spawnWorker());
+              }
+            }, 2000);
+            return;
+          }
           processes.push(spawnWorker());
         }
       });
@@ -4096,6 +4136,300 @@ function stripBody(res) {
 
 // src/internal/node-compat.ts
 var isNode = typeof Bun === "undefined";
+var WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+var nodeTopics = new Map;
+
+class NodeServerWebSocket {
+  socket;
+  data;
+  readyState = 1;
+  remoteAddress;
+  topics = new Set;
+  buffer = Buffer.alloc(0);
+  fragments = [];
+  fragmentOpcode = 0;
+  maxPayloadLength;
+  handlers;
+  appHandlers;
+  constructor(socket, data, wsOptions) {
+    this.socket = socket;
+    this.data = data;
+    this.remoteAddress = ("remoteAddress" in socket ? socket.remoteAddress : "") || "";
+    this.maxPayloadLength = wsOptions?.maxPayloadLength ?? 16 * 1024 * 1024;
+    this.appHandlers = wsOptions;
+    const internal = data?._barqInternal ? data.handlers : undefined;
+    this.handlers = internal;
+    socket.on("data", (chunk) => this.onData(chunk));
+    socket.on("close", () => this.onClose(1006, ""));
+    socket.on("error", (err) => this.onError(err));
+    socket.on("drain", () => this.onDrain());
+  }
+  send(data) {
+    if (this.readyState !== 1)
+      return -1;
+    let payload;
+    let isText = true;
+    if (typeof data === "string") {
+      payload = Buffer.from(data, "utf8");
+      isText = true;
+    } else if (Buffer.isBuffer(data)) {
+      payload = data;
+      isText = false;
+    } else if (ArrayBuffer.isView(data)) {
+      payload = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+      isText = false;
+    } else {
+      payload = Buffer.from(String(data), "utf8");
+      isText = true;
+    }
+    this.sendFrame(isText ? 1 : 2, payload);
+    return payload.length;
+  }
+  subscribe(room) {
+    let set = nodeTopics.get(room);
+    if (!set) {
+      set = new Set;
+      nodeTopics.set(room, set);
+    }
+    set.add(this);
+    this.topics.add(room);
+  }
+  unsubscribe(room) {
+    const set = nodeTopics.get(room);
+    if (set) {
+      set.delete(this);
+      if (set.size === 0)
+        nodeTopics.delete(room);
+    }
+    this.topics.delete(room);
+  }
+  isSubscribed(room) {
+    return this.topics.has(room);
+  }
+  publish(room, message, _compress) {
+    const set = nodeTopics.get(room);
+    if (!set || set.size === 0)
+      return 0;
+    let sent = 0;
+    for (const client of set) {
+      if (client !== this && client.readyState === 1) {
+        client.send(message);
+        sent++;
+      }
+    }
+    return sent;
+  }
+  ping(data = "") {
+    if (this.readyState !== 1)
+      return;
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    this.sendFrame(9, buf);
+  }
+  pong(data = "") {
+    if (this.readyState !== 1)
+      return;
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    this.sendFrame(10, buf);
+  }
+  cork(callback) {
+    return callback(this);
+  }
+  close(code = 1000, reason = "") {
+    if (this.readyState >= 2)
+      return;
+    this.readyState = 2;
+    const reasonBuf = Buffer.from(reason, "utf8");
+    const payload = Buffer.allocUnsafe(2 + reasonBuf.length);
+    payload.writeUInt16BE(code, 0);
+    reasonBuf.copy(payload, 2);
+    this.sendFrame(8, payload);
+    this.socket.end();
+  }
+  terminate() {
+    this.readyState = 3;
+    this.socket.destroy();
+  }
+  sendFrame(opcode, payload) {
+    if (this.socket.destroyed)
+      return;
+    const len = payload.length;
+    let header;
+    if (len <= 125) {
+      header = Buffer.allocUnsafe(2);
+      header[0] = 128 | opcode & 15;
+      header[1] = len;
+    } else if (len <= 65535) {
+      header = Buffer.allocUnsafe(4);
+      header[0] = 128 | opcode & 15;
+      header[1] = 126;
+      header.writeUInt16BE(len, 2);
+    } else {
+      header = Buffer.allocUnsafe(10);
+      header[0] = 128 | opcode & 15;
+      header[1] = 127;
+      header.writeBigUInt64BE(BigInt(len), 2);
+    }
+    this.socket.write(Buffer.concat([header, payload]));
+  }
+  onData(chunk) {
+    this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+    while (this.buffer.length >= 2) {
+      const byte0 = this.buffer[0];
+      const byte1 = this.buffer[1];
+      const fin = (byte0 & 128) !== 0;
+      const opcode = byte0 & 15;
+      const masked = (byte1 & 128) !== 0;
+      if (!masked) {
+        this.close(1002, "Protocol error: unmasked client frame");
+        this.onClose(1002, "Protocol error: unmasked client frame");
+        return;
+      }
+      let payloadLen = byte1 & 127;
+      let offset = 2;
+      if (payloadLen === 126) {
+        if (this.buffer.length < 4)
+          return;
+        payloadLen = this.buffer.readUInt16BE(2);
+        offset = 4;
+      } else if (payloadLen === 127) {
+        if (this.buffer.length < 10)
+          return;
+        const high = this.buffer.readUInt32BE(2);
+        const low = this.buffer.readUInt32BE(6);
+        payloadLen = high * 4294967296 + low;
+        offset = 10;
+      }
+      if (payloadLen > this.maxPayloadLength) {
+        this.close(1009, "Message Too Big");
+        return;
+      }
+      const maskLen = 4;
+      const totalLen = offset + maskLen + payloadLen;
+      if (this.buffer.length < totalLen)
+        return;
+      const maskKey = this.buffer.subarray(offset, offset + 4);
+      const rawPayload = this.buffer.subarray(offset + maskLen, totalLen);
+      const payload = Buffer.allocUnsafe(payloadLen);
+      for (let i = 0;i < payloadLen; i++) {
+        payload[i] = rawPayload[i] ^ maskKey[i & 3];
+      }
+      this.buffer = this.buffer.subarray(totalLen);
+      if (opcode === 8) {
+        let code = 1000;
+        let reason = "";
+        if (payload.length >= 2) {
+          code = payload.readUInt16BE(0);
+          if (payload.length > 2) {
+            reason = payload.subarray(2).toString("utf8");
+          }
+        }
+        if (this.readyState === 1) {
+          this.close(code, reason);
+        }
+        this.onClose(code, reason);
+        return;
+      }
+      if (opcode === 9) {
+        this.sendFrame(10, payload);
+        continue;
+      }
+      if (opcode === 10) {
+        continue;
+      }
+      if (!fin) {
+        if (opcode !== 0) {
+          this.fragmentOpcode = opcode;
+          this.fragments = [payload];
+        } else {
+          this.fragments.push(payload);
+        }
+        continue;
+      }
+      let fullPayload = payload;
+      let effectiveOpcode = opcode;
+      if (opcode === 0) {
+        this.fragments.push(payload);
+        fullPayload = Buffer.concat(this.fragments);
+        effectiveOpcode = this.fragmentOpcode;
+        this.fragments = [];
+        this.fragmentOpcode = 0;
+      }
+      const message = effectiveOpcode === 1 ? fullPayload.toString("utf8") : fullPayload;
+      this.onMessage(message);
+    }
+  }
+  dispatchOpen() {
+    try {
+      this.handlers?.open?.(this);
+      this.appHandlers?.open?.(this);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+  onMessage(msg) {
+    try {
+      this.handlers?.message?.(this, msg);
+      this.appHandlers?.message?.(this, msg);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+  onClose(code, reason) {
+    if (this.readyState === 3)
+      return;
+    this.readyState = 3;
+    for (const room of this.topics) {
+      const set = nodeTopics.get(room);
+      if (set) {
+        set.delete(this);
+        if (set.size === 0)
+          nodeTopics.delete(room);
+      }
+    }
+    this.topics.clear();
+    try {
+      this.handlers?.close?.(this, code, reason);
+      this.appHandlers?.close?.(this, code, reason);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+  onError(err) {
+    try {
+      if (this.handlers?.error) {
+        this.handlers.error(this, err);
+      } else if (this.appHandlers?.error) {
+        this.appHandlers.error(this, err);
+      }
+    } catch (e) {
+      console.error("Unhandled WebSocket error:", e);
+    }
+  }
+  onDrain() {
+    try {
+      this.handlers?.drain?.(this);
+      this.appHandlers?.drain?.(this);
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+}
+function resolveTlsData(input) {
+  if (!input)
+    return;
+  if (Buffer.isBuffer(input) || typeof input === "string") {
+    if (typeof input === "string" && !input.includes(`
+`) && (input.startsWith("./") || input.startsWith("/") || input.includes("."))) {
+      try {
+        if (fs.existsSync(input)) {
+          return fs.readFileSync(input);
+        }
+      } catch {}
+    }
+    return input;
+  }
+  return;
+}
 if (isNode) {
   if (typeof globalThis.Bun === "undefined") {
     Object.defineProperty(globalThis, "Bun", {
@@ -4119,15 +4453,59 @@ if (isNode) {
     });
   }
   App.prototype.listen = function(port) {
-    const rawPort = port ?? this["_options"]?.port ?? 3000;
-    const hostname = this["_options"]?.hostname ?? "0.0.0.0";
-    const listenPort = rawPort === 0 ? Math.floor(Math.random() * 20000) + 30000 : rawPort;
-    const server = http.createServer(async (req, res) => {
+    const app = this;
+    const rawPort = port ?? app._options?.port ?? 3000;
+    const hostname = app._options?.hostname ?? "0.0.0.0";
+    const activeSockets = new Set;
+    let inFlightRequests = 0;
+    let isDraining = false;
+    const fastRoutes = new Map;
+    if (app.nativeRoutes && !app.hasMiddlewares && app.errorResolver === undefined) {
+      for (const nr of app.nativeRoutes) {
+        if (!nr.isDynamic && nr.isContextFree && nr.rawHandler) {
+          fastRoutes.set(`${nr.method}:${nr.pattern}`, nr.rawHandler);
+        }
+      }
+    }
+    const requestListener = async (req, res) => {
+      inFlightRequests++;
+      if (isDraining) {
+        res.setHeader("Connection", "close");
+      }
+      const onFinished = () => {
+        inFlightRequests--;
+        res.removeListener("finish", onFinished);
+        res.removeListener("close", onFinished);
+      };
+      res.on("finish", onFinished);
+      res.on("close", onFinished);
+      const method = req.method || "GET";
+      const rawUrl = req.url || "/";
+      const pathname = scanPathname(rawUrl);
+      const fastHandler = fastRoutes.get(`${method}:${pathname}`);
+      if (fastHandler) {
+        try {
+          const val = fastHandler();
+          if (typeof val === "string") {
+            res.writeHead(200, {
+              "content-type": "text/plain; charset=utf-8"
+            });
+            res.end(val);
+            return;
+          }
+          if (typeof val === "object" && val !== null && !(val instanceof Response)) {
+            res.writeHead(200, {
+              "content-type": "application/json; charset=utf-8"
+            });
+            res.end(JSON.stringify(val));
+            return;
+          }
+        } catch {}
+      }
       try {
         const protocol = req.socket?.encrypted ? "https" : "http";
         const host = req.headers.host || "localhost";
-        const url = `${protocol}://${host}${req.url || "/"}`;
-        const method = req.method || "GET";
+        const url = `${protocol}://${host}${rawUrl}`;
         let reqBody;
         if (method !== "GET" && method !== "HEAD") {
           reqBody = Readable.toWeb(req);
@@ -4139,40 +4517,228 @@ if (isNode) {
           duplex: "half"
         });
         const remoteIp = req.socket.remoteAddress || "";
-        const webRes = await this["handle"](webReq, {
-          requestIP: () => remoteIp ? { address: remoteIp } : null
-        });
-        res.statusCode = webRes.status;
-        res.statusMessage = webRes.statusText;
+        let upgraded = false;
+        const serverShim = {
+          requestIP: () => remoteIp ? { address: remoteIp } : null,
+          upgrade: (_request, options) => {
+            const secKey = req.headers["sec-websocket-key"];
+            if (!secKey || typeof secKey !== "string")
+              return false;
+            const acceptKey = crypto.createHash("sha1").update(secKey + WS_GUID).digest("base64");
+            req.socket.write(`HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${acceptKey}\r
+\r
+`);
+            const ws = new NodeServerWebSocket(req.socket, options?.data, app._options?.websocket);
+            upgraded = true;
+            ws.dispatchOpen();
+            return true;
+          }
+        };
+        const webRes = await app.handle(webReq, serverShim);
+        if (upgraded)
+          return;
+        const resHeaders = {};
         webRes.headers.forEach((val, key) => {
-          res.setHeader(key, val);
+          resHeaders[key] = val;
         });
-        if (!webRes.body) {
+        const getSetCookie = webRes.headers.getSetCookie;
+        if (typeof getSetCookie === "function") {
+          const cookies = getSetCookie.call(webRes.headers);
+          if (cookies && cookies.length > 0) {
+            resHeaders["set-cookie"] = cookies;
+          }
+        }
+        res.writeHead(webRes.status, webRes.statusText || undefined, resHeaders);
+        if (webRes.body) {
+          const nodeStream = Readable.fromWeb(webRes.body);
+          nodeStream.pipe(res);
+        } else {
           res.end();
-          return;
         }
-        const nodeStream = Readable.fromWeb(webRes.body);
-        nodeStream.pipe(res);
       } catch (err) {
         console.error("Barq Node Adapter Error:", err);
         if (!res.headersSent) {
-          res.statusCode = 500;
-          res.setHeader("Content-Type", "application/json");
+          res.writeHead(500, {
+            "content-type": "application/json; charset=utf-8"
+          });
           res.end('{"error":"Internal Server Error"}');
         }
       }
+    };
+    const tlsConfig = app._options?.tls;
+    const hasTls = Boolean(tlsConfig && (tlsConfig.key || tlsConfig.cert));
+    const server = hasTls ? https.createServer({
+      key: resolveTlsData(tlsConfig?.key),
+      cert: resolveTlsData(tlsConfig?.cert),
+      ca: resolveTlsData(tlsConfig?.ca),
+      passphrase: tlsConfig?.passphrase
+    }, requestListener) : http.createServer(requestListener);
+    server.on("connection", (socket) => {
+      activeSockets.add(socket);
+      socket.on("close", () => activeSockets.delete(socket));
     });
-    server.listen(listenPort, hostname);
-    return {
-      port: listenPort,
+    server.on("upgrade", async (req, socket, head) => {
+      activeSockets.add(socket);
+      socket.on("close", () => activeSockets.delete(socket));
+      const protocol = socket?.encrypted ? "https" : "http";
+      const host = req.headers.host || "localhost";
+      const fullUrl = `${protocol}://${host}${req.url || "/"}`;
+      let upgradedSocket = null;
+      const serverShim = {
+        requestIP: () => ({
+          address: ("remoteAddress" in socket ? socket.remoteAddress : "") || ""
+        }),
+        upgrade: (_request, options) => {
+          const secKey = req.headers["sec-websocket-key"];
+          if (!secKey || typeof secKey !== "string")
+            return false;
+          const acceptKey = crypto.createHash("sha1").update(secKey + WS_GUID).digest("base64");
+          socket.write(`HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${acceptKey}\r
+\r
+`);
+          const ws = new NodeServerWebSocket(socket, options?.data, app._options?.websocket);
+          upgradedSocket = ws;
+          if (head && head.length > 0) {
+            socket.unshift(head);
+          }
+          ws.dispatchOpen();
+          return true;
+        }
+      };
+      const webReq = new Request(fullUrl, {
+        method: "GET",
+        headers: req.headers
+      });
+      try {
+        const webRes = await app.handle(webReq, serverShim);
+        if (!upgradedSocket) {
+          const status = webRes.status || 400;
+          const statusText = webRes.statusText || "Bad Request";
+          socket.write(`HTTP/1.1 ${status} ${statusText}\r
+Connection: close\r
+\r
+`);
+          socket.destroy();
+        }
+      } catch {
+        if (!upgradedSocket) {
+          socket.write(`HTTP/1.1 500 Internal Server Error\r
+Connection: close\r
+\r
+`);
+          socket.destroy();
+        }
+      }
+    });
+    server.listen(rawPort, hostname);
+    const serverHandle = {
+      get port() {
+        const addr = server.address();
+        return addr && typeof addr === "object" ? addr.port : rawPort;
+      },
       hostname,
-      stop: () => new Promise((resolve) => {
-        server.close(() => resolve());
-        if (typeof server.closeAllConnections === "function") {
-          server.closeAllConnections();
+      stop: (hardTimeoutMs) => new Promise((resolve) => {
+        if (hardTimeoutMs === true) {
+          for (const socket of activeSockets) {
+            socket.destroy();
+          }
+          activeSockets.clear();
+          server.close(() => resolve({ forced: true, pending: 0 }));
+          return;
+        }
+        isDraining = true;
+        const timeout = typeof hardTimeoutMs === "number" ? hardTimeoutMs : 5000;
+        let timer;
+        let resolved = false;
+        const done = (forced) => {
+          if (resolved)
+            return;
+          resolved = true;
+          if (timer !== undefined)
+            clearTimeout(timer);
+          const pending = activeSockets.size;
+          if (forced) {
+            for (const socket of activeSockets) {
+              socket.destroy();
+            }
+            activeSockets.clear();
+          }
+          server.close(() => resolve({ forced, pending: forced ? pending : 0 }));
+        };
+        timer = setTimeout(() => done(true), timeout);
+        if (typeof timer.unref === "function")
+          timer.unref();
+        server.close(() => {
+          if (!resolved) {
+            resolved = true;
+            if (timer !== undefined)
+              clearTimeout(timer);
+            resolve({ forced: false, pending: 0 });
+          }
+        });
+        if (inFlightRequests === 0) {
+          done(false);
         }
       })
     };
+    return serverHandle;
+  };
+  App.prototype.cluster = function(port) {
+    const app = this;
+    const rawPort = port ?? app._options?.port ?? 3000;
+    const hostname = app._options?.hostname ?? "0.0.0.0";
+    const listenPort = rawPort === 0 ? 3000 : rawPort;
+    if (cluster.isPrimary) {
+      const numCPUs = cpus2().length;
+      const workers = [];
+      let crashCount = 0;
+      let lastReset = Date.now();
+      const spawnWorker = () => {
+        const worker = cluster.fork({
+          ...process.env,
+          PORT: String(listenPort)
+        });
+        worker.on("exit", () => {
+          const now = Date.now();
+          if (now - lastReset > 5000) {
+            crashCount = 0;
+            lastReset = now;
+          }
+          crashCount++;
+          const idx = workers.indexOf(worker);
+          if (idx !== -1)
+            workers.splice(idx, 1);
+          if (crashCount > 15) {
+            console.error("[Barq Cluster] Node workers restarting too fast. Throttling respawn.");
+            setTimeout(() => {
+              workers.push(spawnWorker());
+            }, 2000);
+            return;
+          }
+          workers.push(spawnWorker());
+        });
+        return worker;
+      };
+      for (let i = 0;i < numCPUs; i++) {
+        workers.push(spawnWorker());
+      }
+      return {
+        port: listenPort,
+        hostname,
+        stop: async () => {
+          for (const w of workers) {
+            w.kill("SIGTERM");
+          }
+        }
+      };
+    }
+    return this.listen(listenPort);
   };
 }
 // src/cors.ts
@@ -4301,4 +4867,4 @@ export {
   validateJson
 };
 
-//# debugId=CB52E520E9F56C4264756E2164756E21
+//# debugId=9C2F2B32771A43B764756E2164756E21