@barqel/barq 1.0.0 → 1.0.2

package/dist/node-patch.js

@@ -0,0 +1,4870 @@
+// 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
+import { cpus } from "node:os";
+
+// src/cookies.ts
+import { timingSafeEqual } from "node:crypto";
+
+class CookieJarImpl {
+  secret;
+  onMutation;
+  state;
+  constructor(secret, requestHeaders, onMutation) {
+    this.secret = secret;
+    this.onMutation = onMutation;
+    this.state = { cookies: null, requestHeaders, pending: null };
+  }
+  get(name) {
+    return getCookies(this.state).get(name);
+  }
+  getSigned(name, customSecret) {
+    const signed = getCookies(this.state).get(name);
+    if (!signed)
+      return null;
+    const signingSecret = customSecret ?? this.secret;
+    if (!signingSecret)
+      return null;
+    return unsign(signed, signingSecret);
+  }
+  set(name, value, options) {
+    const cookieOptions = snapshotOptions(options);
+    validateCookie(name, cookieOptions);
+    getCookies(this.state).set(name, value);
+    getPending(this.state).push({
+      name,
+      headerString: buildCookieString(name, value, cookieOptions)
+    });
+    this.onMutation?.();
+  }
+  setSigned(name, value, options, customSecret) {
+    const signingSecret = customSecret ?? this.secret;
+    if (!signingSecret) {
+      throw new Error("A non-empty secret is required to set a signed cookie");
+    }
+    const cookieOptions = snapshotOptions(options);
+    validateCookie(name, cookieOptions);
+    const signed = sign(value, signingSecret);
+    getCookies(this.state).set(name, signed);
+    getPending(this.state).push({
+      name,
+      headerString: buildCookieString(name, signed, cookieOptions)
+    });
+    this.onMutation?.();
+  }
+  delete(name, options) {
+    const cookieOptions = snapshotOptions(options);
+    validateCookie(name, cookieOptions);
+    getCookies(this.state).delete(name);
+    getPending(this.state).push({
+      name,
+      headerString: buildCookieString(name, "", {
+        ...cookieOptions,
+        maxAge: 0,
+        expires: new Date(0)
+      })
+    });
+    this.onMutation?.();
+  }
+  hasPending() {
+    return (this.state.pending?.length ?? 0) > 0;
+  }
+  apply(headers) {
+    const pending = this.state.pending;
+    if (pending === null)
+      return;
+    for (const cookie of pending) {
+      headers.append("set-cookie", cookie.headerString);
+    }
+    pending.length = 0;
+  }
+}
+function normalizeSameSite(value) {
+  if (!value)
+    return "Lax";
+  const lower = value.toLowerCase();
+  if (lower === "strict")
+    return "Strict";
+  if (lower === "lax")
+    return "Lax";
+  if (lower === "none")
+    return "None";
+  return value;
+}
+function buildCookieString(name, value, options) {
+  validateCookie(name, options);
+  let cookie = `${name}=${encodeURIComponent(value)}`;
+  if (options.path)
+    cookie += `; Path=${options.path}`;
+  if (options.domain)
+    cookie += `; Domain=${options.domain}`;
+  if (options.maxAge !== undefined)
+    cookie += `; Max-Age=${options.maxAge}`;
+  if (options.expires)
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.httpOnly !== false)
+    cookie += "; HttpOnly";
+  if (options.secure)
+    cookie += "; Secure";
+  const sameSite = normalizeSameSite(options.sameSite);
+  if (sameSite)
+    cookie += `; SameSite=${sameSite}`;
+  return cookie;
+}
+function sign(value, secret) {
+  const hasher = new Bun.CryptoHasher("sha256", secret);
+  hasher.update(value);
+  const sig = hasher.digest("base64url");
+  return `${value}.${sig}`;
+}
+function unsign(signedValue, secret) {
+  const lastDot = signedValue.lastIndexOf(".");
+  if (lastDot <= 0 || lastDot === signedValue.length - 1)
+    return null;
+  const value = signedValue.slice(0, lastDot);
+  const sig = signedValue.slice(lastDot + 1);
+  const hasher = new Bun.CryptoHasher("sha256", secret);
+  hasher.update(value);
+  const expected = hasher.digest("base64url");
+  const actualBytes = Buffer.from(sig);
+  const expectedBytes = Buffer.from(expected);
+  if (actualBytes.length !== expectedBytes.length)
+    return null;
+  if (!timingSafeEqual(actualBytes, expectedBytes))
+    return null;
+  return value;
+}
+function decodeCookieValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function validateCookie(name, options) {
+  if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) {
+    throw new TypeError("Cookie name must be a valid HTTP token");
+  }
+  if (options.path !== undefined && (!options.path.startsWith("/") || /[;\r\n\0]/.test(options.path))) {
+    throw new TypeError("Cookie path must start with '/' and contain no controls");
+  }
+  if (options.domain !== undefined && (!/^(?:\.?[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)*$/.test(options.domain) || options.domain.includes(".."))) {
+    throw new TypeError("Cookie domain is invalid");
+  }
+  if (options.maxAge !== undefined && (!Number.isSafeInteger(options.maxAge) || options.maxAge < 0)) {
+    throw new TypeError("Cookie maxAge must be a non-negative safe integer");
+  }
+  if (options.expires !== undefined && !Number.isFinite(options.expires.getTime())) {
+    throw new TypeError("Cookie expires must be a valid Date");
+  }
+  if (options.sameSite !== undefined && !["strict", "lax", "none"].includes(options.sameSite.toLowerCase())) {
+    throw new TypeError("Cookie sameSite must be Strict, Lax, or None");
+  }
+  if (options.sameSite?.toLowerCase() === "none" && !options.secure) {
+    throw new TypeError("SameSite=None cookies must also be Secure");
+  }
+  if (name.startsWith("__Secure-") && !options.secure) {
+    throw new TypeError("__Secure- cookies must also be Secure");
+  }
+  if (name.startsWith("__Host-") && (!options.secure || options.path !== "/" || options.domain !== undefined)) {
+    throw new TypeError("__Host- cookies must be Secure, use Path=/, and omit Domain");
+  }
+}
+function snapshotOptions(options) {
+  if (!options)
+    return {};
+  return {
+    ...options,
+    ...options.expires === undefined ? {} : { expires: new Date(options.expires.getTime()) }
+  };
+}
+function parseCookieHeader(header) {
+  const cookies = new Map;
+  let pos = 0;
+  const len = header.length;
+  while (pos < len) {
+    while (pos < len && header.charCodeAt(pos) === 32)
+      pos++;
+    if (pos >= len)
+      break;
+    const eq = header.indexOf("=", pos);
+    if (eq === -1)
+      break;
+    const name = header.slice(pos, eq).trim();
+    pos = eq + 1;
+    let end = header.indexOf(";", pos);
+    if (end === -1)
+      end = len;
+    const value = header.slice(pos, end);
+    if (name)
+      cookies.set(name, decodeCookieValue(value));
+    pos = end + 1;
+  }
+  return cookies;
+}
+function getCookies(state) {
+  if (state.cookies !== null)
+    return state.cookies;
+  const header = state.requestHeaders?.get("cookie") ?? "";
+  state.requestHeaders = undefined;
+  state.cookies = header.length === 0 ? new Map : parseCookieHeader(header);
+  return state.cookies;
+}
+function getPending(state) {
+  if (state.pending === null)
+    state.pending = [];
+  return state.pending;
+}
+function createCookieJar(secret, requestHeaders, onMutation) {
+  return new CookieJarImpl(secret ?? "", requestHeaders, onMutation);
+}
+function applyPendingCookies(cookieJar, headers) {
+  if (!(cookieJar instanceof CookieJarImpl)) {
+    throw new TypeError("CookieJar was not created by Barq");
+  }
+  cookieJar.apply(headers);
+}
+
+// src/http.ts
+var NULL_BODY_STATUSES = new Set([204, 205, 304]);
+var DEFAULT_JSON_HEADERS = Object.freeze({
+  "content-type": "application/json; charset=utf-8"
+});
+var DEFAULT_JSON_INIT = Object.freeze({
+  status: 200,
+  headers: DEFAULT_JSON_HEADERS
+});
+var DEFAULT_TEXT_HEADERS = Object.freeze({
+  "content-type": "text/plain; charset=utf-8"
+});
+function isNullBodyStatus(status) {
+  return status >= 100 && status < 200 || NULL_BODY_STATUSES.has(status);
+}
+function createJsonResponse(data, init) {
+  if (data === undefined || typeof data === "function" || typeof data === "symbol") {
+    return new Response(JSON.stringify(data), init);
+  }
+  return Response.json(data, init);
+}
+function json(data, init) {
+  if (init === undefined) {
+    if (typeof data === "object" && data !== null) {
+      return new Response(JSON.stringify(data), DEFAULT_JSON_INIT);
+    }
+    return createJsonResponse(data, DEFAULT_JSON_INIT);
+  }
+  if (typeof init === "number") {
+    if (isNullBodyStatus(init)) {
+      return new Response(null, { status: init });
+    }
+    return createJsonResponse(data, {
+      status: init,
+      headers: DEFAULT_JSON_HEADERS
+    });
+  }
+  const status = init.status ?? 200;
+  if (isNullBodyStatus(status)) {
+    return new Response(null, { ...init, status });
+  }
+  if (init.headers === undefined) {
+    return createJsonResponse(data, {
+      ...init,
+      status,
+      headers: DEFAULT_JSON_HEADERS
+    });
+  }
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return createJsonResponse(data, { ...init, status, headers });
+}
+function text(body, init) {
+  if (init === undefined) {
+    return new Response(body);
+  }
+  if (typeof init === "number") {
+    if (isNullBodyStatus(init)) {
+      return new Response(null, { status: init });
+    }
+    return new Response(body, {
+      status: init,
+      headers: DEFAULT_TEXT_HEADERS
+    });
+  }
+  const status = init.status ?? 200;
+  if (isNullBodyStatus(status)) {
+    return new Response(null, { ...init, status });
+  }
+  if (init.headers === undefined) {
+    return new Response(body, {
+      ...init,
+      status,
+      headers: DEFAULT_TEXT_HEADERS
+    });
+  }
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "text/plain; charset=utf-8");
+  }
+  return new Response(body, { ...init, status, headers });
+}
+function empty(status = 204, headers) {
+  const init = headers !== undefined ? { status, headers } : { status };
+  return new Response(null, init);
+}
+var CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+var ALLOWED_REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+function redirect(url, status = 302, allowlist) {
+  if (!ALLOWED_REDIRECT_STATUSES.has(status)) {
+    throw new TypeError(`redirect status must be one of: ${Array.from(ALLOWED_REDIRECT_STATUSES).join(", ")}`);
+  }
+  if (CONTROL_CHARS.test(url) || url.includes("\\")) {
+    throw new TypeError("redirect target contains control or backslash characters");
+  }
+  if (url.charCodeAt(0) === 47) {
+    if (url.charCodeAt(1) === 47) {
+      throw new TypeError("redirect target must not be protocol-relative");
+    }
+  } else {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new TypeError("redirect target must be a root-relative path or an absolute URL");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new TypeError(`redirect target protocol is not allowed: ${parsed.protocol}`);
+    }
+    const host = parsed.host.toLowerCase();
+    if (allowlist !== undefined && !allowlist.has(host)) {
+      throw new TypeError(`redirect target host is not allowlisted: ${host}`);
+    }
+  }
+  const res = new Response(null, { status });
+  res.headers.set("location", url);
+  return res;
+}
+
+// src/internal/ip.ts
+import { isIP } from "node:net";
+function ipv4ToNumber(bytes) {
+  return (bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]) >>> 0;
+}
+function compileTrustProxy(trust) {
+  if (!trust)
+    return () => false;
+  if (trust === true)
+    return () => true;
+  if (typeof trust === "function")
+    return trust;
+  const ranges = typeof trust === "string" ? [trust] : trust;
+  if (ranges.length === 0)
+    return () => false;
+  const matchers = [];
+  for (const range of ranges) {
+    if (range === "loopback") {
+      matchers.push((ip) => {
+        const addr = parseIpAddress(ip);
+        if (addr === null)
+          return false;
+        if (addr.length === 4)
+          return addr[0] === 127;
+        return addr.slice(0, 15).every((b) => b === 0) && addr[15] === 1;
+      });
+      continue;
+    }
+    const slash = range.indexOf("/");
+    const netText = slash === -1 ? range : range.slice(0, slash);
+    const netBytes = parseIpAddress(netText);
+    if (!netBytes)
+      continue;
+    const bits = slash === -1 ? netBytes.length * 8 : Number(range.slice(slash + 1));
+    if (netBytes.length === 4) {
+      const netNum = ipv4ToNumber(netBytes);
+      const mask = bits === 0 ? 0 : ~0 << 32 - bits >>> 0;
+      const expected = (netNum & mask) >>> 0;
+      matchers.push((ip) => {
+        const addr = parseIpAddress(ip);
+        if (addr?.length !== 4)
+          return false;
+        return (ipv4ToNumber(addr) & mask) >>> 0 === expected;
+      });
+    } else {
+      matchers.push((ip) => ipMatchesRange(ip, range));
+    }
+  }
+  return (ip) => matchers.some((m) => m(ip));
+}
+function isIpRange(value) {
+  if (value === "loopback")
+    return true;
+  const slash = value.indexOf("/");
+  if (slash !== value.lastIndexOf("/"))
+    return false;
+  const address = slash === -1 ? value : value.slice(0, slash);
+  const bytes = parseIpAddress(address);
+  if (bytes === null)
+    return false;
+  if (slash === -1)
+    return true;
+  const bitsText = value.slice(slash + 1);
+  if (!/^\d+$/.test(bitsText))
+    return false;
+  const bits = Number(bitsText);
+  return Number.isInteger(bits) && bits >= 0 && bits <= bytes.length * 8;
+}
+function ipMatchesRange(ip, range) {
+  const address = parseIpAddress(ip);
+  if (address === null)
+    return false;
+  if (range === "loopback") {
+    if (address.length === 4)
+      return address[0] === 127;
+    return address.slice(0, 15).every((byte) => byte === 0) && address[15] === 1;
+  }
+  const slash = range.indexOf("/");
+  const networkText = slash === -1 ? range : range.slice(0, slash);
+  const network = parseIpAddress(networkText);
+  if (network === null || address.length !== network.length)
+    return false;
+  const bits = slash === -1 ? network.length * 8 : Number(range.slice(slash + 1));
+  if (!Number.isInteger(bits) || bits < 0 || bits > network.length * 8) {
+    return false;
+  }
+  const fullBytes = Math.floor(bits / 8);
+  for (let i = 0;i < fullBytes; i++) {
+    if (address[i] !== network[i])
+      return false;
+  }
+  const remainingBits = bits % 8;
+  if (remainingBits === 0)
+    return true;
+  const mask = 255 << 8 - remainingBits & 255;
+  return (address[fullBytes] & mask) === (network[fullBytes] & mask);
+}
+function isValidIpAddress(value) {
+  return parseIpAddress(value) !== null;
+}
+function parseIpAddress(value) {
+  const version = isIP(value);
+  if (version === 4) {
+    const bytes = value.split(".").map(Number);
+    if (bytes.length !== 4)
+      return null;
+    return Uint8Array.from(bytes);
+  }
+  if (version !== 6)
+    return null;
+  let address = value.toLowerCase();
+  if (address.includes(".")) {
+    const separator = address.lastIndexOf(":");
+    const ipv4 = address.slice(separator + 1).split(".").map(Number);
+    if (separator === -1 || ipv4.length !== 4)
+      return null;
+    const high = (ipv4[0] << 8 | ipv4[1]).toString(16);
+    const low = (ipv4[2] << 8 | ipv4[3]).toString(16);
+    address = `${address.slice(0, separator + 1)}${high}:${low}`;
+  }
+  const halves = address.split("::");
+  if (halves.length > 2)
+    return null;
+  const left = halves[0] ? halves[0].split(":") : [];
+  const right = halves.length === 2 && halves[1] ? halves[1].split(":") : [];
+  const missing = 8 - left.length - right.length;
+  if (halves.length === 1 && missing !== 0 || halves.length === 2 && missing < 1) {
+    return null;
+  }
+  const groups = [
+    ...left,
+    ...new Array(halves.length === 2 ? missing : 0).fill("0"),
+    ...right
+  ];
+  if (groups.length !== 8 || groups.some((group) => !/^[0-9a-f]{1,4}$/.test(group))) {
+    return null;
+  }
+  const bytes = new Uint8Array(16);
+  for (let i = 0;i < groups.length; i++) {
+    const group = Number.parseInt(groups[i], 16);
+    bytes[i * 2] = group >>> 8;
+    bytes[i * 2 + 1] = group & 255;
+  }
+  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)
+    return seg;
+  try {
+    return decodeURIComponent(seg);
+  } catch {
+    return seg;
+  }
+}
+function decodePercentSegment(seg) {
+  try {
+    return decodeURIComponent(seg);
+  } catch {
+    return seg;
+  }
+}
+function isDotSegment(seg) {
+  return seg === "." || seg === "..";
+}
+function hasDotSegment(path) {
+  let i = 0;
+  const len = path.length;
+  while (i < len) {
+    while (i < len && path.charCodeAt(i) === 47)
+      i++;
+    if (i >= len)
+      break;
+    const endIdx = path.indexOf("/", i);
+    const segEnd = endIdx === -1 ? len : endIdx;
+    const segmentLength = segEnd - i;
+    if (segmentLength === 1 && path.charCodeAt(i) === 46 || segmentLength === 2 && path.charCodeAt(i) === 46 && path.charCodeAt(i + 1) === 46) {
+      return true;
+    }
+    const percent = path.indexOf("%", i);
+    if (percent !== -1 && percent < segEnd) {
+      const decoded = decodePercentSegment(path.slice(i, segEnd));
+      if (isDotSegment(decoded))
+        return true;
+    }
+    if (endIdx === -1)
+      break;
+    i = endIdx + 1;
+  }
+  return false;
+}
+function targetStart(url) {
+  if (url.charCodeAt(0) === 47)
+    return 0;
+  if (url.charCodeAt(4) === 58 && url.charCodeAt(5) === 47 && url.charCodeAt(6) === 47)
+    return 7;
+  if (url.charCodeAt(5) === 58 && url.charCodeAt(6) === 47 && url.charCodeAt(7) === 47)
+    return 8;
+  const scheme = url.indexOf("://");
+  return scheme === -1 ? 0 : scheme + 3;
+}
+function normalizeDotSegments(path) {
+  const len = path.length;
+  const segments = [];
+  let start = 0;
+  while (start < len) {
+    while (start < len && path.charCodeAt(start) === 47)
+      start++;
+    if (start >= len)
+      break;
+    const end = path.indexOf("/", start);
+    const segEnd = end === -1 ? len : end;
+    const rawSeg = path.slice(start, segEnd);
+    const decodedSeg = decodeSegment(rawSeg);
+    if (decodedSeg === ".") {} else if (decodedSeg === "..") {
+      segments.pop();
+    } else {
+      segments.push(rawSeg);
+    }
+    if (end === -1)
+      break;
+    start = end + 1;
+  }
+  const res = `/${segments.join("/")}`;
+  const endsWithSlash = path.endsWith("/") || path.endsWith("/.") || path.endsWith("/..");
+  return path.length > 1 && endsWithSlash && res !== "/" ? `${res}/` : res;
+}
+function scanPathname(url) {
+  const s = targetStart(url);
+  const slash = url.indexOf("/", s);
+  if (slash === -1)
+    return "/";
+  let end = url.indexOf("?", slash);
+  if (end === -1) {
+    end = url.indexOf("#", slash);
+    if (end === -1)
+      end = url.length;
+  } else {
+    const hash = url.indexOf("#", slash);
+    if (hash !== -1 && hash < end)
+      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;
+  return hasDotSegment(raw) ? normalizeDotSegments(raw) : raw;
+}
+function parseRequestTarget(url) {
+  const s = targetStart(url);
+  const slash = url.indexOf("/", s);
+  let pathname;
+  let query;
+  if (slash === -1) {
+    pathname = "/";
+    const q = url.indexOf("?", s);
+    const h = url.indexOf("#", s);
+    if (q !== -1 && (h === -1 || q < h)) {
+      query = h === -1 ? url.slice(q + 1) : url.slice(q + 1, h);
+    }
+  } else {
+    let end = url.indexOf("?", slash);
+    const hash = url.indexOf("#", slash);
+    if (hash !== -1 && (end === -1 || hash < end))
+      end = hash;
+    if (end === -1) {
+      end = url.length;
+    } else if (url.charCodeAt(end) === 63) {
+      query = hash !== -1 && hash > end ? url.slice(end + 1, hash) : url.slice(end + 1);
+    }
+    const raw = url.slice(slash, end);
+    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 };
+}
+
+// src/internal/query.ts
+function decodeQueryComponent(value) {
+  const hasPlus = value.indexOf("+") !== -1;
+  const hasPercent = value.indexOf("%") !== -1;
+  if (!hasPlus && !hasPercent)
+    return value;
+  const formValue = hasPlus ? value.replace(/\+/g, " ") : value;
+  if (!hasPercent)
+    return formValue;
+  try {
+    return decodeURIComponent(formValue);
+  } catch {
+    return new URLSearchParams(`v=${value}`).get("v") ?? "";
+  }
+}
+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 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 || amp > len)
+          amp = len;
+        const val = url.slice(valStart, amp);
+        if (val.indexOf("+") === -1 && val.indexOf("%") === -1) {
+          return val;
+        }
+        return decodeQueryComponent(val);
+      }
+      if (nextChar === 38) {
+        return "";
+      }
+    }
+    const amp = url.indexOf("&", s);
+    if (amp === -1 || amp >= len)
+      break;
+    s = amp + 1;
+  }
+  return null;
+}
+function findQueryParamAll(url, name) {
+  const res = [];
+  const queryStart = url.indexOf("?");
+  if (queryStart === -1)
+    return res;
+  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 || amp > len)
+      amp = len;
+    let eq = url.indexOf("=", s);
+    if (eq === -1 || eq > amp)
+      eq = amp;
+    if (eq - s === nLen && url.startsWith(name, s)) {
+      const val = eq < amp ? url.slice(eq + 1, amp) : "";
+      if (val.indexOf("%") === -1 && val.indexOf("+") === -1) {
+        res.push(val);
+      } else {
+        try {
+          res.push(decodeURIComponent(val.replace(/\+/g, " ")));
+        } catch {
+          res.push(val);
+        }
+      }
+    }
+    s = amp + 1;
+  }
+  return res;
+}
+function parseAllQueryParams(url) {
+  const qIdx = url.indexOf("?");
+  if (qIdx === -1)
+    return Object.create(null);
+  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 || amp > len)
+      amp = len;
+    let eq = url.indexOf("=", s);
+    if (eq === -1 || eq > amp)
+      eq = amp;
+    const k = decodeQueryComponent(url.slice(s, eq));
+    const v = eq < amp ? decodeQueryComponent(url.slice(eq + 1, amp)) : "";
+    if (res[k] === undefined)
+      res[k] = v;
+    s = amp + 1;
+  }
+  return res;
+}
+
+// src/context.ts
+var TEXT_DECODER = new TextDecoder;
+
+class Context {
+  req;
+  params;
+  _hasPendingCookies = false;
+  server;
+  application;
+  _pathname;
+  _query = null;
+  _url = null;
+  _queryParams = null;
+  _lazy = null;
+  constructor(req, server, params, application, pathname) {
+    this.req = req;
+    this.server = server;
+    this.params = params;
+    this.application = application;
+    this._pathname = pathname ?? null;
+    this._query = null;
+  }
+  _getLazy() {
+    let lazy = this._lazy;
+    if (lazy === null) {
+      lazy = {};
+      this._lazy = lazy;
+    }
+    return lazy;
+  }
+  get development() {
+    return this.application.development;
+  }
+  get redirectHosts() {
+    return this.application.redirectHosts;
+  }
+  get trustProxy() {
+    return this.application.trustProxy;
+  }
+  get cookies() {
+    const lazy = this._getLazy();
+    if (!lazy.cookies) {
+      lazy.cookies = createCookieJar(this.application.cookieSecret ?? "", this.req.headers, () => {
+        this._hasPendingCookies = true;
+      });
+    }
+    return lazy.cookies;
+  }
+  _cookieJarIfCreated() {
+    return this._lazy?.cookies ?? null;
+  }
+  get state() {
+    const lazy = this._getLazy();
+    if (!lazy.state) {
+      lazy.state = Object.create(null);
+    }
+    return lazy.state;
+  }
+  get valid() {
+    const lazy = this._lazy;
+    if (lazy && lazy.valid !== undefined)
+      return lazy.valid;
+    return lazy?.state?.valid;
+  }
+  set valid(val) {
+    this._getLazy().valid = val;
+    this.state.valid = val;
+  }
+  get pathname() {
+    if (this._pathname !== null)
+      return this._pathname;
+    const p = scanPathname(this.req.url);
+    this._pathname = p;
+    return p;
+  }
+  get query() {
+    if (this._query)
+      return this._query;
+    const url = this.req.url;
+    const qIdx = url.indexOf("?");
+    if (qIdx === -1) {
+      const sp = new URLSearchParams("");
+      this._query = sp;
+      return sp;
+    }
+    const hashIdx = url.indexOf("#", qIdx);
+    const qStr = hashIdx === -1 ? url.slice(qIdx + 1) : url.slice(qIdx + 1, hashIdx);
+    const sp = new URLSearchParams(qStr);
+    this._query = sp;
+    return sp;
+  }
+  queryParam(name) {
+    if (this._query)
+      return this._query.get(name);
+    if (this._queryParams === null) {
+      if (this._url === null)
+        this._url = this.req.url;
+      this._queryParams = parseAllQueryParams(this._url);
+    }
+    return this._queryParams[name] ?? null;
+  }
+  queryParamAll(name) {
+    return this.query.getAll(name);
+  }
+  get ip() {
+    const lazy = this._lazy;
+    if (lazy && typeof lazy.ip === "string")
+      return lazy.ip;
+    const directIp = this.getDirectIp();
+    if (!this.isTrustedProxy(directIp)) {
+      this._getLazy().ip = directIp;
+      return directIp;
+    }
+    const forwarded = this.req.headers.get("x-forwarded-for");
+    if (forwarded) {
+      const hops = forwarded.split(",").map((hop) => hop.trim());
+      if (hops.every(isValidIpAddress)) {
+        let clientIp = directIp;
+        for (let i = hops.length - 1;i >= 0; i--) {
+          if (clientIp && !this.isTrustedProxy(clientIp))
+            break;
+          clientIp = hops[i];
+        }
+        this._getLazy().ip = clientIp;
+        return clientIp;
+      }
+      this._getLazy().ip = directIp;
+      return directIp;
+    }
+    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;
+  }
+  isTrustedProxy(ip) {
+    const trust = this.trustProxy;
+    if (trust === true)
+      return true;
+    if (trust === false || !ip)
+      return false;
+    if (this.application.trustedProxyChecker) {
+      return this.application.trustedProxyChecker(ip);
+    }
+    if (typeof trust === "function")
+      return trust(ip);
+    if (typeof trust !== "string") {
+      return trust.some((range) => ipMatchesRange(ip, range));
+    }
+    return ipMatchesRange(ip, trust);
+  }
+  getDirectIp() {
+    const info = this.server?.requestIP(this.req);
+    return info?.address ?? "";
+  }
+  get bodyStream() {
+    return this.req.body;
+  }
+  stream() {
+    return this.req.body;
+  }
+  _getBodyBuffer() {
+    const lazy = this._getLazy();
+    if (!lazy.bodyBufferPromise) {
+      lazy.bodyBufferPromise = this.req.arrayBuffer().catch((err) => {
+        lazy.bodyBufferPromise = null;
+        throw err;
+      });
+    }
+    return lazy.bodyBufferPromise;
+  }
+  arrayBuffer() {
+    return this._getBodyBuffer();
+  }
+  text() {
+    const lazy = this._getLazy();
+    if (!lazy.textPromise) {
+      lazy.textPromise = this._getBodyBuffer().then((buf) => TEXT_DECODER.decode(buf)).catch((err) => {
+        lazy.textPromise = null;
+        throw err;
+      });
+    }
+    return lazy.textPromise;
+  }
+  json() {
+    const lazy = this._getLazy();
+    if (!lazy.jsonPromise) {
+      lazy.jsonPromise = this._getBodyBuffer().then((buf) => JSON.parse(TEXT_DECODER.decode(buf))).catch((err) => {
+        lazy.jsonPromise = null;
+        throw err;
+      });
+    }
+    return lazy.jsonPromise;
+  }
+  blob() {
+    const lazy = this._getLazy();
+    if (!lazy.blobPromise) {
+      const ct = this.req.headers.get("content-type") ?? "application/octet-stream";
+      lazy.blobPromise = this._getBodyBuffer().then((buf) => new Blob([buf], { type: ct })).catch((err) => {
+        lazy.blobPromise = null;
+        throw err;
+      });
+    }
+    return lazy.blobPromise;
+  }
+  formData() {
+    const lazy = this._getLazy();
+    if (!lazy.formDataPromise) {
+      lazy.formDataPromise = this._getBodyBuffer().then((buf) => {
+        const ct = this.req.headers.get("content-type") ?? "";
+        const tempRes = new Response(buf, {
+          headers: { "content-type": ct }
+        });
+        return tempRes.formData();
+      }).catch((err) => {
+        lazy.formDataPromise = null;
+        throw err;
+      });
+    }
+    return lazy.formDataPromise;
+  }
+  redirect(url, status = 302) {
+    return redirect(url, status, this.redirectHosts);
+  }
+  upgrade(data) {
+    if (!this.server) {
+      throw new Error("Cannot upgrade WebSocket: server instance is not available");
+    }
+    return this.server.upgrade(this.req, { data });
+  }
+  timeout(seconds) {
+    if (this.server) {
+      this.server.timeout(this.req, seconds);
+    }
+    return this;
+  }
+  disableTimeout() {
+    if (this.server) {
+      this.server.timeout(this.req, 0);
+    }
+    return this;
+  }
+}
+
+// src/internal/scan.ts
+var ESCAPE_JSON_CHARS_RE = /[\u0000-\u001f"\\]/;
+function escapeJsonString(value) {
+  if (!ESCAPE_JSON_CHARS_RE.test(value))
+    return value;
+  return JSON.stringify(value).slice(1, -1);
+}
+function isIdentStart(c) {
+  return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 95 || c === 36 || c > 127;
+}
+function isIdentPart(c) {
+  return isIdentStart(c) || c >= 48 && c <= 57;
+}
+function isSpace(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11;
+}
+var KEYWORDS_BEFORE_REGEX = new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+var PUNCT_BEFORE_REGEX = new Set([
+  "(",
+  "[",
+  "{",
+  ",",
+  ";",
+  ":",
+  "?",
+  "!",
+  "=",
+  "==",
+  "===",
+  "!=",
+  "!==",
+  "&&",
+  "||",
+  "??",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "&",
+  "|",
+  "^",
+  "~",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "=>",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "&=",
+  "|=",
+  "^=",
+  "&&=",
+  "||=",
+  "??=",
+  "<<",
+  ">>",
+  ">>>",
+  "<<=",
+  ">>=",
+  ">>>="
+]);
+function tokenize(src) {
+  const tokens = [];
+  const len = src.length;
+  let i = 0;
+  let last = "";
+  while (i < len) {
+    const c = src.charCodeAt(i);
+    if (isSpace(c)) {
+      i++;
+      continue;
+    }
+    if (c === 47 && src.charCodeAt(i + 1) === 47) {
+      i += 2;
+      while (i < len && src.charCodeAt(i) !== 10)
+        i++;
+      continue;
+    }
+    if (c === 47 && src.charCodeAt(i + 1) === 42) {
+      i += 2;
+      while (i < len && !(src.charCodeAt(i) === 42 && src.charCodeAt(i + 1) === 47))
+        i++;
+      i += 2;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      const q = c;
+      const start = i;
+      i++;
+      while (i < len) {
+        const cc = src.charCodeAt(i);
+        if (cc === 92) {
+          i += 2;
+          continue;
+        }
+        if (cc === q) {
+          i++;
+          break;
+        }
+        if (cc === 10)
+          break;
+        i++;
+      }
+      tokens.push({
+        type: "str",
+        value: src.slice(start + 1, i - 1),
+        start,
+        end: i
+      });
+      last = "str";
+      continue;
+    }
+    if (c === 96) {
+      i = tokenizeTemplate(src, i, tokens);
+      last = "template";
+      continue;
+    }
+    if (c === 47) {
+      let isRegex;
+      if (last === "" || last === "regex" || last === "num")
+        isRegex = true;
+      else if (last === "str" || last === "template")
+        isRegex = false;
+      else if (last === "ident")
+        isRegex = KEYWORDS_BEFORE_REGEX.has(last);
+      else
+        isRegex = PUNCT_BEFORE_REGEX.has(last);
+      if (isRegex) {
+        const start = i;
+        i++;
+        let inClass = false;
+        while (i < len) {
+          const cc = src.charCodeAt(i);
+          if (cc === 92) {
+            i += 2;
+            continue;
+          }
+          if (cc === 91) {
+            inClass = true;
+            i++;
+            continue;
+          }
+          if (cc === 93) {
+            inClass = false;
+            i++;
+            continue;
+          }
+          if (cc === 47 && !inClass) {
+            i++;
+            break;
+          }
+          if (cc === 10)
+            break;
+          i++;
+        }
+        while (i < len && isIdentPart(src.charCodeAt(i)))
+          i++;
+        tokens.push({ type: "regex", value: "", start, end: i });
+        last = "regex";
+        continue;
+      }
+      tokens.push({ type: "punct", value: "/", start: i, end: i + 1 });
+      last = "/";
+      i++;
+      continue;
+    }
+    if (isIdentStart(c)) {
+      const start = i;
+      i++;
+      while (i < len && isIdentPart(src.charCodeAt(i)))
+        i++;
+      const value = src.slice(start, i);
+      tokens.push({ type: "ident", value, start, end: i });
+      last = value;
+      continue;
+    }
+    if (c >= 48 && c <= 57) {
+      const start = i;
+      i++;
+      while (i < len) {
+        const cc = src.charCodeAt(i);
+        if (cc >= 48 && cc <= 57 || cc === 46 || cc === 95 || cc >= 97 && cc <= 122 || cc >= 65 && cc <= 90)
+          i++;
+        else if ((cc === 43 || cc === 45) && (src.charCodeAt(i - 1) === 101 || src.charCodeAt(i - 1) === 69))
+          i++;
+        else
+          break;
+      }
+      tokens.push({ type: "num", value: src.slice(start, i), start, end: i });
+      last = "num";
+      continue;
+    }
+    const start = i;
+    const cc2 = src.charCodeAt(i + 1);
+    const cc3 = src.charCodeAt(i + 2);
+    const cc4 = src.charCodeAt(i + 3);
+    let op = src[i];
+    if (c === 62 && cc2 === 62 && cc3 === 62 && cc4 === 61)
+      op = ">>>=";
+    else if (c === 61 && cc2 === 61 && cc3 === 61)
+      op = "===";
+    else if (c === 33 && cc2 === 61 && cc3 === 61)
+      op = "!==";
+    else if (c === 42 && cc2 === 42 && cc3 === 61)
+      op = "**=";
+    else if (c === 60 && cc2 === 60 && cc3 === 61)
+      op = "<<=";
+    else if (c === 62 && cc2 === 62 && cc3 === 61)
+      op = ">>=";
+    else if (c === 62 && cc2 === 62 && cc3 === 62)
+      op = ">>>";
+    else if (c === 46 && cc2 === 46 && cc3 === 46)
+      op = "...";
+    else if (c === 63 && cc2 === 63 && cc3 === 61)
+      op = "??=";
+    else if (c === 38 && cc2 === 38 && cc3 === 61)
+      op = "&&=";
+    else if (c === 124 && cc2 === 124 && cc3 === 61)
+      op = "||=";
+    else if (c === 61 && cc2 === 62)
+      op = "=>";
+    else if (c === 61 && cc2 === 61)
+      op = "==";
+    else if (c === 33 && cc2 === 61)
+      op = "!=";
+    else if (c === 60 && cc2 === 61)
+      op = "<=";
+    else if (c === 62 && cc2 === 61)
+      op = ">=";
+    else if (c === 38 && cc2 === 38)
+      op = "&&";
+    else if (c === 124 && cc2 === 124)
+      op = "||";
+    else if (c === 63 && cc2 === 46)
+      op = "?.";
+    else if (c === 63 && cc2 === 63)
+      op = "??";
+    else if (c === 43 && cc2 === 43)
+      op = "++";
+    else if (c === 45 && cc2 === 45)
+      op = "--";
+    else if (c === 42 && cc2 === 42)
+      op = "**";
+    else if (c === 60 && cc2 === 60)
+      op = "<<";
+    else if (c === 62 && cc2 === 62)
+      op = ">>";
+    else if (c === 43 && cc2 === 61)
+      op = "+=";
+    else if (c === 45 && cc2 === 61)
+      op = "-=";
+    else if (c === 42 && cc2 === 61)
+      op = "*=";
+    else if (c === 47 && cc2 === 61)
+      op = "/=";
+    else if (c === 37 && cc2 === 61)
+      op = "%=";
+    else if (c === 38 && cc2 === 61)
+      op = "&=";
+    else if (c === 124 && cc2 === 61)
+      op = "|=";
+    else if (c === 94 && cc2 === 61)
+      op = "^=";
+    i += op.length;
+    tokens.push({ type: "punct", value: op, start, end: i });
+    last = op;
+  }
+  tokens.push({ type: "eof", value: "", start: len, end: len });
+  return tokens;
+}
+function tokenizeTemplate(src, start, out) {
+  let i = start + 1;
+  const len = src.length;
+  let strStart = i;
+  while (i < len) {
+    const c = src.charCodeAt(i);
+    if (c === 92) {
+      i += 2;
+      continue;
+    }
+    if (c === 96) {
+      if (i > strStart) {
+        out.push({
+          type: "str",
+          value: src.slice(strStart, i),
+          start: strStart,
+          end: i
+        });
+      }
+      return i + 1;
+    }
+    if (c === 36 && src.charCodeAt(i + 1) === 123) {
+      if (i > strStart) {
+        out.push({
+          type: "str",
+          value: src.slice(strStart, i),
+          start: strStart,
+          end: i
+        });
+      }
+      out.push({ type: "punct", value: "${", start: i, end: i + 2 });
+      i += 2;
+      const exprStart = i;
+      let depth = 1;
+      while (i < len && depth > 0) {
+        const cc = src.charCodeAt(i);
+        if (cc === 92) {
+          i += 2;
+          continue;
+        }
+        if (cc === 34 || cc === 39) {
+          const q = cc;
+          i++;
+          while (i < len) {
+            const c2 = src.charCodeAt(i);
+            if (c2 === 92) {
+              i += 2;
+              continue;
+            }
+            if (c2 === q) {
+              i++;
+              break;
+            }
+            i++;
+          }
+          continue;
+        }
+        if (cc === 96) {
+          i = tokenizeTemplate(src, i, out);
+          continue;
+        }
+        if (cc === 123) {
+          depth++;
+          i++;
+          continue;
+        }
+        if (cc === 125) {
+          depth--;
+          if (depth === 0)
+            break;
+          i++;
+          continue;
+        }
+        i++;
+      }
+      const inner = src.slice(exprStart, i);
+      const innerTokens = tokenize(inner);
+      for (const t of innerTokens) {
+        if (t.type === "eof")
+          continue;
+        out.push({ ...t, start: t.start + exprStart, end: t.end + exprStart });
+      }
+      out.push({ type: "punct", value: "}", start: i, end: i + 1 });
+      i++;
+      strStart = i;
+      continue;
+    }
+    i++;
+  }
+  if (i > strStart) {
+    out.push({
+      type: "str",
+      value: src.slice(strStart, i),
+      start: strStart,
+      end: i
+    });
+  }
+  return i;
+}
+function analyzeHandler(fn) {
+  let src;
+  try {
+    src = fn.toString();
+  } catch {
+    return makeUnknown();
+  }
+  const tokens = tokenize(src);
+  let i = 0;
+  if (tokens[i]?.type === "ident" && tokens[i].value === "async")
+    i++;
+  if (tokens[i]?.type === "ident" && tokens[i].value === "function") {
+    i++;
+    if (tokens[i]?.type === "ident")
+      i++;
+  }
+  if (tokens[i]?.type === "punct" && tokens[i].value === "(") {
+    i++;
+    const first = tokens[i];
+    if (first?.type === "punct" && first.value === ")") {
+      i++;
+      const body = walkBody(tokens, i, null);
+      return {
+        isNoArg: true,
+        contextProps: new Set,
+        hasDynamicAccess: false,
+        isDestructured: false,
+        destructuredProps: new Set,
+        literal: body.literal,
+        arglessJsonCall: false,
+        paramSerializer: null,
+        paramParts: null
+      };
+    }
+    if (first?.type === "punct" && first.value === "{") {
+      const { names, next } = parseDestructure(tokens, i);
+      const body = walkBody(tokens, next, null);
+      return {
+        isNoArg: false,
+        contextProps: new Set,
+        hasDynamicAccess: false,
+        isDestructured: true,
+        destructuredProps: names,
+        literal: body.literal,
+        arglessJsonCall: false,
+        paramSerializer: body.paramSerializer,
+        paramParts: body.paramParts
+      };
+    }
+    if (first?.type === "ident") {
+      const name = first.value;
+      i++;
+      const body = walkBody(tokens, i, name);
+      return {
+        isNoArg: false,
+        contextProps: body.props,
+        hasDynamicAccess: body.hasDynamic,
+        isDestructured: false,
+        destructuredProps: new Set,
+        literal: body.literal,
+        arglessJsonCall: body.arglessJsonCall,
+        paramSerializer: body.paramSerializer,
+        paramParts: body.paramParts
+      };
+    }
+    return makeUnknown();
+  }
+  if (tokens[i]?.type === "ident") {
+    const name = tokens[i].value;
+    i++;
+    const body = walkBody(tokens, i, name);
+    return {
+      isNoArg: false,
+      contextProps: body.props,
+      hasDynamicAccess: body.hasDynamic,
+      isDestructured: false,
+      destructuredProps: new Set,
+      literal: body.literal,
+      arglessJsonCall: body.arglessJsonCall,
+      paramSerializer: body.paramSerializer,
+      paramParts: body.paramParts
+    };
+  }
+  return makeUnknown();
+}
+function parseDestructure(tokens, braceStart) {
+  const names = new Set;
+  let i = braceStart + 1;
+  let depth = 1;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t.type === "eof")
+      break;
+    if (t.type === "punct") {
+      if (t.value === "{")
+        depth++;
+      else if (t.value === "}") {
+        depth--;
+        i++;
+        if (depth === 0)
+          break;
+        continue;
+      } else if (t.value === "[")
+        depth += 100;
+      else if (t.value === "]")
+        depth -= 100;
+    }
+    if (t.type === "ident" && depth === 1) {
+      const prev = tokens[i - 1];
+      const next = tokens[i + 1];
+      if (prev?.type === "punct" && prev.value === ":") {
+        names.add(t.value);
+      } else if (next?.type !== "punct" || next.value !== ":") {
+        names.add(t.value);
+      }
+    }
+    i++;
+  }
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t.type === "eof")
+      break;
+    if (t.type === "punct" && t.value === ")") {
+      i++;
+      break;
+    }
+    i++;
+  }
+  return { names, next: i };
+}
+function walkBody(tokens, from, paramName) {
+  const props = new Set;
+  let hasDynamic = false;
+  let arglessJsonCall = false;
+  let bodyStart = -1;
+  let i = from;
+  let parenDepth = 0;
+  if (tokens[from]?.type === "punct" && tokens[from].value === "{") {
+    bodyStart = from + 1;
+  } else {
+    while (i < tokens.length) {
+      const t = tokens[i];
+      if (t.type === "eof")
+        break;
+      if (t.type === "punct") {
+        if (t.value === "(" || t.value === "[" || t.value === "{") {
+          parenDepth++;
+        } else if (t.value === ")" || t.value === "]" || t.value === "}") {
+          if (parenDepth > 0)
+            parenDepth--;
+        } else if (t.value === "=>" && parenDepth === 0) {
+          const next = tokens[i + 1];
+          if (next?.type === "punct" && next.value === "{") {
+            bodyStart = i + 2;
+          } else {
+            bodyStart = i + 1;
+          }
+          break;
+        }
+        if (t.value === ")" && parenDepth === 0 && i + 1 < tokens.length) {
+          const next = tokens[i + 1];
+          if (next?.type === "punct" && next.value === "{") {
+            bodyStart = i + 2;
+            break;
+          }
+        }
+      }
+      i++;
+    }
+  }
+  if (bodyStart < 0) {
+    return {
+      props,
+      hasDynamic,
+      literal: null,
+      arglessJsonCall: false,
+      paramSerializer: null,
+      paramParts: null
+    };
+  }
+  if (paramName !== null) {
+    for (let j = bodyStart;j < tokens.length; j++) {
+      const t = tokens[j];
+      if (t.type === "eof")
+        break;
+      if (t.type !== "ident" || t.value !== paramName)
+        continue;
+      const n = tokens[j + 1];
+      if (!n)
+        continue;
+      if (n.type === "punct" && (n.value === "." || n.value === "?.")) {
+        const key = tokens[j + 2];
+        if (key?.type === "ident") {
+          props.add(key.value);
+          if (key.value === "json") {
+            const pOpen = tokens[j + 3];
+            const pClose = tokens[j + 4];
+            if (pOpen?.type === "punct" && pOpen.value === "(" && pClose?.type === "punct" && pClose.value === ")") {
+              const prev1 = tokens[j - 1];
+              const prev2 = tokens[j - 2];
+              const isPrecededByReturn = prev1?.type === "punct" && prev1.value === "=>" || prev1?.type === "ident" && prev1.value === "return" || prev1?.type === "ident" && prev1.value === "await" && (prev2?.type === "punct" && prev2.value === "=>" || prev2?.type === "ident" && prev2.value === "return");
+              const next1 = tokens[j + 5];
+              const next2 = tokens[j + 6];
+              const isEndOfBody = isBodyEnd(next1) && (next1?.value !== ";" || isBodyEnd(next2));
+              if (isPrecededByReturn && isEndOfBody) {
+                arglessJsonCall = true;
+              }
+            }
+          }
+          j += 2;
+          continue;
+        }
+        hasDynamic = true;
+        continue;
+      }
+      if (n.type === "punct" && n.value === "[") {
+        const key = tokens[j + 2];
+        const close = tokens[j + 3];
+        if (key?.type === "str" && close?.type === "punct" && close.value === "]") {
+          props.add(key.value);
+          j += 3;
+          continue;
+        }
+        hasDynamic = true;
+        continue;
+      }
+      const prev = tokens[j - 1];
+      if (prev?.type === "punct" && prev.value === "...") {
+        hasDynamic = true;
+      }
+    }
+  }
+  const literal = tryExtractLiteral(tokens, bodyStart);
+  const paramExtraction = literal === null ? tryExtractParamSerializer(tokens, bodyStart, paramName) : null;
+  const paramSerializer = paramExtraction?.serializer ?? null;
+  const paramParts = paramExtraction?.parts ?? null;
+  return {
+    props,
+    hasDynamic,
+    literal,
+    arglessJsonCall,
+    paramSerializer,
+    paramParts
+  };
+}
+function isBodyEnd(t) {
+  if (!t)
+    return true;
+  if (t.type === "eof")
+    return true;
+  if (t.type === "punct" && (t.value === ";" || t.value === "}"))
+    return true;
+  return false;
+}
+function tryExtractLiteral(tokens, bodyStart) {
+  const t = tokens[bodyStart];
+  if (!t || t.type === "eof")
+    return null;
+  if (t.type === "ident" && t.value === "return") {
+    return tryExtractLiteral(tokens, bodyStart + 1);
+  }
+  if (t.type === "str") {
+    if (isBodyEnd(tokens[bodyStart + 1])) {
+      return { kind: "string", value: t.value };
+    }
+    return null;
+  }
+  if (t.type === "punct" && t.value === "(") {
+    const inner = tokens[bodyStart + 1];
+    if (inner?.type === "punct" && inner.value === "{") {
+      const obj = extractFlatObject(tokens, bodyStart + 1);
+      if (!obj.ok)
+        return null;
+      const afterBrace = tokens[obj.end];
+      if (afterBrace?.type !== "punct" || afterBrace.value !== ")")
+        return null;
+      if (!isBodyEnd(tokens[obj.end + 1]))
+        return null;
+      return { kind: "json", value: JSON.stringify(obj.value) };
+    }
+    return null;
+  }
+  if (t.type === "punct" && t.value === "{") {
+    const next = tokens[bodyStart + 1];
+    if (next && (next.type === "ident" || next.type === "str" || next.type === "num") && tokens[bodyStart + 2]?.type === "punct" && tokens[bodyStart + 2].value === ":") {
+      const obj = extractFlatObject(tokens, bodyStart);
+      if (obj.ok) {
+        if (isBodyEnd(tokens[obj.end])) {
+          return { kind: "json", value: JSON.stringify(obj.value) };
+        }
+        return null;
+      }
+      return null;
+    }
+    let j = bodyStart + 1;
+    while (j < tokens.length) {
+      const tt = tokens[j];
+      if (tt.type === "eof")
+        return null;
+      if (tt.type === "punct" && tt.value === "}")
+        return null;
+      if (tt.type === "ident" && tt.value === "return") {
+        return tryExtractLiteral(tokens, j + 1);
+      }
+      if (tt.type === "punct" && tt.value === ";")
+        return null;
+      if (tt.type === "ident" && tt.value !== "return")
+        return null;
+      j++;
+    }
+    return null;
+  }
+  return null;
+}
+function extractFlatObject(tokens, braceStart) {
+  let i = braceStart + 1;
+  const obj = {};
+  let expectKey = true;
+  let key = null;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t.type === "eof")
+      return { ok: false };
+    if (t.type === "punct" && t.value === "}") {
+      if (!expectKey)
+        return { ok: false };
+      return { ok: true, end: i + 1, value: obj };
+    }
+    if (expectKey) {
+      if (t.type === "ident" || t.type === "str" || t.type === "num")
+        key = t.value;
+      else
+        return { ok: false };
+      i++;
+      const colon = tokens[i];
+      if (colon?.type !== "punct" || colon.value !== ":")
+        return { ok: false };
+      i++;
+      expectKey = false;
+      continue;
+    }
+    if (t.type === "str") {
+      obj[key] = t.value;
+      i++;
+    } else if (t.type === "num") {
+      obj[key] = Number(t.value);
+      i++;
+    } else if (t.type === "ident") {
+      if (t.value === "true")
+        obj[key] = true;
+      else if (t.value === "false")
+        obj[key] = false;
+      else if (t.value === "null")
+        obj[key] = null;
+      else
+        return { ok: false };
+      i++;
+    } else if (t.type === "punct" && t.value === "!" && tokens[i + 1]?.type === "num") {
+      const n = tokens[i + 1].value;
+      obj[key] = n === "1";
+      i += 2;
+    } else if (t.type === "punct" && t.value === "-" && tokens[i + 1]?.type === "num") {
+      obj[key] = -Number(tokens[i + 1].value);
+      i += 2;
+    } else {
+      return { ok: false };
+    }
+    const sep = tokens[i];
+    if (sep?.type === "punct" && sep.value === ",") {
+      i++;
+      expectKey = true;
+      continue;
+    }
+    if (sep?.type === "punct" && sep.value === "}") {
+      return { ok: true, end: i + 1, value: obj };
+    }
+    return { ok: false };
+  }
+  return { ok: false };
+}
+function extractParamObject(tokens, braceStart, paramName) {
+  let i = braceStart + 1;
+  const parts = [];
+  let expectKey = true;
+  let key = null;
+  let hasParam = false;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t.type === "eof")
+      return { ok: false };
+    if (t.type === "punct" && t.value === "}") {
+      if (!expectKey)
+        return { ok: false };
+      return hasParam ? { ok: true, end: i + 1, parts } : { ok: false };
+    }
+    if (expectKey) {
+      if (t.type === "ident" || t.type === "str" || t.type === "num") {
+        key = t.value;
+      } else {
+        return { ok: false };
+      }
+      i++;
+      const colon = tokens[i];
+      if (colon?.type !== "punct" || colon.value !== ":")
+        return { ok: false };
+      i++;
+      expectKey = false;
+      continue;
+    }
+    if (paramName !== null && t.type === "ident" && t.value === paramName) {
+      const dot1 = tokens[i + 1];
+      const pIdent = tokens[i + 2];
+      const dot2 = tokens[i + 3];
+      const pKey = tokens[i + 4];
+      if (dot1?.type === "punct" && (dot1.value === "." || dot1.value === "?.") && pIdent?.type === "ident" && pIdent.value === "params" && dot2?.type === "punct" && (dot2.value === "." || dot2.value === "?.") && pKey?.type === "ident") {
+        hasParam = true;
+        parts.push({ key, isParam: true, paramKey: pKey.value });
+        i += 5;
+        const sep = tokens[i];
+        if (sep?.type === "punct" && sep.value === ",") {
+          i++;
+          expectKey = true;
+          continue;
+        }
+        if (sep?.type === "punct" && sep.value === "}") {
+          return { ok: true, end: i + 1, parts };
+        }
+        return { ok: false };
+      }
+    }
+    if (t.type === "ident" && t.value === "params") {
+      const dot = tokens[i + 1];
+      const pKey = tokens[i + 2];
+      if (dot?.type === "punct" && (dot.value === "." || dot.value === "?.") && pKey?.type === "ident") {
+        hasParam = true;
+        parts.push({ key, isParam: true, paramKey: pKey.value });
+        i += 3;
+        const sep = tokens[i];
+        if (sep?.type === "punct" && sep.value === ",") {
+          i++;
+          expectKey = true;
+          continue;
+        }
+        if (sep?.type === "punct" && sep.value === "}") {
+          return { ok: true, end: i + 1, parts };
+        }
+        return { ok: false };
+      }
+    }
+    if (t.type === "str") {
+      parts.push({
+        key,
+        isParam: false,
+        literalValue: JSON.stringify(t.value)
+      });
+      i++;
+    } else if (t.type === "num") {
+      parts.push({
+        key,
+        isParam: false,
+        literalValue: t.value
+      });
+      i++;
+    } else if (t.type === "ident") {
+      if (t.value === "true" || t.value === "false" || t.value === "null") {
+        parts.push({
+          key,
+          isParam: false,
+          literalValue: t.value
+        });
+        i++;
+      } else {
+        return { ok: false };
+      }
+    } else if (t.type === "punct" && t.value === "!" && tokens[i + 1]?.type === "num") {
+      parts.push({
+        key,
+        isParam: false,
+        literalValue: tokens[i + 1].value === "1" ? "true" : "false"
+      });
+      i += 2;
+    } else if (t.type === "punct" && t.value === "-" && tokens[i + 1]?.type === "num") {
+      parts.push({
+        key,
+        isParam: false,
+        literalValue: `-${tokens[i + 1].value}`
+      });
+      i += 2;
+    } else {
+      return { ok: false };
+    }
+    const sep = tokens[i];
+    if (sep?.type === "punct" && sep.value === ",") {
+      i++;
+      expectKey = true;
+      continue;
+    }
+    if (sep?.type === "punct" && sep.value === "}") {
+      return hasParam ? { ok: true, end: i + 1, parts } : { ok: false };
+    }
+    return { ok: false };
+  }
+  return { ok: false };
+}
+function buildParamSerializer(parts) {
+  const chunks = [];
+  const keys = [];
+  let current = "{";
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    if (i > 0)
+      current += ",";
+    current += `${JSON.stringify(part.key)}:`;
+    if (part.isParam) {
+      current += '"';
+      chunks.push(current);
+      keys.push(part.paramKey);
+      current = '"';
+    } else {
+      current += part.literalValue;
+    }
+  }
+  current += "}";
+  chunks.push(current);
+  if (keys.length === 1) {
+    const c0 = chunks[0];
+    const c1 = chunks[1];
+    const k0 = keys[0];
+    return (p) => c0 + escapeJsonString(typeof p === "string" ? p : p[k0] ?? "") + c1;
+  }
+  if (keys.length === 2) {
+    const c0 = chunks[0];
+    const c1 = chunks[1];
+    const c2 = chunks[2];
+    const k0 = keys[0];
+    const k1 = keys[1];
+    return (p) => `${c0}${escapeJsonString(typeof p === "string" ? p : p[k0] ?? "")}${c1}${typeof p === "string" ? "" : escapeJsonString(p[k1] ?? "")}${c2}`;
+  }
+  return (p) => {
+    let out = chunks[0];
+    for (let j = 0;j < keys.length; j++) {
+      out += escapeJsonString(typeof p === "string" ? j === 0 ? p : "" : p[keys[j]] ?? "") + chunks[j + 1];
+    }
+    return out;
+  };
+}
+function tryExtractParamSerializer(tokens, bodyStart, paramName) {
+  const t = tokens[bodyStart];
+  if (!t || t.type === "eof")
+    return null;
+  if (t.type === "punct" && t.value === "(") {
+    const inner = tokens[bodyStart + 1];
+    if (inner?.type === "punct" && inner.value === "{") {
+      const res = extractParamObject(tokens, bodyStart + 1, paramName);
+      if (!res.ok)
+        return null;
+      const afterBrace = tokens[res.end];
+      if (afterBrace?.type !== "punct" || afterBrace.value !== ")")
+        return null;
+      if (!isBodyEnd(tokens[res.end + 1]))
+        return null;
+      return { serializer: buildParamSerializer(res.parts), parts: res.parts };
+    }
+    return null;
+  }
+  if (t.type === "punct" && t.value === "{") {
+    const next = tokens[bodyStart + 1];
+    if (next && (next.type === "ident" || next.type === "str" || next.type === "num") && tokens[bodyStart + 2]?.type === "punct" && tokens[bodyStart + 2].value === ":") {
+      const res = extractParamObject(tokens, bodyStart, paramName);
+      if (res.ok && isBodyEnd(tokens[res.end])) {
+        return {
+          serializer: buildParamSerializer(res.parts),
+          parts: res.parts
+        };
+      }
+      return null;
+    }
+    let j = bodyStart + 1;
+    while (j < tokens.length) {
+      const tt = tokens[j];
+      if (tt.type === "eof")
+        return null;
+      if (tt.type === "punct" && tt.value === "}")
+        return null;
+      if (tt.type === "ident" && tt.value === "return") {
+        return tryExtractParamSerializer(tokens, j + 1, paramName);
+      }
+      if (tt.type === "punct" && tt.value === ";")
+        return null;
+      if (tt.type === "ident" && tt.value !== "return")
+        return null;
+      j++;
+    }
+    return null;
+  }
+  return null;
+}
+function makeUnknown() {
+  return {
+    isNoArg: false,
+    contextProps: new Set,
+    hasDynamicAccess: true,
+    isDestructured: false,
+    destructuredProps: new Set,
+    literal: null,
+    arglessJsonCall: false,
+    paramSerializer: null,
+    paramParts: null
+  };
+}
+
+// src/internal/shutdown.ts
+async function stopServer(server, hardTimeoutMs) {
+  let timer;
+  let forced = false;
+  let stopPromise = null;
+  try {
+    stopPromise = Promise.resolve(server.stop()).then(() => {});
+    await Promise.race([
+      stopPromise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          forced = true;
+          stopPromise = Promise.resolve(server.stop(true)).then(() => {});
+          resolve();
+        }, hardTimeoutMs);
+        timer?.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+    }
+  }
+  await stopPromise;
+  return {
+    forced,
+    pending: 0
+  };
+}
+
+// src/internal/trie.ts
+var MATCH_HANDLER = Symbol("barq.match.handler");
+var MATCH_NOT_ALLOWED = Symbol("barq.match.not-allowed");
+var METHOD_BITS = {
+  GET: 1 << 0,
+  POST: 1 << 1,
+  PUT: 1 << 2,
+  DELETE: 1 << 3,
+  PATCH: 1 << 4,
+  HEAD: 1 << 5,
+  OPTIONS: 1 << 6
+};
+var STATIC_CHILD_SCAN_THRESHOLD = 4;
+function methodBit(method) {
+  return METHOD_BITS[method] ?? 0;
+}
+function createNode() {
+  return {
+    staticChildren: null,
+    staticChildKeys: [],
+    staticChildNodes: [],
+    paramChildren: null,
+    paramChild: null,
+    paramName: null,
+    wildcardChild: null,
+    wildcardName: null,
+    handlers: null,
+    allow: null,
+    notAllowed: null
+  };
+}
+function cloneNode(node) {
+  const staticChildren = node.staticChildren ? new Map(Array.from(node.staticChildren, ([key, child]) => [
+    key,
+    cloneNode(child)
+  ])) : null;
+  const staticChildKeys = node.staticChildKeys.slice();
+  const staticChildNodes = staticChildren ? staticChildKeys.map((key) => staticChildren.get(key)) : [];
+  const paramChildren = node.paramChildren ? new Map(Array.from(node.paramChildren, ([name, child]) => [
+    name,
+    cloneNode(child)
+  ])) : null;
+  let handlers = null;
+  if (node.handlers !== null) {
+    handlers = Object.assign(Object.create(null), node.handlers);
+  }
+  return {
+    staticChildren,
+    staticChildKeys,
+    staticChildNodes,
+    paramChildren,
+    paramChild: node.paramChild ? cloneNode(node.paramChild) : null,
+    paramName: node.paramName,
+    wildcardChild: node.wildcardChild ? cloneNode(node.wildcardChild) : null,
+    wildcardName: node.wildcardName,
+    handlers,
+    allow: node.allow,
+    notAllowed: node.notAllowed
+  };
+}
+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 /`);
+  }
+  if (pattern.indexOf("#") !== -1) {
+    throw new Error(`Invalid route pattern "${pattern}": must not contain #`);
+  }
+  let p = pattern;
+  if (p.length > 1 && p.charCodeAt(p.length - 1) === 47) {
+    p = p.slice(0, -1);
+  }
+  const segments = [];
+  const names = new Set;
+  let i = 1;
+  while (i < p.length) {
+    const slash = p.indexOf("/", i);
+    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 (//)`);
+    }
+    const c0 = seg.charCodeAt(0);
+    if (seg.includes("?") && !(c0 === 58 && seg.endsWith("?") && seg.indexOf("?") === seg.length - 1)) {
+      throw new Error(`Invalid route pattern "${pattern}": malformed optional parameter`);
+    }
+    if (c0 === 58) {
+      const optional = seg.endsWith("?");
+      const name = optional ? seg.slice(1, -1) : seg.slice(1);
+      if (name.length === 0) {
+        throw new Error(`Invalid route pattern "${pattern}": empty parameter name in segment ":${name}"`);
+      }
+      if (names.has(name)) {
+        throw new Error(`Invalid route pattern "${pattern}": duplicate parameter name "${name}"`);
+      }
+      names.add(name);
+      if (name.includes("?")) {
+        throw new Error(`Invalid route pattern "${pattern}": malformed optional parameter`);
+      }
+      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`);
+      }
+      const name = seg.length > 1 ? seg.slice(1) : null;
+      if (name !== null) {
+        if (names.has(name)) {
+          throw new Error(`Invalid route pattern "${pattern}": duplicate parameter name "${name}"`);
+        }
+        names.add(name);
+      }
+      segments.push({ kind: "wildcard", name });
+    } else {
+      segments.push({ kind: "static", value: seg });
+    }
+    i = end + 1;
+  }
+  const optionalCount = segments.reduce((count, segment) => count + (segment.kind === "param" && segment.optional ? 1 : 0), 0);
+  if (optionalCount > MAX_OPTIONAL_PARAMS) {
+    throw new RangeError(`Route pattern exceeds the limit of ${MAX_OPTIONAL_PARAMS} optional parameters`);
+  }
+  return segments;
+}
+function _segmentEquals(path, start, end, key) {
+  const n = end - start;
+  if (key.length !== n)
+    return false;
+  for (let i = 0;i < n; i++) {
+    if (path.charCodeAt(start + i) !== key.charCodeAt(i))
+      return false;
+  }
+  return true;
+}
+function decodeParam(raw) {
+  if (raw.indexOf("%") === -1)
+    return raw;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    throw new HttpError(400, { error: "Bad Request" });
+  }
+}
+function matchNode(rootNode, pathname, startI, method, paramNames, paramValues, startDepth) {
+  let node = rootNode;
+  let i = startI;
+  const depth = startDepth;
+  while (true) {
+    const len = pathname.length;
+    if (i >= len) {
+      const handlers = node.handlers;
+      if (handlers === null)
+        return null;
+      let handler = handlers[method];
+      if (handler === undefined && method === "HEAD") {
+        handler = handlers.GET;
+      }
+      if (handler === undefined) {
+        return node.notAllowed;
+      }
+      if (depth === 0)
+        return handler;
+      const p = Object.create(null);
+      p[MATCH_HANDLER] = handler;
+      for (let k = 0;k < depth; k++) {
+        p[paramNames[k]] = paramValues[k];
+      }
+      return p;
+    }
+    const slash = pathname.indexOf("/", i);
+    const segEnd = slash === -1 ? len : slash;
+    if (segEnd === i) {
+      if (slash === len - 1) {
+        return matchNode(node, pathname, len, method, paramNames, paramValues, depth);
+      }
+      return null;
+    }
+    const nextI = slash === -1 ? len : slash + 1;
+    let notAllowedCandidate = null;
+    const staticChildren = node.staticChildren;
+    if (staticChildren !== null) {
+      let child;
+      if (staticChildren.size <= STATIC_CHILD_SCAN_THRESHOLD) {
+        const keys = node.staticChildKeys;
+        const nodes = node.staticChildNodes;
+        for (let childIndex = 0;childIndex < keys.length; childIndex++) {
+          if (_segmentEquals(pathname, i, segEnd, keys[childIndex])) {
+            child = nodes[childIndex];
+            break;
+          }
+        }
+      } else {
+        child = staticChildren.get(pathname.slice(i, segEnd));
+      }
+      if (child !== undefined) {
+        const hasParamChildren = node.paramChild !== null || node.paramChildren !== null && node.paramChildren.size > 0;
+        if (!hasParamChildren && node.wildcardChild === null) {
+          node = child;
+          i = nextI;
+          continue;
+        }
+        const res = matchNode(child, pathname, nextI, method, paramNames, paramValues, depth);
+        if (res !== null) {
+          if (MATCH_NOT_ALLOWED in res) {
+            notAllowedCandidate = res;
+          } else {
+            return res;
+          }
+        }
+      }
+    }
+    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")
+            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;
+          }
+        }
+      }
+    }
+    if (node.wildcardChild !== null) {
+      let wildcardDepth = depth;
+      if (node.wildcardName !== null) {
+        let rest = pathname.slice(i);
+        if (rest.length > 1 && rest.charCodeAt(rest.length - 1) === 47) {
+          rest = rest.slice(0, -1);
+        }
+        paramNames[wildcardDepth] = node.wildcardName;
+        paramValues[wildcardDepth] = decodeParam(rest);
+        wildcardDepth++;
+      }
+      const handlers = node.wildcardChild.handlers;
+      if (handlers !== null) {
+        let handler = handlers[method];
+        if (handler === undefined && method === "HEAD") {
+          handler = handlers.GET;
+        }
+        if (handler === undefined) {
+          return node.wildcardChild.notAllowed;
+        }
+        if (wildcardDepth === 0)
+          return handler;
+        const p = Object.create(null);
+        for (let k = 0;k < wildcardDepth; k++) {
+          p[paramNames[k]] = paramValues[k];
+        }
+        p[MATCH_HANDLER] = handler;
+        return p;
+      }
+    }
+    return notAllowedCandidate;
+  }
+}
+
+class SegmentTrie {
+  root = createNode();
+  staticRoutes = new Map;
+  staticNotAllowed = new Map;
+  maxStaticLength = 0;
+  paramNameBuffer = [];
+  paramValueBuffer = [];
+  addBatch(routes) {
+    if (routes.length === 0)
+      return;
+    if (routes.length === 1) {
+      const route = routes[0];
+      this.add(route.method, route.pattern, route.handler);
+      return;
+    }
+    const staged = this.clone();
+    const parsedPatterns = new Map;
+    for (const route of routes) {
+      let segments = parsedPatterns.get(route.pattern);
+      if (segments === undefined) {
+        segments = parsePattern(route.pattern);
+        parsedPatterns.set(route.pattern, segments);
+      }
+      staged.addWithSegments(route.method, route.pattern, segments, route.handler);
+    }
+    this.root = staged.root;
+    this.staticRoutes = staged.staticRoutes;
+    this.staticNotAllowed = staged.staticNotAllowed;
+    this.maxStaticLength = staged.maxStaticLength;
+  }
+  clone() {
+    const copy = new SegmentTrie;
+    copy.root = cloneNode(this.root);
+    copy.staticRoutes = new Map(Array.from(this.staticRoutes, ([path, handlers]) => [
+      path,
+      Object.assign(Object.create(null), handlers)
+    ]));
+    copy.staticNotAllowed = new Map(this.staticNotAllowed);
+    copy.maxStaticLength = this.maxStaticLength;
+    return copy;
+  }
+  add(method, pattern, handler) {
+    const segments = parsePattern(pattern);
+    let optionalCount = 0;
+    for (const segment of segments) {
+      if (segment.kind === "param" && segment.optional)
+        optionalCount++;
+    }
+    if (optionalCount === 0) {
+      this.addParsed(method, pattern, segments, handler, false);
+      return;
+    }
+    const staged = this.clone();
+    staged.addWithSegments(method, pattern, segments, handler);
+    this.root = staged.root;
+    this.staticRoutes = staged.staticRoutes;
+    this.staticNotAllowed = staged.staticNotAllowed;
+  }
+  addWithSegments(method, pattern, segments, handler) {
+    let optionalCount = 0;
+    for (const segment of segments) {
+      if (segment.kind === "param" && segment.optional)
+        optionalCount++;
+    }
+    if (optionalCount === 0) {
+      this.addParsed(method, pattern, segments, handler, false);
+      return;
+    }
+    const selected = [];
+    const addVariants = (index) => {
+      if (index === segments.length) {
+        const variant = selected.length === 0 ? "/" : `/${selected.map((segment) => segment.kind === "static" ? segment.value : segment.kind === "param" ? `:${segment.name}` : `*${segment.name ?? ""}`).join("/")}`;
+        this.addParsed(method, variant, selected, handler, true);
+        return;
+      }
+      const segment = segments[index];
+      if (segment.kind === "param" && segment.optional) {
+        selected.push({ kind: "param", name: segment.name });
+        addVariants(index + 1);
+        selected.pop();
+        addVariants(index + 1);
+        return;
+      }
+      selected.push(segment);
+      addVariants(index + 1);
+      selected.pop();
+    };
+    addVariants(0);
+  }
+  addParsed(method, pattern, segments, handler, _allowConflictingParamNames) {
+    const bit = methodBit(method);
+    if (bit === 0) {
+      throw new Error(`Unsupported HTTP method "${method}" for route "${pattern}"`);
+    }
+    const isPureStatic = segments.every((s) => s.kind === "static");
+    let cleanPattern;
+    if (isPureStatic) {
+      cleanPattern = pattern.length > 1 && pattern.charCodeAt(pattern.length - 1) === 47 ? pattern.slice(0, -1) : pattern;
+      if (cleanPattern.length > this.maxStaticLength) {
+        this.maxStaticLength = cleanPattern.length;
+      }
+    }
+    let node = this.root;
+    for (const seg of segments) {
+      if (seg.kind === "static") {
+        if (node.staticChildren === null) {
+          node.staticChildren = new Map;
+        }
+        let child = node.staticChildren.get(seg.value);
+        if (child === undefined) {
+          child = createNode();
+          node.staticChildren.set(seg.value, child);
+          node.staticChildKeys.push(seg.value);
+          node.staticChildNodes.push(child);
+        }
+        node = child;
+      } else if (seg.kind === "param") {
+        if (node.wildcardChild !== null) {
+          throw new Error(`Ambiguous routes: wildcard "${node.wildcardName ?? "*"}" and param ":${seg.name}" compete at the same position in "${pattern}"`);
+        }
+        if (node.paramChildren === null) {
+          node.paramChildren = new Map;
+        }
+        let child = node.paramChildren.get(seg.name);
+        if (child === undefined) {
+          child = createNode();
+          node.paramChildren.set(seg.name, child);
+          if (node.paramChild === null && node.paramChildren.size === 1) {
+            node.paramChild = child;
+            node.paramName = seg.name;
+          } else {
+            node.paramChild = null;
+            node.paramName = null;
+          }
+        }
+        node = child;
+      } else {
+        if (node.wildcardChild !== null) {
+          if (node.wildcardName !== seg.name) {
+            throw new Error(`Conflicting wildcards at the same position: "*${node.wildcardName ?? ""}" vs "*${seg.name ?? ""}" (route "${pattern}")`);
+          }
+        } else {
+          if (node.paramChildren !== null && node.paramChildren.size > 0) {
+            const existingParam = node.paramChildren.keys().next().value;
+            if (existingParam !== undefined) {
+              throw new Error(`Ambiguous routes: param ":${existingParam}" and wildcard "*${seg.name ?? ""}" compete at the same position in "${pattern}"`);
+            }
+          }
+          node.wildcardChild = createNode();
+          node.wildcardName = seg.name;
+        }
+        node = node.wildcardChild;
+      }
+    }
+    if (node.handlers?.[method] !== undefined) {
+      throw new Error(`Duplicate route: ${method} ${pattern} is already registered`);
+    }
+    if (node.handlers === null)
+      node.handlers = Object.create(null);
+    node.handlers[method] = handler;
+    node.allow = SegmentTrie.computeAllow(node.handlers);
+    node.notAllowed = Object.freeze({
+      [MATCH_NOT_ALLOWED]: node.allow
+    });
+    if (isPureStatic) {
+      let sHandlers = this.staticRoutes.get(cleanPattern);
+      if (sHandlers === undefined) {
+        sHandlers = Object.create(null);
+        this.staticRoutes.set(cleanPattern, sHandlers);
+      }
+      sHandlers[method] = handler;
+      const sAllow = SegmentTrie.computeAllow(sHandlers);
+      this.staticNotAllowed.set(cleanPattern, Object.freeze({ [MATCH_NOT_ALLOWED]: sAllow }));
+    }
+  }
+  static computeAllow(handlers) {
+    const methods = Object.keys(handlers);
+    if (methods.includes("GET") && !methods.includes("HEAD")) {
+      return [...methods, "HEAD"].join(", ");
+    }
+    return methods.join(", ");
+  }
+  match(method, pathname) {
+    const len = pathname.length;
+    const cleanPath = len > 1 && pathname.charCodeAt(len - 1) === 47 ? pathname.slice(0, -1) : pathname;
+    if (cleanPath.length <= this.maxStaticLength) {
+      const sHandlers = this.staticRoutes.get(cleanPath);
+      if (sHandlers !== undefined) {
+        let handler = sHandlers[method];
+        if (handler === undefined && method === "HEAD") {
+          handler = sHandlers.GET;
+        }
+        if (handler !== undefined) {
+          return handler;
+        }
+        const dynamicMatch = matchNode(this.root, pathname, 1, method, this.paramNameBuffer, this.paramValueBuffer, 0);
+        if (this.paramNameBuffer.length > 0) {
+          this.paramNameBuffer.length = 0;
+          this.paramValueBuffer.length = 0;
+        }
+        if (dynamicMatch !== null && !(MATCH_NOT_ALLOWED in dynamicMatch)) {
+          return dynamicMatch;
+        }
+        return this.staticNotAllowed.get(cleanPath);
+      }
+    }
+    const res = matchNode(this.root, pathname, 1, method, this.paramNameBuffer, this.paramValueBuffer, 0);
+    if (this.paramNameBuffer.length > 0) {
+      this.paramNameBuffer.length = 0;
+      this.paramValueBuffer.length = 0;
+    }
+    return res;
+  }
+}
+
+// src/middleware.ts
+function isThenable(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function mergeState(ctx, value) {
+  if (typeof value === "object" && value !== null) {
+    Object.assign(ctx.state, value);
+  }
+}
+function composeMiddlewareDispatcher(mws, errorResolver) {
+  if (mws.length > 64 || mws.some((middleware) => middleware.after !== undefined)) {
+    return (ctx, handler) => runPipeline(mws, ctx, handler, errorResolver);
+  }
+  let next = (ctx, handler) => {
+    let result;
+    try {
+      result = handler(ctx);
+    } catch (error) {
+      return handlePipelineError(mws, ctx, error, mws.length, errorResolver);
+    }
+    if (isThenable(result)) {
+      return Promise.resolve(result).catch((error) => handlePipelineError(mws, ctx, error, mws.length, errorResolver));
+    }
+    return result;
+  };
+  for (let i = mws.length - 1;i >= 0; i--) {
+    const middleware = mws[i];
+    const hook = middleware.before;
+    const following = next;
+    next = (ctx, handler) => {
+      if (!hook)
+        return following(ctx, handler);
+      let result;
+      try {
+        result = hook(ctx);
+      } catch (error) {
+        return handlePipelineError(mws, ctx, error, i, errorResolver);
+      }
+      if (result === undefined)
+        return following(ctx, handler);
+      if (isThenable(result)) {
+        return Promise.resolve(result).then((value) => {
+          if (value instanceof Response)
+            return value;
+          mergeState(ctx, value);
+          return following(ctx, handler);
+        }, (error) => handlePipelineError(mws, ctx, error, i, errorResolver));
+      }
+      if (result instanceof Response)
+        return result;
+      mergeState(ctx, result);
+      return following(ctx, handler);
+    };
+  }
+  return next;
+}
+function composeMiddlewares(mws, handler, errorResolver) {
+  const dispatch = composeMiddlewareDispatcher(mws, errorResolver);
+  return (ctx) => dispatch(ctx, handler);
+}
+function runPipeline(mws, ctx, handler, errorResolver) {
+  let i = 0;
+  const len = mws.length;
+  while (i < len) {
+    const hook = mws[i].before;
+    if (hook) {
+      let r;
+      try {
+        r = hook(ctx);
+      } catch (err) {
+        return handlePipelineError(mws, ctx, err, i, errorResolver);
+      }
+      if (r !== undefined) {
+        if (r instanceof Response) {
+          return unwindAfter(mws, ctx, r, i + 1, errorResolver);
+        }
+        if (isThenable(r)) {
+          return resumeBefore(mws, ctx, handler, r, i, errorResolver);
+        }
+        mergeState(ctx, r);
+      }
+    }
+    i++;
+  }
+  return invokeHandler(mws, ctx, handler, len, errorResolver);
+}
+function continueBefore(mws, ctx, handler, startIndex, errorResolver) {
+  let i = startIndex;
+  const len = mws.length;
+  while (i < len) {
+    const hook = mws[i].before;
+    if (hook) {
+      let r;
+      try {
+        r = hook(ctx);
+      } catch (err) {
+        return handlePipelineError(mws, ctx, err, i, errorResolver);
+      }
+      if (r !== undefined) {
+        if (r instanceof Response) {
+          return unwindAfter(mws, ctx, r, i + 1, errorResolver);
+        }
+        if (isThenable(r)) {
+          return resumeBefore(mws, ctx, handler, r, i, errorResolver);
+        }
+        mergeState(ctx, r);
+      }
+    }
+    i++;
+  }
+  return invokeHandler(mws, ctx, handler, len, errorResolver);
+}
+function invokeHandler(mws, ctx, handler, entered, errorResolver) {
+  let res;
+  try {
+    res = handler(ctx);
+  } catch (err) {
+    return handlePipelineError(mws, ctx, err, entered, errorResolver);
+  }
+  if (isThenable(res)) {
+    return resumeHandler(mws, ctx, res, entered, errorResolver);
+  }
+  return unwindAfter(mws, ctx, res, entered, errorResolver);
+}
+function resumeBefore(mws, ctx, handler, promise, index, errorResolver) {
+  return Promise.resolve(promise).then((r) => {
+    if (r instanceof Response) {
+      return unwindAfter(mws, ctx, r, index + 1, errorResolver);
+    }
+    mergeState(ctx, r);
+    return continueBefore(mws, ctx, handler, index + 1, errorResolver);
+  }, (err) => handlePipelineError(mws, ctx, err, index, errorResolver));
+}
+function resumeHandler(mws, ctx, promise, entered, errorResolver) {
+  return Promise.resolve(promise).then((res) => unwindAfter(mws, ctx, res, entered, errorResolver), (err) => handlePipelineError(mws, ctx, err, entered, errorResolver));
+}
+function handlePipelineError(mws, ctx, err, entered, errorResolver) {
+  if (errorResolver !== undefined) {
+    let res;
+    try {
+      res = errorResolver(err, ctx);
+    } catch (resolverErr) {
+      const fallback = errorToResponse(resolverErr, ctx.development);
+      return unwindAfter(mws, ctx, fallback, entered, errorResolver);
+    }
+    if (isThenable(res)) {
+      return res.then((resolved) => unwindAfter(mws, ctx, resolved, entered, errorResolver), (resolverErr) => {
+        const fallback = errorToResponse(resolverErr, ctx.development);
+        return unwindAfter(mws, ctx, fallback, entered, errorResolver);
+      });
+    }
+    return unwindAfter(mws, ctx, res, entered, errorResolver);
+  }
+  const res = errorToResponse(err, ctx.development);
+  return unwindAfter(mws, ctx, res, entered, errorResolver);
+}
+function unwindAfter(mws, ctx, res, enteredCount, errorResolver) {
+  let currentRes = res;
+  for (let j = enteredCount - 1;j >= 0; j--) {
+    const hook = mws[j].after;
+    if (hook) {
+      let r;
+      try {
+        r = hook(ctx, currentRes);
+      } catch (err) {
+        if (errorResolver !== undefined) {
+          try {
+            const resolved = errorResolver(err, ctx);
+            if (isThenable(resolved)) {
+              return resolved.then((resolvedRes) => continueUnwind(mws, ctx, j - 1, resolvedRes, errorResolver), (resolverErr) => continueUnwind(mws, ctx, j - 1, errorToResponse(resolverErr, ctx.development), errorResolver));
+            }
+            currentRes = resolved;
+            continue;
+          } catch (resolverErr) {
+            currentRes = errorToResponse(resolverErr, ctx.development);
+            continue;
+          }
+        }
+        currentRes = errorToResponse(err, ctx.development);
+        continue;
+      }
+      if (r !== undefined) {
+        if (isThenable(r)) {
+          return resumeUnwind(mws, ctx, r, j - 1, currentRes, errorResolver);
+        }
+        if (r instanceof Response) {
+          currentRes = r;
+        }
+      }
+    }
+  }
+  return currentRes;
+}
+function resumeUnwind(mws, ctx, promise, nextIndex, currentRes, errorResolver) {
+  return Promise.resolve(promise).then((r) => {
+    const next = r instanceof Response ? r : currentRes;
+    return continueUnwind(mws, ctx, nextIndex, next, errorResolver);
+  }, (err) => {
+    if (errorResolver !== undefined) {
+      try {
+        const resolved = errorResolver(err, ctx);
+        if (isThenable(resolved)) {
+          return resolved.then((resolvedRes) => continueUnwind(mws, ctx, nextIndex, resolvedRes, errorResolver), (resolverErr) => continueUnwind(mws, ctx, nextIndex, errorToResponse(resolverErr, ctx.development), errorResolver));
+        }
+        return continueUnwind(mws, ctx, nextIndex, resolved, errorResolver);
+      } catch (resolverErr) {
+        return continueUnwind(mws, ctx, nextIndex, errorToResponse(resolverErr, ctx.development), errorResolver);
+      }
+    }
+    const next = errorToResponse(err, ctx.development);
+    return continueUnwind(mws, ctx, nextIndex, next, errorResolver);
+  });
+}
+function continueUnwind(mws, ctx, startIndex, currentRes, errorResolver) {
+  let cur = currentRes;
+  for (let j = startIndex;j >= 0; j--) {
+    const hook = mws[j].after;
+    if (hook) {
+      let r;
+      try {
+        r = hook(ctx, cur);
+      } catch (err) {
+        if (errorResolver !== undefined) {
+          try {
+            const resolved = errorResolver(err, ctx);
+            if (isThenable(resolved)) {
+              return resolved.then((resolvedRes) => continueUnwind(mws, ctx, j - 1, resolvedRes, errorResolver), (resolverErr) => continueUnwind(mws, ctx, j - 1, errorToResponse(resolverErr, ctx.development), errorResolver));
+            }
+            cur = resolved;
+            continue;
+          } catch (resolverErr) {
+            cur = errorToResponse(resolverErr, ctx.development);
+            continue;
+          }
+        }
+        cur = errorToResponse(err, ctx.development);
+        continue;
+      }
+      if (r !== undefined) {
+        if (isThenable(r)) {
+          return resumeUnwind(mws, ctx, r, j - 1, cur, errorResolver);
+        }
+        if (r instanceof Response) {
+          cur = r;
+        }
+      }
+    }
+  }
+  return cur;
+}
+
+// src/app.ts
+var METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS"
+];
+var MAX_ROUTE_SEGMENTS = 256;
+var EMPTY_PARAMS = Object.freeze(Object.create(null));
+var FAST_JSON_HEADERS = new Headers({
+  "content-type": "application/json; charset=utf-8"
+});
+var FAST_TEXT_HEADERS = new Headers({
+  "content-type": "text/plain; charset=utf-8"
+});
+
+class ReadonlySetView {
+  source;
+  constructor(source) {
+    this.source = source;
+  }
+  get size() {
+    return this.source.size;
+  }
+  has(value) {
+    return this.source.has(value);
+  }
+  forEach(callback, thisArg) {
+    this.source.forEach((value) => {
+      callback.call(thisArg, value, value, this);
+    });
+  }
+  entries() {
+    return this.source.entries();
+  }
+  keys() {
+    return this.source.keys();
+  }
+  values() {
+    return this.source.values();
+  }
+  [Symbol.iterator]() {
+    return this.source[Symbol.iterator]();
+  }
+  get [Symbol.toStringTag]() {
+    return "Set";
+  }
+}
+function createReadonlySet(source) {
+  return new ReadonlySetView(source);
+}
+var EMPTY_REDIRECT_HOSTS = createReadonlySet(new Set);
+function expandOptionalPatterns(pattern) {
+  if (!pattern.includes("?"))
+    return [pattern];
+  const segments = pattern.split("/").filter(Boolean);
+  const optIndices = [];
+  for (let i = 0;i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.startsWith(":") && seg.endsWith("?")) {
+      optIndices.push(i);
+    }
+  }
+  if (optIndices.length === 0)
+    return [pattern];
+  const variants = [];
+  const count = 1 << optIndices.length;
+  for (let mask = 0;mask < count; mask++) {
+    const parts = [];
+    for (let i = 0;i < segments.length; i++) {
+      const optPos = optIndices.indexOf(i);
+      if (optPos >= 0) {
+        if (mask & 1 << optPos) {
+          parts.push(segments[i].slice(0, -1));
+        }
+      } else {
+        parts.push(segments[i]);
+      }
+    }
+    variants.push(parts.length === 0 ? "/" : `/${parts.join("/")}`);
+  }
+  return variants;
+}
+var LIGHT_SUPPORTED_PROPS = new Set([
+  "req",
+  "params",
+  "pathname",
+  "queryParam",
+  "queryParamAll",
+  "state",
+  "stream",
+  "bodyStream"
+]);
+function classifyProps(props) {
+  for (const p of props) {
+    if (!LIGHT_SUPPORTED_PROPS.has(p)) {
+      return {
+        isContextFree: false,
+        isLightweight: false,
+        isParamsOnly: false,
+        isJsonBodyOnly: false
+      };
+    }
+  }
+  const hasParams = props.has("params") || props.size === 0;
+  const hasQuery = props.has("queryParam") || props.has("queryParamAll");
+  if (hasParams && props.size === 1) {
+    return {
+      isContextFree: false,
+      isLightweight: true,
+      isParamsOnly: true,
+      isJsonBodyOnly: false
+    };
+  }
+  if (hasParams || hasQuery || props.size > 0) {
+    return {
+      isContextFree: false,
+      isLightweight: true,
+      isParamsOnly: false,
+      isJsonBodyOnly: false
+    };
+  }
+  return {
+    isContextFree: false,
+    isLightweight: false,
+    isParamsOnly: false,
+    isJsonBodyOnly: false
+  };
+}
+function classify(analysis) {
+  if (analysis.isNoArg) {
+    return {
+      isContextFree: true,
+      isLightweight: false,
+      isParamsOnly: false,
+      isJsonBodyOnly: false
+    };
+  }
+  if (analysis.arglessJsonCall && !analysis.isDestructured && analysis.contextProps.size === 1 && analysis.contextProps.has("json")) {
+    return {
+      isContextFree: false,
+      isLightweight: false,
+      isParamsOnly: false,
+      isJsonBodyOnly: true
+    };
+  }
+  if (analysis.isDestructured) {
+    return classifyProps(analysis.destructuredProps);
+  }
+  if (analysis.hasDynamicAccess) {
+    return {
+      isContextFree: false,
+      isLightweight: false,
+      isParamsOnly: false,
+      isJsonBodyOnly: false
+    };
+  }
+  return classifyProps(analysis.contextProps);
+}
+function detectHandlerNeeds(fn) {
+  try {
+    return classify(analyzeHandler(fn));
+  } catch {
+    return {
+      isContextFree: false,
+      isLightweight: false,
+      isParamsOnly: false,
+      isJsonBodyOnly: false
+    };
+  }
+}
+
+class FastLightContext {
+  req;
+  params;
+  _pathname;
+  _state;
+  _hasPendingCookies = false;
+  _url;
+  _qPos = -2;
+  constructor(req, params) {
+    this.req = req;
+    this.params = params;
+  }
+  init(req, params) {
+    this.req = req;
+    this.params = params;
+    this._pathname = undefined;
+    this._state = undefined;
+    this._hasPendingCookies = false;
+    this._url = undefined;
+    this._qPos = -2;
+    return this;
+  }
+  get url() {
+    if (this._url === undefined) {
+      this._url = this.req.url;
+    }
+    return this._url;
+  }
+  get pathname() {
+    if (this._pathname === undefined) {
+      this._pathname = scanPathname(this.url);
+    }
+    return this._pathname;
+  }
+  queryParam(name) {
+    let u = this._url;
+    if (u === undefined) {
+      u = this.req.url;
+      this._url = u;
+    }
+    let q = this._qPos;
+    if (q === -2)
+      this._qPos = q = u.indexOf("?");
+    return findQueryParam(u, name, q);
+  }
+  queryParamAll(name) {
+    return findQueryParamAll(this.url, name);
+  }
+  get cookies() {
+    throw new Error("LightweightContext does not support cookies.");
+  }
+  get state() {
+    let state = this._state;
+    if (state === undefined) {
+      state = Object.create(null);
+      this._state = state;
+    }
+    return state;
+  }
+  stream() {
+    return this.req.body;
+  }
+  get bodyStream() {
+    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);
+    return;
+  }
+  try {
+    const result = handler(ws, error);
+    if (isThenable(result)) {
+      Promise.resolve(result).catch((handlerError) => console.error("WebSocket error handler failed:", handlerError));
+    }
+  } catch (handlerError) {
+    console.error("WebSocket error handler failed:", handlerError);
+  }
+}
+function dispatchWebSocketCallback(callback, args, onError) {
+  if (!callback)
+    return;
+  try {
+    const len = args.length;
+    let result;
+    if (len === 1) {
+      result = callback(args[0]);
+    } else if (len === 2) {
+      result = callback(args[0], args[1]);
+    } else if (len === 3) {
+      result = callback(args[0], args[1], args[2]);
+    } else {
+      result = Reflect.apply(callback, undefined, args);
+    }
+    if (isThenable(result)) {
+      Promise.resolve(result).catch(onError);
+    }
+  } catch (error) {
+    onError(error);
+  }
+}
+function getInternalWebSocketHandlers(ws) {
+  const data = ws.data;
+  return data?._barqInternal === true ? data.handlers : undefined;
+}
+function parseRouteArgs(args) {
+  if (args.length === 0) {
+    throw new Error("Route requires a handler function");
+  }
+  const last = args[args.length - 1];
+  if (typeof last !== "function") {
+    throw new Error("The final argument in route definition must be a Handler function");
+  }
+  const handler = last;
+  if (args.length === 1) {
+    return { middlewares: [], handler };
+  }
+  const middlewares = [];
+  for (let i = 0;i < args.length - 1; i++) {
+    const item = args[i];
+    if (Array.isArray(item)) {
+      for (let j = 0;j < item.length; j++) {
+        middlewares.push(item[j]);
+      }
+    } else if (item && typeof item === "object") {
+      middlewares.push(item);
+    } else {
+      throw new TypeError("Route middleware must be a Middleware object or array of Middleware");
+    }
+  }
+  return { middlewares, handler };
+}
+function normalizePrefix(prefix) {
+  let p = prefix.trim();
+  if (p.length === 0 || p === "/")
+    return "";
+  if (p.charCodeAt(0) !== 47)
+    p = `/${p}`;
+  if (p.charCodeAt(p.length - 1) === 47)
+    p = p.slice(0, -1);
+  return p;
+}
+function joinPrefix(prefix, pattern) {
+  if (!prefix)
+    return pattern;
+  let p = pattern.trim();
+  if (p.length === 0 || p === "/")
+    return prefix;
+  if (p.charCodeAt(0) !== 47)
+    p = `/${p}`;
+  return prefix + p;
+}
+function canonicalizeRoutePattern(pattern) {
+  let p = pattern.trim();
+  if (p.length === 0)
+    p = "/";
+  if (p.charCodeAt(0) !== 47)
+    p = `/${p}`;
+  if (p.length > 1 && p.charCodeAt(p.length - 1) === 47) {
+    p = p.slice(0, -1);
+  }
+  return p;
+}
+function validateRoutePattern(pattern) {
+  if (pattern.length === 0 || pattern.charCodeAt(0) !== 47) {
+    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 #`);
+  }
+  const segments = pattern.split("/");
+  if (segments.length - 1 > MAX_ROUTE_SEGMENTS) {
+    throw new RangeError(`Route pattern exceeds the limit of ${MAX_ROUTE_SEGMENTS} segments`);
+  }
+  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 (//)`);
+    }
+    const decoded = decodeSegment2(seg);
+    if (decoded === "." || decoded === "..") {
+      throw new Error(`Invalid route pattern "${pattern}": dot segments ., .. not allowed in route patterns`);
+    }
+  }
+}
+function decodeSegment2(seg) {
+  if (seg.indexOf("%") === -1)
+    return seg;
+  try {
+    return decodeURIComponent(seg);
+  } catch {
+    return seg;
+  }
+}
+function toResponse(value) {
+  if (value instanceof Response)
+    return value;
+  if (isThenable(value)) {
+    return Promise.resolve(value).then((resolved) => toResponse(resolved));
+  }
+  return finalizeValue(value);
+}
+function finalizeValue(value) {
+  if (typeof value === "object" && value !== null)
+    return new Response(JSON.stringify(value), { headers: FAST_JSON_HEADERS });
+  if (typeof value === "string")
+    return new Response(value, { headers: FAST_TEXT_HEADERS });
+  return new Response(String(value), { headers: FAST_TEXT_HEADERS });
+}
+async function stopClusterProcesses(processes, hardTimeoutMs) {
+  const running = processes.filter((process2) => !process2.killed);
+  if (running.length === 0)
+    return false;
+  for (const process2 of running)
+    process2.kill("SIGTERM");
+  const exited = Promise.all(running.map((process2) => process2.exited));
+  let timer;
+  const forced = await Promise.race([
+    exited.then(() => false),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(true), hardTimeoutMs);
+      timer.unref?.();
+    })
+  ]);
+  if (timer !== undefined)
+    clearTimeout(timer);
+  if (forced) {
+    for (const process2 of running) {
+      if (!process2.killed)
+        process2.kill("SIGKILL");
+    }
+    await exited;
+  }
+  return forced;
+}
+
+class RouteGroup {
+  app;
+  prefix;
+  middlewares;
+  constructor(app, prefix, middlewares = []) {
+    this.app = app;
+    this.prefix = prefix;
+    this.middlewares = middlewares;
+  }
+  use(...middlewares) {
+    for (let i = 0;i < middlewares.length; i++) {
+      this.middlewares.push(middlewares[i]);
+    }
+    return this;
+  }
+  plugin(pluginFn, options) {
+    pluginFn(this, options);
+    return this;
+  }
+  _register(method, pattern, args) {
+    return this._registerMethods([method], pattern, args);
+  }
+  _registerMethods(methods, pattern, args) {
+    const fullPattern = joinPrefix(this.prefix, pattern);
+    const { middlewares, handler } = parseRouteArgs(args);
+    const allMiddlewares = this.middlewares.length === 0 ? middlewares : [...this.middlewares, ...middlewares];
+    this.app._registerMethods(methods, fullPattern, allMiddlewares.length === 0 ? [handler] : [...allMiddlewares, handler]);
+    return this;
+  }
+  add(method, pattern, ...args) {
+    return this._register(method, pattern, args);
+  }
+  get(pattern, ...args) {
+    return this._register("GET", pattern, args);
+  }
+  post(pattern, ...args) {
+    return this._register("POST", pattern, args);
+  }
+  put(pattern, ...args) {
+    return this._register("PUT", pattern, args);
+  }
+  delete(pattern, ...args) {
+    return this._register("DELETE", pattern, args);
+  }
+  patch(pattern, ...args) {
+    return this._register("PATCH", pattern, args);
+  }
+  head(pattern, ...args) {
+    return this._register("HEAD", pattern, args);
+  }
+  options(pattern, ...args) {
+    return this._register("OPTIONS", pattern, args);
+  }
+  all(pattern, ...args) {
+    return this._registerMethods(METHODS, pattern, args);
+  }
+  ws(pattern, handlers, beforeUpgrade) {
+    this.app.ws(joinPrefix(this.prefix, pattern), handlers, beforeUpgrade ? (ctx) => beforeUpgrade(ctx) : undefined);
+    return this;
+  }
+  group(prefix, ...args) {
+    const nestedPrefix = joinPrefix(this.prefix, prefix);
+    const last = args[args.length - 1];
+    if (typeof last !== "function") {
+      throw new Error("Route group callback must be a function");
+    }
+    const callback = last;
+    const groupMws = [...this.middlewares];
+    for (let i = 0;i < args.length - 1; i++) {
+      const item = args[i];
+      if (Array.isArray(item)) {
+        for (let j = 0;j < item.length; j++)
+          groupMws.push(item[j]);
+      } else if (item && typeof item === "object") {
+        groupMws.push(item);
+      }
+    }
+    const nestedGroup = new RouteGroup(this.app, nestedPrefix, groupMws);
+    callback(nestedGroup);
+    return this;
+  }
+}
+
+class App {
+  fetchHandler = (req, srv) => this.handle(req, srv);
+  trie = new SegmentTrie;
+  middlewares = [];
+  nativeRoutes = [];
+  server = null;
+  clusterProcesses = null;
+  _options;
+  redirectHosts;
+  trustProxy;
+  trustedProxyChecker;
+  stopPromise = null;
+  notFoundHandler = null;
+  errorHandler = null;
+  errorResolver = undefined;
+  globalPipeline = composeMiddlewareDispatcher([]);
+  hasMiddlewares = false;
+  hasWebSockets = false;
+  development;
+  cookieSecret;
+  constructor(options = {}) {
+    if (options.port !== undefined && (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535)) {
+      throw new RangeError("port must be an integer between 0 and 65535");
+    }
+    if (options.maxRequestBodySize !== undefined && (!Number.isSafeInteger(options.maxRequestBodySize) || options.maxRequestBodySize < 0)) {
+      throw new RangeError("maxRequestBodySize must be a non-negative safe integer");
+    }
+    if (options.idleTimeout !== undefined && (!Number.isFinite(options.idleTimeout) || options.idleTimeout < 0 || options.idleTimeout > 255)) {
+      throw new RangeError("idleTimeout must be between 0 and 255 seconds");
+    }
+    for (const [name, value] of [
+      ["websocket.maxPayloadLength", options.websocket?.maxPayloadLength],
+      ["websocket.backpressureLimit", options.websocket?.backpressureLimit]
+    ]) {
+      if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+        throw new RangeError(`${name} must be a positive safe integer`);
+      }
+    }
+    if (options.websocket?.idleTimeout !== undefined && (!Number.isFinite(options.websocket.idleTimeout) || options.websocket.idleTimeout < 0 || options.websocket.idleTimeout > 255)) {
+      throw new RangeError("websocket.idleTimeout must be between 0 and 255 seconds");
+    }
+    const trustedProxyRanges = Array.isArray(options.trustProxy) ? options.trustProxy : typeof options.trustProxy === "string" ? [options.trustProxy] : [];
+    for (const range of trustedProxyRanges) {
+      if (!isIpRange(range)) {
+        throw new TypeError(`Invalid trustProxy IP range: ${range}`);
+      }
+    }
+    if (options.cookieSecret !== undefined && !options.cookieSecret.trim()) {
+      throw new TypeError("cookieSecret must be non-empty when provided");
+    }
+    this._options = options;
+    this.development = options.development ?? true;
+    this.trustProxy = Array.isArray(options.trustProxy) ? Object.freeze([...options.trustProxy]) : options.trustProxy ?? false;
+    this.trustedProxyChecker = compileTrustProxy(options.trustProxy);
+    this.cookieSecret = options.cookieSecret;
+    this.redirectHosts = options.allowedRedirectHosts ? createReadonlySet(new Set(options.allowedRedirectHosts.map((h) => h.toLowerCase()))) : EMPTY_REDIRECT_HOSTS;
+  }
+  plugin(pluginFn, options) {
+    pluginFn(this, options);
+    return this;
+  }
+  notFound(handler) {
+    this.notFoundHandler = handler;
+    return this;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    this.errorResolver = (err, ctx) => handler(err, ctx);
+    if (this.server !== null) {
+      this.globalPipeline = composeMiddlewareDispatcher(this.middlewares, this.errorResolver);
+    }
+    return this;
+  }
+  _register(method, pattern, args) {
+    return this._registerMethods([method], pattern, args);
+  }
+  _registerMethods(methods, pattern, args) {
+    const { middlewares, handler } = parseRouteArgs(args);
+    const responseHandler = (ctx) => toResponse(handler(ctx));
+    const finalHandler = middlewares.length === 0 ? responseHandler : composeMiddlewares(middlewares, responseHandler);
+    const canonicalPattern = canonicalizeRoutePattern(pattern);
+    validateRoutePattern(canonicalPattern);
+    const routes = methods.map((method) => ({
+      method,
+      pattern: canonicalPattern,
+      handler: finalHandler
+    }));
+    this.trie.addBatch(routes);
+    const needs = detectHandlerNeeds(handler);
+    const hasRouteMws = middlewares.length > 0;
+    for (const r of routes) {
+      const variants = expandOptionalPatterns(r.pattern);
+      for (const variant of variants) {
+        this.nativeRoutes.push({
+          method: r.method,
+          pattern: variant,
+          handler: r.handler,
+          rawHandler: handler,
+          isDynamic: variant.includes(":") || variant.includes("*"),
+          isContextFree: needs.isContextFree && !hasRouteMws,
+          isLightweight: needs.isLightweight && !hasRouteMws,
+          isParamsOnly: needs.isParamsOnly && !hasRouteMws,
+          isJsonBodyOnly: needs.isJsonBodyOnly && !hasRouteMws,
+          hasRouteMiddlewares: hasRouteMws
+        });
+      }
+    }
+    return this;
+  }
+  add(method, pattern, ...args) {
+    return this._register(method, pattern, args);
+  }
+  get(pattern, ...args) {
+    return this._register("GET", pattern, args);
+  }
+  post(pattern, ...args) {
+    return this._register("POST", pattern, args);
+  }
+  put(pattern, ...args) {
+    return this._register("PUT", pattern, args);
+  }
+  delete(pattern, ...args) {
+    return this._register("DELETE", pattern, args);
+  }
+  patch(pattern, ...args) {
+    return this._register("PATCH", pattern, args);
+  }
+  head(pattern, ...args) {
+    return this._register("HEAD", pattern, args);
+  }
+  options(pattern, ...args) {
+    return this._register("OPTIONS", pattern, args);
+  }
+  all(pattern, ...args) {
+    return this._registerMethods(METHODS, pattern, args);
+  }
+  ws(pattern, handlers, beforeUpgrade) {
+    this.hasWebSockets = true;
+    return this._registerMethods(["GET"], pattern, [
+      async (ctx) => {
+        if (ctx.req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+          return new Response("Upgrade Required", { status: 426 });
+        }
+        let customData;
+        if (beforeUpgrade) {
+          const check = await beforeUpgrade(ctx);
+          if (!check)
+            return new Response("Unauthorized", { status: 401 });
+          if (typeof check === "object" && check !== null && "data" in check) {
+            customData = check.data;
+          }
+        }
+        const upgradeData = customData !== undefined && typeof customData === "object" && customData !== null ? { ...customData, handlers, _barqInternal: true } : { handlers, _barqInternal: true, data: customData };
+        const upgraded = ctx.upgrade(upgradeData);
+        return upgraded ? new Response(null) : new Response("WebSocket upgrade failed", { status: 400 });
+      }
+    ]);
+  }
+  group(prefix, ...args) {
+    const last = args[args.length - 1];
+    if (typeof last !== "function") {
+      throw new Error("Route group callback must be a function");
+    }
+    const callback = last;
+    const groupMws = [];
+    for (let i = 0;i < args.length - 1; i++) {
+      const item = args[i];
+      if (Array.isArray(item)) {
+        for (let j = 0;j < item.length; j++)
+          groupMws.push(item[j]);
+      } else if (item && typeof item === "object") {
+        groupMws.push(item);
+      }
+    }
+    const normalizedPrefix = normalizePrefix(prefix);
+    const group = new RouteGroup(this, normalizedPrefix, groupMws);
+    callback(group);
+    return this;
+  }
+  use(...middlewares) {
+    for (let i = 0;i < middlewares.length; i++) {
+      this.middlewares.push(middlewares[i]);
+    }
+    this.hasMiddlewares = this.middlewares.length > 0;
+    if (this.server !== null) {
+      this.globalPipeline = composeMiddlewareDispatcher(this.middlewares, this.errorResolver);
+    }
+    return this;
+  }
+  listen(port) {
+    const listenPort = port ?? this._options.port ?? 0;
+    if (!Number.isInteger(listenPort) || listenPort < 0 || listenPort > 65535) {
+      throw new RangeError("port must be an integer between 0 and 65535");
+    }
+    if (this.stopPromise !== null) {
+      throw new Error("App cannot listen while shutdown is in progress");
+    }
+    if (this.server !== null) {
+      throw new Error("App is already listening");
+    }
+    const userWs = this._options.websocket;
+    this.globalPipeline = composeMiddlewareDispatcher(this.middlewares, this.errorResolver);
+    const contextApplication = this;
+    const opts = {
+      fetch: this.fetchHandler,
+      development: this.development
+    };
+    if (this._options.idleTimeout !== undefined) {
+      opts.idleTimeout = this._options.idleTimeout;
+    }
+    if (this._options.maxRequestBodySize !== undefined) {
+      opts.maxRequestBodySize = this._options.maxRequestBodySize;
+    }
+    opts.error = (err) => errorToResponse(err, this.development);
+    if (Bun.env.BARQ_IS_WORKER === "true")
+      opts.reusePort = true;
+    if (this.hasWebSockets || userWs !== undefined) {
+      opts.websocket = {
+        ...userWs,
+        message: (ws, message) => {
+          const internal = getInternalWebSocketHandlers(ws);
+          dispatchWebSocketCallback(internal?.message, [ws, message], (err) => reportWebSocketError(internal?.error, ws, err));
+          dispatchWebSocketCallback(userWs?.message, [ws, message], (err) => reportWebSocketError(userWs?.error, ws, err));
+        },
+        open: (ws) => {
+          const internal = getInternalWebSocketHandlers(ws);
+          dispatchWebSocketCallback(internal?.open, [ws], (err) => reportWebSocketError(internal?.error, ws, err));
+          dispatchWebSocketCallback(userWs?.open, [ws], (err) => reportWebSocketError(userWs?.error, ws, err));
+        },
+        close: (ws, code, reason) => {
+          const internal = getInternalWebSocketHandlers(ws);
+          dispatchWebSocketCallback(internal?.close, [ws, code, reason], (err) => reportWebSocketError(internal?.error, ws, err));
+          dispatchWebSocketCallback(userWs?.close, [ws, code, reason], (err) => reportWebSocketError(userWs?.error, ws, err));
+        },
+        drain: (ws) => {
+          const internal = getInternalWebSocketHandlers(ws);
+          dispatchWebSocketCallback(internal?.drain, [ws], (err) => reportWebSocketError(internal?.error, ws, err));
+          dispatchWebSocketCallback(userWs?.drain, [ws], (err) => reportWebSocketError(userWs?.error, ws, err));
+        },
+        error: (ws, err) => {
+          const internal = getInternalWebSocketHandlers(ws);
+          if (internal?.error === undefined && userWs?.error === undefined) {
+            console.error("Unhandled WebSocket error:", err);
+            return;
+          }
+          if (internal?.error)
+            reportWebSocketError(internal.error, ws, err);
+          if (userWs?.error)
+            reportWebSocketError(userWs.error, ws, err);
+        }
+      };
+    }
+    if (this.nativeRoutes.length > 0) {
+      const systemRoutes = Object.create(null);
+      const hasGlobalPipeline = this.hasMiddlewares || this.errorResolver !== undefined;
+      const routesByPattern = new Map;
+      for (const nr of this.nativeRoutes) {
+        let list = routesByPattern.get(nr.pattern);
+        if (!list) {
+          list = [];
+          routesByPattern.set(nr.pattern, list);
+        }
+        list.push(nr);
+      }
+      for (const [pattern, list] of routesByPattern) {
+        const isDynamic = pattern.includes(":") || pattern.includes("*");
+        const methodMap = Object.create(null);
+        for (const nr of list) {
+          const h = nr.handler;
+          const isDyn = nr.isDynamic;
+          const raw = nr.rawHandler;
+          if (hasGlobalPipeline || nr.hasRouteMiddlewares) {
+            methodMap[nr.method] = (req) => {
+              try {
+                const params = isDyn ? req.params ?? EMPTY_PARAMS : EMPTY_PARAMS;
+                const ctx = new Context(req, this.server, params, contextApplication);
+                const result = this.globalPipeline(ctx, h);
+                return finalizeResponse(ctx, result, req.method === "HEAD");
+              } catch (err) {
+                return errorToResponse(err, this.development);
+              }
+            };
+          } else if (nr.isContextFree && raw) {
+            const analysis = analyzeHandler(raw);
+            const literal = analysis.literal;
+            if (literal !== null) {
+              if (literal.kind === "string") {
+                methodMap[nr.method] = new Response(literal.value);
+                if (nr.method === "GET" && !isDyn)
+                  methodMap.HEAD = new Response(null);
+              } else {
+                methodMap[nr.method] = new Response(literal.value, {
+                  headers: FAST_JSON_HEADERS
+                });
+                if (nr.method === "GET" && !isDyn)
+                  methodMap.HEAD = new Response(null, {
+                    headers: FAST_JSON_HEADERS
+                  });
+              }
+            } else {
+              methodMap[nr.method] = () => {
+                const res = raw();
+                if (res instanceof Response)
+                  return res;
+                if (isThenable(res)) {
+                  return Promise.resolve(res).then((r) => {
+                    if (r instanceof Response)
+                      return r;
+                    if (typeof r === "object" && r !== null)
+                      return Response.json(r);
+                    if (typeof r === "string")
+                      return new Response(r, { headers: FAST_TEXT_HEADERS });
+                    return finalizeValue(r);
+                  });
+                }
+                if (typeof res === "object" && res !== null)
+                  return Response.json(res);
+                if (typeof res === "string")
+                  return new Response(res, { headers: FAST_TEXT_HEADERS });
+                return Response.json(res);
+              };
+              if (nr.method === "GET" && !isDyn) {
+                methodMap.HEAD = () => {
+                  const res = raw();
+                  const r = res instanceof Response ? res : finalizeValue(res);
+                  return stripBody(r);
+                };
+              }
+            }
+          } else if (nr.isJsonBodyOnly && raw) {
+            methodMap[nr.method] = (req) => new Response(req.body, { headers: FAST_JSON_HEADERS });
+            if (nr.method === "GET" && !isDyn) {
+              methodMap.HEAD = (req) => req.json().then(() => new Response(null, { headers: FAST_JSON_HEADERS }), (err) => errorToResponse(err, this.development));
+            }
+          } else if (nr.isParamsOnly && raw) {
+            const analysis = analyzeHandler(raw);
+            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 {
+              methodMap[nr.method] = (req) => {
+                const p = req.params;
+                const res = raw(p ? req : { params: EMPTY_PARAMS, req });
+                if (typeof res === "object" && res !== null) {
+                  if (res instanceof Response)
+                    return res;
+                  return Response.json(res);
+                }
+                if (typeof res === "string")
+                  return new Response(res, { headers: FAST_TEXT_HEADERS });
+                if (isThenable(res)) {
+                  return Promise.resolve(res).then((r) => {
+                    if (r instanceof Response)
+                      return r;
+                    if (typeof r === "object" && r !== null)
+                      return new Response(JSON.stringify(r), {
+                        headers: FAST_JSON_HEADERS
+                      });
+                    if (typeof r === "string")
+                      return new Response(r, { headers: FAST_TEXT_HEADERS });
+                    return finalizeValue(r);
+                  });
+                }
+                return new Response(JSON.stringify(res), {
+                  headers: FAST_JSON_HEADERS
+                });
+              };
+              if (nr.method === "GET" && !isDyn)
+                methodMap.HEAD = () => new Response(null, { headers: FAST_JSON_HEADERS });
+            }
+          } else if (nr.isLightweight && raw) {
+            methodMap[nr.method] = (req) => {
+              const params = isDyn ? req.params ?? EMPTY_PARAMS : EMPTY_PARAMS;
+              const ctx = acquireLightContext(req, params);
+              let res;
+              try {
+                res = raw(ctx);
+              } catch (err) {
+                releaseLightContext(ctx);
+                return errorToResponse(err, this.development);
+              }
+              if (typeof res === "object" && res !== null) {
+                if (res instanceof Response) {
+                  releaseLightContext(ctx);
+                  return res;
+                }
+                if (!isThenable(res)) {
+                  releaseLightContext(ctx);
+                  return Response.json(res);
+                }
+              } else if (typeof res === "string") {
+                releaseLightContext(ctx);
+                return new Response(res, { headers: FAST_TEXT_HEADERS });
+              } else if (!isThenable(res)) {
+                releaseLightContext(ctx);
+                return new Response(JSON.stringify(res), {
+                  headers: FAST_JSON_HEADERS
+                });
+              }
+              return Promise.resolve(res).then((r) => {
+                releaseLightContext(ctx);
+                if (r instanceof Response)
+                  return r;
+                if (typeof r === "object" && r !== null)
+                  return new Response(JSON.stringify(r), {
+                    headers: FAST_JSON_HEADERS
+                  });
+                if (typeof r === "string")
+                  return new Response(r, { headers: FAST_TEXT_HEADERS });
+                return finalizeValue(r);
+              }).catch((err) => {
+                releaseLightContext(ctx);
+                return errorToResponse(err, this.development);
+              });
+            };
+            if (nr.method === "GET" && !isDyn)
+              methodMap.HEAD = () => new Response(null, { headers: FAST_JSON_HEADERS });
+          } else {
+            methodMap[nr.method] = (req) => {
+              const isHead = nr.method === "GET" && req.method === "HEAD";
+              try {
+                const params = isDyn ? req.params ?? EMPTY_PARAMS : EMPTY_PARAMS;
+                const ctx = new Context(req, this.server, params, contextApplication);
+                const res = raw ? raw(ctx) : h(ctx);
+                if (res instanceof Response) {
+                  if (!isHead && !ctx._hasPendingCookies)
+                    return res;
+                  return finalizeResponse(ctx, res, isHead);
+                }
+                if (!isThenable(res))
+                  return finalizeResponse(ctx, toResponse(res), isHead);
+                return Promise.resolve(res).then((value) => finalizeResponse(ctx, toResponse(value), isHead)).catch((err) => finalizeResponse(ctx, errorToResponse(err, this.development), isHead));
+              } catch (err) {
+                return errorToResponse(err, this.development);
+              }
+            };
+          }
+        }
+        const allowMethods = Object.keys(methodMap);
+        const allowHeader = allowMethods.includes("GET") && !allowMethods.includes("HEAD") ? [...allowMethods, "HEAD"].join(", ") : allowMethods.join(", ");
+        if (isDynamic) {
+          const getFn = methodMap.GET;
+          if (allowMethods.length === 1 && typeof getFn === "function" && allowMethods[0] === "GET") {
+            systemRoutes[pattern] = methodMap;
+          } else {
+            systemRoutes[pattern] = (req) => {
+              const matched = methodMap[req.method];
+              if (typeof matched === "function")
+                return matched(req);
+              if (matched instanceof Response)
+                return req.method === "HEAD" ? stripBody(matched) : matched;
+              if (req.method === "HEAD") {
+                const gh = methodMap.GET;
+                if (typeof gh === "function") {
+                  const res = gh(req);
+                  return isThenable(res) ? res.then(stripBody) : stripBody(res);
+                }
+              }
+              return new Response('{"error":"Method Not Allowed"}', {
+                status: 405,
+                headers: {
+                  "content-type": "application/json; charset=utf-8",
+                  Allow: allowHeader
+                }
+              });
+            };
+          }
+        } else {
+          systemRoutes[pattern] = methodMap;
+        }
+      }
+      opts.routes = systemRoutes;
+    }
+    opts.port = listenPort;
+    if (this._options.hostname !== undefined)
+      opts.hostname = this._options.hostname;
+    if (this._options.tls !== undefined)
+      opts.tls = this._options.tls;
+    this.server = Bun.serve(opts);
+    return this.server;
+  }
+  handle(req, srv) {
+    const isHead = req.method === "HEAD";
+    const serverInstance = srv ?? this.server;
+    const contextApplication = this;
+    let currentCtx = null;
+    let pathname;
+    try {
+      pathname = scanPathname(req.url);
+      const matched = this.trie.match(req.method, pathname);
+      if (matched === null) {
+        if (this.notFoundHandler === null && !this.hasMiddlewares && this.errorResolver === undefined) {
+          return new Response('{"error":"Not Found"}', {
+            status: 404,
+            headers: { "content-type": "application/json; charset=utf-8" }
+          });
+        }
+        currentCtx = new Context(req, serverInstance, EMPTY_PARAMS, contextApplication, pathname);
+        const notFoundHandler = this.notFoundHandler !== null ? this.notFoundHandler : () => new Response('{"error":"Not Found"}', {
+          status: 404,
+          headers: {
+            "content-type": "application/json; charset=utf-8"
+          }
+        });
+        const result = this.globalPipeline(currentCtx, notFoundHandler);
+        return finalizeResponse(currentCtx, result, isHead);
+      }
+      if (!this.hasMiddlewares && this.errorResolver === undefined) {
+        if (typeof matched === "function") {
+          if (matched.length === 0) {
+            const res = matched();
+            if (!isHead && !isThenable(res))
+              return res;
+            if (isThenable(res)) {
+              return res.then((r) => isHead ? stripBody(r) : r, (err) => errorToResponse(err, this.development));
+            }
+            return isHead ? stripBody(res) : res;
+          }
+          currentCtx = new Context(req, serverInstance, EMPTY_PARAMS, contextApplication, pathname);
+          const res = matched(currentCtx);
+          if (!isHead && !isThenable(res)) {
+            if (typeof res === "object" && res !== null && !(res instanceof Response)) {
+              return new Response(JSON.stringify(res), {
+                headers: FAST_JSON_HEADERS
+              });
+            }
+            if (!currentCtx._hasPendingCookies)
+              return res;
+          }
+          return finalizeResponse(currentCtx, guardRejections(res, this.development), isHead);
+        }
+        const handler = typeof matched === "object" && MATCH_HANDLER in matched ? matched[MATCH_HANDLER] : undefined;
+        if (handler !== undefined) {
+          const params = matched;
+          currentCtx = new Context(req, serverInstance, params, contextApplication, pathname);
+          const res = handler(currentCtx);
+          if (!isHead && !isThenable(res)) {
+            if (!currentCtx._hasPendingCookies)
+              return res;
+          }
+          return finalizeResponse(currentCtx, guardRejections(res, this.development), isHead);
+        }
+      }
+      if (typeof matched === "function") {
+        currentCtx = new Context(req, serverInstance, EMPTY_PARAMS, contextApplication, pathname);
+        const result = this.globalPipeline(currentCtx, matched);
+        return finalizeResponse(currentCtx, result, isHead);
+      }
+      if (MATCH_NOT_ALLOWED in matched) {
+        const allow = matched[MATCH_NOT_ALLOWED];
+        if (this.errorHandler === null && !this.hasMiddlewares && this.errorResolver === undefined) {
+          return new Response('{"error":"Method Not Allowed"}', {
+            status: 405,
+            headers: {
+              "content-type": "application/json; charset=utf-8",
+              Allow: allow
+            }
+          });
+        }
+        currentCtx = new Context(req, serverInstance, EMPTY_PARAMS, contextApplication, pathname);
+        const notAllowedHandler = () => errorToResponse(new HttpError(405, { error: "Method Not Allowed" }, { Allow: allow }), this.development);
+        const result = this.globalPipeline(currentCtx, notAllowedHandler);
+        return finalizeResponse(currentCtx, result, isHead);
+      }
+      const params = matched;
+      const handler = params[MATCH_HANDLER];
+      currentCtx = new Context(req, serverInstance, params, contextApplication, pathname);
+      const result = this.globalPipeline(currentCtx, handler);
+      return finalizeResponse(currentCtx, result, isHead);
+    } catch (err) {
+      const activeCtx = currentCtx ?? new Context(req, serverInstance, EMPTY_PARAMS, contextApplication, pathname);
+      if (this.errorHandler !== null) {
+        try {
+          const custom = this.errorHandler(err, activeCtx);
+          const result = isThenable(custom) ? custom.then((r) => unwindAfter(this.middlewares, activeCtx, r, 0, this.errorResolver)) : unwindAfter(this.middlewares, activeCtx, custom, 0, this.errorResolver);
+          return finalizeResponse(activeCtx, result, isHead);
+        } catch (e2) {
+          const fallback = errorToResponse(e2, this.development);
+          const result = unwindAfter(this.middlewares, activeCtx, fallback, 0, this.errorResolver);
+          return finalizeResponse(activeCtx, result, isHead);
+        }
+      }
+      const routingErr = errorToResponse(err, this.development);
+      const result = unwindAfter(this.middlewares, activeCtx, routingErr, 0, this.errorResolver);
+      return finalizeResponse(activeCtx, result, isHead);
+    }
+  }
+  cluster(port) {
+    const listenPort = port ?? this._options.port ?? 3000;
+    const isWorker = Bun.env.BARQ_IS_WORKER === "true";
+    if (!Number.isInteger(listenPort) || listenPort < 0 || listenPort > 65535) {
+      throw new RangeError("port must be an integer between 0 and 65535");
+    }
+    if (isWorker || process.platform !== "linux") {
+      return this.listen(listenPort);
+    }
+    if (listenPort === 0) {
+      throw new RangeError("cluster requires a fixed, non-zero port");
+    }
+    if (this.clusterProcesses !== null || this.server !== null) {
+      throw new Error("App is already listening or clustering");
+    }
+    const entry = process.argv[1];
+    if (!entry) {
+      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: {
+          ...process.env,
+          BARQ_IS_WORKER: "true",
+          PORT: String(listenPort)
+        },
+        stdio: ["inherit", "inherit", "inherit"]
+      });
+      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());
+        }
+      });
+      return proc;
+    };
+    try {
+      for (let i = 0;i < cpus().length; i++) {
+        processes.push(spawnWorker());
+      }
+    } catch (error) {
+      for (const process2 of processes)
+        process2.kill("SIGTERM");
+      throw error;
+    }
+    this.clusterProcesses = processes;
+    return;
+  }
+  async stop(hardTimeoutMs = 5000) {
+    if (!Number.isFinite(hardTimeoutMs) || hardTimeoutMs < 0) {
+      throw new RangeError("hardTimeoutMs must be a finite non-negative number");
+    }
+    if (this.stopPromise !== null) {
+      return this.stopPromise;
+    }
+    const server = this.server;
+    const clusterProcesses = this.clusterProcesses;
+    this.server = null;
+    this.clusterProcesses = null;
+    if (server === null && clusterProcesses === null) {
+      return { forced: false, pending: 0 };
+    }
+    this.stopPromise = (async () => {
+      let serverResult = { forced: false, pending: 0 };
+      let workersForced = false;
+      try {
+        if (server !== null) {
+          serverResult = await stopServer(server, hardTimeoutMs);
+        }
+      } finally {
+        if (clusterProcesses !== null) {
+          workersForced = await stopClusterProcesses(clusterProcesses, hardTimeoutMs);
+        }
+      }
+      return {
+        forced: serverResult.forced || workersForced,
+        pending: serverResult.pending
+      };
+    })();
+    try {
+      return await this.stopPromise;
+    } finally {
+      this.stopPromise = null;
+    }
+  }
+}
+function guardRejections(res, development) {
+  return isThenable(res) ? res.catch((err) => errorToResponse(err, development)) : res;
+}
+function applyCookies(ctx, res) {
+  if (!ctx._hasPendingCookies)
+    return res;
+  const cookies = ctx._cookieJarIfCreated();
+  if (cookies === null)
+    return res;
+  const headers = new Headers(res.headers);
+  applyPendingCookies(cookies, headers);
+  ctx._hasPendingCookies = false;
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+function finalizeResponse(ctx, res, isHead) {
+  if (res instanceof Response) {
+    if (!isHead && !ctx._hasPendingCookies)
+      return res;
+    const withCookies = applyCookies(ctx, res);
+    return isHead ? stripBody(withCookies) : withCookies;
+  }
+  if (isThenable(res)) {
+    return res.then((response) => {
+      const withCookies = applyCookies(ctx, response);
+      return isHead ? stripBody(withCookies) : withCookies;
+    });
+  }
+  if (!isHead) {
+    if (!ctx._hasPendingCookies)
+      return res;
+    return applyCookies(ctx, res);
+  }
+  return stripBody(applyCookies(ctx, res));
+}
+function stripBody(res) {
+  if (res.body === null)
+    return res;
+  try {
+    res.body.cancel?.().catch?.(() => {});
+  } catch {}
+  return new Response(null, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: res.headers
+  });
+}
+
+// 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", {
+      configurable: true,
+      value: {
+        env: process.env,
+        CryptoHasher: class {
+          hmac;
+          constructor(_algo, secret) {
+            this.hmac = crypto.createHmac("sha256", secret);
+          }
+          update(data) {
+            this.hmac.update(data);
+            return this;
+          }
+          digest(encoding) {
+            return this.hmac.digest(encoding);
+          }
+        }
+      }
+    });
+  }
+  App.prototype.listen = function(port) {
+    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}${rawUrl}`;
+        let reqBody;
+        if (method !== "GET" && method !== "HEAD") {
+          reqBody = Readable.toWeb(req);
+        }
+        const webReq = new Request(url, {
+          method,
+          headers: req.headers,
+          body: reqBody,
+          duplex: "half"
+        });
+        const remoteIp = req.socket.remoteAddress || "";
+        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) => {
+          resHeaders[key] = val;
+        });
+        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();
+        }
+      } catch (err) {
+        console.error("Barq Node Adapter Error:", err);
+        if (!res.headersSent) {
+          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.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: (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
+function cors(options = {}) {
+  const methods = (options.methods ?? ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]).join(", ");
+  const allowedHeaders = options.allowedHeaders?.join(", ");
+  const exposedHeaders = options.exposedHeaders?.join(", ");
+  const maxAge = options.maxAge !== undefined ? String(options.maxAge) : null;
+  const credentials = options.credentials === true;
+  function resolveOrigin(reqOrigin) {
+    if (!options.origin || options.origin === "*") {
+      return credentials ? reqOrigin ?? "*" : "*";
+    }
+    if (!reqOrigin)
+      return null;
+    if (typeof options.origin === "string") {
+      return options.origin === reqOrigin ? reqOrigin : null;
+    }
+    if (Array.isArray(options.origin)) {
+      return options.origin.includes(reqOrigin) ? reqOrigin : null;
+    }
+    if (typeof options.origin === "function") {
+      const result = options.origin(reqOrigin);
+      if (typeof result === "string")
+        return result;
+      return result ? reqOrigin : null;
+    }
+    return null;
+  }
+  function setCorsHeaders(headers, matchedOrigin) {
+    if (matchedOrigin) {
+      headers.set("access-control-allow-origin", matchedOrigin);
+      if (matchedOrigin !== "*") {
+        headers.append("vary", "Origin");
+      }
+    }
+    if (credentials) {
+      headers.set("access-control-allow-credentials", "true");
+    }
+    if (exposedHeaders) {
+      headers.set("access-control-expose-headers", exposedHeaders);
+    }
+  }
+  return {
+    before(ctx) {
+      const reqOrigin = ctx.req.headers.get("origin");
+      const matchedOrigin = resolveOrigin(reqOrigin);
+      if (ctx.req.method === "OPTIONS") {
+        const headers = new Headers;
+        setCorsHeaders(headers, matchedOrigin);
+        headers.set("access-control-allow-methods", methods);
+        if (allowedHeaders) {
+          headers.set("access-control-allow-headers", allowedHeaders);
+        } else {
+          const reqHeaders = ctx.req.headers.get("access-control-request-headers");
+          if (reqHeaders) {
+            headers.set("access-control-allow-headers", reqHeaders);
+          }
+        }
+        if (maxAge) {
+          headers.set("access-control-max-age", maxAge);
+        }
+        headers.set("content-length", "0");
+        return new Response(null, { status: 204, headers });
+      }
+      ctx.state._corsOrigin = matchedOrigin;
+    },
+    after(ctx, res) {
+      const matchedOrigin = ctx.state._corsOrigin;
+      if (matchedOrigin !== undefined) {
+        const headers = new Headers(res.headers);
+        setCorsHeaders(headers, matchedOrigin);
+        return new Response(res.body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers
+        });
+      }
+      return res;
+    }
+  };
+}
+// src/validation.ts
+function validateJson(validator, handler) {
+  return async (ctx) => {
+    const raw = await ctx.json();
+    let body;
+    if (typeof validator === "object" && validator !== null && "~standard" in validator) {
+      const res = await validator["~standard"].validate(raw);
+      if (res.issues) {
+        throw new HttpError(422, {
+          error: "Validation Failed",
+          issues: res.issues
+        });
+      }
+      body = res.value;
+    } else if (typeof validator === "function") {
+      body = await validator(raw);
+    } else if (typeof validator === "object" && validator !== null && "parse" in validator) {
+      body = validator.parse(raw);
+    } else {
+      throw new TypeError("Invalid validator provided to validateJson");
+    }
+    return handler(ctx, body);
+  };
+}
+export {
+  App,
+  Context,
+  HttpError,
+  RouteGroup,
+  composeMiddlewareDispatcher,
+  composeMiddlewares,
+  cors,
+  createCookieJar,
+  createErrorResponse,
+  empty,
+  errorToResponse,
+  isThenable,
+  json,
+  parseRequestTarget,
+  redirect,
+  runPipeline,
+  text,
+  unwindAfter,
+  validateJson
+};
+
+//# debugId=9C2F2B32771A43B764756E2164756E21