@orieljs/http 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1908 @@
+// errors.ts
+var HttpException = class extends Error {
+  constructor(status, message = "", headers = {}) {
+    super(message);
+    this.status = status;
+    this.headers = headers;
+  }
+  status;
+  headers;
+  kind = "Http";
+  name = "HttpException";
+};
+var HttpResponseException = class extends Error {
+  constructor(response2) {
+    super(`HTTP response exception (${response2.status}).`);
+    this.response = response2;
+    this.status = response2.status;
+  }
+  response;
+  kind = "Http";
+  name = "HttpResponseException";
+  status;
+};
+var HttpServerError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "HttpServerError";
+};
+
+// body.ts
+async function readBody(raw, limit) {
+  if (raw.body === null) return new Uint8Array(0);
+  const declared = Number(raw.headers.get("content-length") ?? NaN);
+  if (limit !== null && Number.isFinite(declared) && declared > limit) {
+    await raw.body.cancel();
+    throw new HttpException(413, "Content Too Large");
+  }
+  const reader = raw.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (limit !== null && size > limit) {
+      await reader.cancel();
+      throw new HttpException(413, "Content Too Large");
+    }
+    chunks.push(value);
+  }
+  const out = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+
+// context.ts
+import { CookieJar, HttpRequest, Session } from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+function requestScope() {
+  const container = currentContainer();
+  return container !== void 0 && container.bound(HttpRequest) ? container : void 0;
+}
+function currentRequest() {
+  return requestScope()?.make(HttpRequest);
+}
+function optionalSession() {
+  const scope = requestScope();
+  return scope?.bound(Session) ? scope.make(Session) : void 0;
+}
+function optionalCookieJar() {
+  const scope = requestScope();
+  return scope?.bound(CookieJar) ? scope.make(CookieJar) : void 0;
+}
+
+// HttpRedirectResponse.ts
+function serializeCookie(cookie) {
+  const parts = [`${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`, `Path=${cookie.path}`];
+  if (cookie.domain !== void 0) parts.push(`Domain=${cookie.domain}`);
+  if (cookie.secure) parts.push("Secure");
+  if (cookie.httpOnly) parts.push("HttpOnly");
+  parts.push(`SameSite=${cookie.sameSite.charAt(0).toUpperCase()}${cookie.sameSite.slice(1)}`);
+  if (cookie.minutes < 0) parts.push("Max-Age=0", "Expires=Thu, 01 Jan 1970 00:00:00 GMT");
+  else if (cookie.minutes > 0) parts.push(`Max-Age=${Math.round(cookie.minutes * 60)}`);
+  return parts.join("; ");
+}
+var HttpRedirectResponse = class {
+  constructor(targetUrl, status = 302, headers) {
+    this.targetUrl = targetUrl;
+    this.status = status;
+    this.#headers = new Headers(headers);
+  }
+  targetUrl;
+  status;
+  #headers;
+  with(key, value) {
+    const session = optionalSession();
+    if (session === void 0) return this;
+    if (typeof key === "string") session.flash(key, value);
+    else for (const [name, item] of Object.entries(key)) session.flash(name, item);
+    return this;
+  }
+  /** Flashes `errors` as { [bag]: { field: string[] } }, keeping the other bags already flashed. */
+  withErrors(errors, bag = "default") {
+    const session = optionalSession();
+    if (session === void 0) return this;
+    const source = typeof errors.toObject === "function" ? errors.toObject() : errors;
+    const normalized = Object.fromEntries(
+      Object.entries(source).map(([field, messages]) => [field, Array.isArray(messages) ? [...messages] : [messages]])
+    );
+    const existing = session.get("errors", {});
+    session.flash("errors", { ...existing, [bag]: normalized });
+    return this;
+  }
+  /** Flashes `input`, or the current request's input (files are never part of input()). */
+  withInput(input) {
+    const session = optionalSession();
+    if (session === void 0) return this;
+    session.flashInput(input ?? currentRequest()?.input() ?? {});
+    return this;
+  }
+  /**
+   * Always a Set-Cookie header on this response (Laravel's RedirectResponse::withCookie). A bound CookieJar only
+   * supplies the defaults (path, domain, secure, same-site); queueing would lose the cookie outside the web group.
+   */
+  withCookie(name, value, minutes = 0) {
+    const jar = optionalCookieJar();
+    const cookie = jar !== void 0 ? jar.make(name, value, minutes) : { name, value, minutes, path: "/", secure: false, httpOnly: true, sameSite: "lax" };
+    this.#headers.append("Set-Cookie", serializeCookie(cookie));
+    return this;
+  }
+  header(name, value) {
+    this.#headers.set(name, value);
+    return this;
+  }
+  toResponse() {
+    const headers = new Headers(this.#headers);
+    headers.set("Location", this.targetUrl);
+    return new Response(null, { status: this.status, headers });
+  }
+};
+
+// HttpRedirector.ts
+import { UrlGenerator } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+var HttpRedirector = class {
+  to(path, status = 302, headers) {
+    return new HttpRedirectResponse(inject(UrlGenerator).to(path), status, headers);
+  }
+  route(name, parameters, status = 302) {
+    return new HttpRedirectResponse(inject(UrlGenerator).route(name, parameters), status);
+  }
+  back(fallback, status = 302) {
+    return new HttpRedirectResponse(inject(UrlGenerator).previous(fallback), status);
+  }
+  /** Pulls url.intended from the session (put there by guest()), else goes to `fallback`. */
+  intended(fallback = "/", status = 302) {
+    const path = optionalSession()?.pull("url.intended") ?? fallback;
+    return this.to(path, status);
+  }
+  away(url2, status = 302) {
+    return new HttpRedirectResponse(url2, status);
+  }
+  /** Remembers where a guest was going (a GET page, else the previous URL), then redirects to `path`. */
+  guest(path, status = 302) {
+    const session = optionalSession();
+    const request2 = currentRequest();
+    if (session !== void 0) {
+      const intended = request2 !== void 0 && request2.method() === "GET" && !request2.expectsJson() ? request2.fullUrl() : inject(UrlGenerator).previous();
+      session.put("url.intended", intended);
+    }
+    return this.to(path, status);
+  }
+  setIntendedUrl(url2) {
+    optionalSession()?.put("url.intended", url2);
+  }
+  refresh(status = 302) {
+    return this.to(currentRequest()?.fullUrl() ?? inject(UrlGenerator).current(), status);
+  }
+};
+
+// clientAddress.ts
+var KEY = /* @__PURE__ */ Symbol.for("oriel:http.client-address");
+var store = globalThis[KEY] ??= /* @__PURE__ */ new WeakMap();
+function setClientAddress(request2, address) {
+  if (address !== void 0 && address !== "") store.set(request2, address);
+}
+function clientAddress(request2) {
+  return store.get(request2);
+}
+
+// FormUploadedFile.ts
+import { FilesystemManager } from "@orieljs/contracts";
+import { inject as inject2 } from "@orieljs/container";
+import { Str } from "@orieljs/support";
+
+// mime.ts
+var TYPES = {
+  avif: "image/avif",
+  css: "text/css",
+  csv: "text/csv",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  gif: "image/gif",
+  gz: "application/gzip",
+  html: "text/html",
+  ico: "image/vnd.microsoft.icon",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  json: "application/json",
+  md: "text/markdown",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  pdf: "application/pdf",
+  png: "image/png",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  wasm: "application/wasm",
+  webm: "video/webm",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xml: "application/xml",
+  zip: "application/zip"
+};
+var ALIASES = { jpeg: "jpg", htm: "html", mjs: "js", text: "txt" };
+var EXTENSIONS = Object.fromEntries(Object.entries(TYPES).map(([extension, type]) => [type, extension]));
+function mimeFromExtension(pathOrExtension) {
+  const extension = pathOrExtension.slice(pathOrExtension.lastIndexOf(".") + 1).toLowerCase();
+  return TYPES[ALIASES[extension] ?? extension] ?? "application/octet-stream";
+}
+function extensionFromMime(type) {
+  return EXTENSIONS[type.split(";")[0].trim().toLowerCase()];
+}
+
+// FormUploadedFile.ts
+var FormUploadedFile = class {
+  constructor(file) {
+    this.file = file;
+    this.clientName = file.name ?? "";
+    this.mimeType = file.type === "" ? "application/octet-stream" : file.type;
+    this.size = file.size;
+  }
+  file;
+  clientName;
+  mimeType;
+  size;
+  /** Guessed from the MIME type, falling back to the client's extension (Laravel's extension()). */
+  extension() {
+    return extensionFromMime(this.mimeType) ?? this.clientExtension();
+  }
+  clientExtension() {
+    const dot = this.clientName.lastIndexOf(".");
+    return dot === -1 ? "" : this.clientName.slice(dot + 1).toLowerCase();
+  }
+  /** A random 40-character name with the guessed extension. */
+  hashName() {
+    const extension = this.extension();
+    return extension === "" ? Str.random(40) : `${Str.random(40)}.${extension}`;
+  }
+  arrayBuffer() {
+    return this.file.arrayBuffer();
+  }
+  text() {
+    return this.file.text();
+  }
+  stream() {
+    return this.file.stream();
+  }
+  store(directory, disk) {
+    return inject2(FilesystemManager).disk(disk).putFile(directory, this);
+  }
+  storeAs(directory, name, disk) {
+    return inject2(FilesystemManager).disk(disk).putFileAs(directory, this, name);
+  }
+};
+
+// IncomingRequest.ts
+import {
+  CurrentRoute,
+  Session as Session2,
+  ValidationFactory
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer2, inject as inject3 } from "@orieljs/container";
+import { Arr, Str as Str2 } from "@orieljs/support";
+
+// input.ts
+var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var INTEGER_KEY = /^(?:0|[1-9]\d*)$/;
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function parseBracketKey(name) {
+  const open = name.indexOf("[");
+  if (open <= 0 || !name.endsWith("]")) return [name];
+  const segments = [name.slice(0, open)];
+  const rest = name.slice(open);
+  const matches = rest.match(/\[[^[\]]*\]/g);
+  if (matches === null || matches.join("") !== rest) return [name];
+  for (const match of matches) segments.push(match.slice(1, -1));
+  return segments;
+}
+function normalizeLists(value) {
+  if (Array.isArray(value)) return value.map(normalizeLists);
+  if (!isPlainObject(value)) return value;
+  const keys = Object.keys(value);
+  const out = {};
+  for (const key of keys) out[key] = normalizeLists(value[key]);
+  if (keys.length > 0 && keys.every((key, index) => key === String(index))) return keys.map((key) => out[key]);
+  return out;
+}
+function fromEntries(entries) {
+  const root = {};
+  const nextIndex = /* @__PURE__ */ new WeakMap();
+  for (const [name, value] of entries) {
+    const segments = parseBracketKey(name);
+    if (segments.some((segment) => FORBIDDEN.has(segment))) continue;
+    let node = root;
+    for (let i = 0; i < segments.length; i++) {
+      let segment = segments[i];
+      const next = nextIndex.get(node) ?? 0;
+      if (segment === "") {
+        segment = String(next);
+        nextIndex.set(node, next + 1);
+      } else if (INTEGER_KEY.test(segment) && Number(segment) >= next) {
+        nextIndex.set(node, Number(segment) + 1);
+      }
+      if (i === segments.length - 1) {
+        node[segment] = value;
+        break;
+      }
+      if (!isPlainObject(node[segment])) node[segment] = {};
+      node = node[segment];
+    }
+  }
+  return normalizeLists(root);
+}
+function sanitize(value) {
+  if (Array.isArray(value)) return value.map(sanitize);
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) if (!FORBIDDEN.has(key)) out[key] = sanitize(item);
+  return out;
+}
+function mergeRecursive(base, override) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (FORBIDDEN.has(key)) continue;
+    const current = out[key];
+    out[key] = (isPlainObject(current) || Array.isArray(current)) && (isPlainObject(value) || Array.isArray(value)) ? normalizeLists(mergeRecursive({ ...current }, { ...value })) : value;
+  }
+  return out;
+}
+function isBlank(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function transformLeaves(tree, transform, prefix = "") {
+  const out = {};
+  for (const [key, value] of Object.entries(tree)) out[key] = transformValue(`${prefix}${key}`, value, transform);
+  return out;
+}
+function transformValue(path, value, transform) {
+  if (Array.isArray(value)) return value.map((item, index) => transformValue(`${path}.${index}`, item, transform));
+  if (isPlainObject(value)) return transformLeaves(value, transform, `${path}.`);
+  return transform(path, value);
+}
+
+// IncomingRequest.ts
+var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+var normalizeIp = (ip) => ip.trim().replace(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i, "$1");
+function ipv4ToNumber(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part) || Number(part) > 255)) return void 0;
+  return parts.reduce((total, part) => total * 256 + Number(part), 0);
+}
+function ipMatches(ip, patterns) {
+  const address = normalizeIp(ip);
+  return patterns.some((pattern) => {
+    if (pattern === "*") return true;
+    if (!pattern.includes("/")) return normalizeIp(pattern) === address;
+    const [range, bits] = pattern.split("/");
+    const base = ipv4ToNumber(range);
+    const value = ipv4ToNumber(address);
+    const size = Number(bits);
+    if (base === void 0 || value === void 0 || !(size >= 0 && size <= 32)) return false;
+    const mask = size === 0 ? 0 : ~0 << 32 - size >>> 0;
+    return (base & mask) >>> 0 === (value & mask) >>> 0;
+  });
+}
+var IncomingRequest = class {
+  constructor(raw, options = {}) {
+    this.raw = raw;
+    this.#url = new URL(raw.url);
+    this.#trustedProxies = options.trustedProxies ?? [];
+    this.#maxBodySize = options.maxBodySize === void 0 ? 8 * 1024 * 1024 : options.maxBodySize;
+    this.#query = fromEntries(this.#url.searchParams.entries());
+    this.#method = raw.method.toUpperCase();
+  }
+  raw;
+  #url;
+  #trustedProxies;
+  #maxBodySize;
+  #query;
+  #body = {};
+  #files = {};
+  #content = "";
+  #method;
+  #cookies;
+  #loading;
+  #userResolver;
+  /** Reads and parses the body (JSON, urlencoded or multipart) once, then applies method spoofing. */
+  load() {
+    return this.#loading ??= this.#load();
+  }
+  async #load() {
+    const method = this.raw.method.toUpperCase();
+    if (method !== "GET" && method !== "HEAD" && this.raw.body !== null) {
+      const type = (this.raw.headers.get("content-type") ?? "").toLowerCase();
+      const isJson = type.includes("/json") || type.includes("+json");
+      const isUrlencoded = type.startsWith("application/x-www-form-urlencoded");
+      const isMultipart = type.startsWith("multipart/form-data");
+      if (isJson || isUrlencoded || isMultipart) {
+        const bytes = await readBody(this.raw, this.#maxBodySize);
+        try {
+          if (isJson) {
+            this.#content = new TextDecoder().decode(bytes);
+            this.#body = this.#parseJson(this.#content);
+          } else if (isUrlencoded) {
+            this.#content = new TextDecoder().decode(bytes);
+            this.#body = fromEntries(new URLSearchParams(this.#content).entries());
+          } else {
+            this.#parseForm(await new Response(bytes, { headers: { "content-type": this.raw.headers.get("content-type") ?? "" } }).formData());
+          }
+        } catch {
+        }
+      }
+    }
+    if (method === "POST") {
+      const override = this.raw.headers.get("x-http-method-override") ?? this.#string(this.#body._method) ?? this.#string(this.#query._method);
+      const spoofed = override?.toUpperCase();
+      if (spoofed !== void 0 && /^[A-Z]+$/.test(spoofed) && !["GET", "HEAD", "CONNECT", "TRACE"].includes(spoofed)) {
+        this.#method = spoofed;
+      }
+    }
+    return this;
+  }
+  #parseJson(text) {
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return {};
+    }
+    if (Array.isArray(parsed)) return sanitize({ ...parsed });
+    return isPlainObject(parsed) ? sanitize(parsed) : {};
+  }
+  #parseForm(form) {
+    const fields = [];
+    const files = [];
+    for (const [name, value] of form.entries()) {
+      if (typeof value === "string") fields.push([name, value]);
+      else if (!((value.name ?? "") === "" && value.size === 0)) files.push([name, new FormUploadedFile(value)]);
+    }
+    this.#body = fromEntries(fields);
+    this.#files = fromEntries(files);
+  }
+  #string(value) {
+    return typeof value === "string" && value !== "" ? value : void 0;
+  }
+  method() {
+    return this.#method;
+  }
+  isMethod(method) {
+    return this.#method === method.toUpperCase();
+  }
+  /** The scheme and host, honouring X-Forwarded-Proto/Host from trusted proxies. */
+  root() {
+    const trusted = this.#fromTrustedProxy();
+    const proto = trusted ? this.raw.headers.get("x-forwarded-proto")?.split(",")[0]?.trim() : void 0;
+    const host = trusted ? this.raw.headers.get("x-forwarded-host")?.split(",")[0]?.trim() : void 0;
+    const scheme = proto === "https" || proto === "http" ? proto : this.#url.protocol.slice(0, -1);
+    return `${scheme}://${host !== void 0 && host !== "" ? host : this.#url.host}`;
+  }
+  /** The URL without the query string or a trailing slash. */
+  url() {
+    return `${this.root()}${this.#url.pathname}`.replace(/\/+$/, "");
+  }
+  fullUrl() {
+    return this.#url.search === "" ? this.url() : `${this.url()}${this.#url.search}`;
+  }
+  /** 'posts/1', or '/' for the root. */
+  path() {
+    const trimmed = this.#url.pathname.replace(/^\/+|\/+$/g, "");
+    return trimmed === "" ? "/" : trimmed;
+  }
+  decodedPath() {
+    try {
+      return decodeURIComponent(this.path());
+    } catch {
+      return this.path();
+    }
+  }
+  secure() {
+    return this.root().startsWith("https:");
+  }
+  /** request.is('admin/*'): wildcard match against the decoded path. */
+  is(...patterns) {
+    const path = this.decodedPath();
+    return patterns.some((pattern) => {
+      const trimmed = pattern.replace(/^\/+|\/+$/g, "");
+      return Str2.is(trimmed === "" ? "/" : trimmed, path);
+    });
+  }
+  routeIs(...names) {
+    const name = this.#currentRoute()?.route.getName();
+    return name !== void 0 && names.some((pattern) => Str2.is(pattern, name));
+  }
+  header(name, defaultValue) {
+    return this.raw.headers.get(name) ?? defaultValue;
+  }
+  bearerToken() {
+    const header = this.header("authorization", "");
+    const position = header.toLowerCase().lastIndexOf("bearer ");
+    if (position === -1) return void 0;
+    const token = header.slice(position + 7).split(",")[0].trim();
+    return token === "" ? void 0 : token;
+  }
+  userAgent() {
+    return this.header("user-agent");
+  }
+  /** The socket address, or the right-most untrusted X-Forwarded-For entry when the socket is a trusted proxy. */
+  ip() {
+    const socket = clientAddress(this.raw);
+    if (socket === void 0) return void 0;
+    const address = normalizeIp(socket);
+    if (!this.#fromTrustedProxy()) return address;
+    const chain = (this.raw.headers.get("x-forwarded-for") ?? "").split(",").map((entry) => normalizeIp(entry)).filter((entry) => entry !== "");
+    for (let i = chain.length - 1; i >= 0; i--) if (!ipMatches(chain[i], this.#trustedProxies)) return chain[i];
+    return chain[0] ?? address;
+  }
+  #fromTrustedProxy() {
+    const socket = clientAddress(this.raw);
+    return socket !== void 0 && this.#trustedProxies.length > 0 && ipMatches(socket, this.#trustedProxies);
+  }
+  ajax() {
+    return this.header("x-requested-with") === "XMLHttpRequest";
+  }
+  pjax() {
+    return this.header("x-pjax") === "true";
+  }
+  /** The first Accept type is JSON. */
+  wantsJson() {
+    const first = this.header("accept", "").split(",")[0].trim();
+    return first.includes("/json") || first.includes("+json");
+  }
+  /** Laravel: (ajax and not pjax and accepts anything) or wantsJson. */
+  expectsJson() {
+    const first = this.header("accept", "").split(",")[0].split(";")[0].trim();
+    const acceptsAny = first === "" || first === "*/*" || first === "*";
+    return this.ajax() && !this.pjax() && acceptsAny || this.wantsJson();
+  }
+  /** The raw body text for JSON and urlencoded requests ('' otherwise; the raw stream stays unread for other types). */
+  content() {
+    return this.#content;
+  }
+  query(key, defaultValue) {
+    return Arr.get(this.#query, key, defaultValue);
+  }
+  /** Body wins over the query string (PHP's $body + $query). Files are not input. */
+  input(key, defaultValue) {
+    return Arr.get({ ...this.#query, ...this.#body }, key, defaultValue);
+  }
+  /** Input plus files (array_replace_recursive). */
+  all() {
+    return mergeRecursive({ ...this.#query, ...this.#body }, this.#files);
+  }
+  only(...keys) {
+    const all = this.all();
+    const out = {};
+    for (const key of keys.flat()) if (Arr.has(all, key)) Arr.set(out, key, Arr.get(all, key));
+    return out;
+  }
+  except(...keys) {
+    const all = structuredCloneInput(this.all());
+    for (const key of keys.flat()) Arr.forget(all, key);
+    return all;
+  }
+  has(...keys) {
+    const all = this.all();
+    return keys.flat().every((key) => Arr.has(all, key));
+  }
+  hasAny(...keys) {
+    const all = this.all();
+    return keys.flat().some((key) => Arr.has(all, key));
+  }
+  missing(...keys) {
+    return !this.has(...keys);
+  }
+  filled(key) {
+    return !isBlank(Arr.get(this.all(), key));
+  }
+  string(key, defaultValue = "") {
+    const value = this.input(key);
+    return value === void 0 || value === null ? defaultValue : String(value);
+  }
+  /** PHP's FILTER_VALIDATE_BOOLEAN: '1', 'true', 'on', 'yes' (any case) and true are true. */
+  boolean(key, defaultValue = false) {
+    const value = this.input(key);
+    if (value === void 0) return defaultValue;
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value === 1;
+    return typeof value === "string" && TRUE_VALUES.has(value.trim().toLowerCase());
+  }
+  /** PHP's intval: leading digits, else 0. */
+  integer(key, defaultValue = 0) {
+    const value = this.input(key);
+    if (value === void 0) return defaultValue;
+    if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : 0;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    const parsed = Number.parseInt(String(value).trim(), 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  /** Adds or replaces top-level body values. */
+  merge(values) {
+    this.#body = { ...this.#body, ...sanitize(values) };
+    return this;
+  }
+  /** Rewrites every scalar in the query and the body (TrimStrings and ConvertEmptyStringsToNull use this). */
+  transformInput(transform) {
+    this.#query = transformLeaves(this.#query, transform);
+    this.#body = transformLeaves(this.#body, transform);
+    return this;
+  }
+  file(key) {
+    const value = Arr.get(this.#files, key);
+    return value instanceof FormUploadedFile ? value : void 0;
+  }
+  hasFile(key) {
+    const value = Arr.get(this.#files, key);
+    return value instanceof FormUploadedFile || Array.isArray(value) && value.some((item) => item instanceof FormUploadedFile);
+  }
+  allFiles() {
+    return { ...this.#files };
+  }
+  cookie(name) {
+    return this.cookies()[name];
+  }
+  cookies() {
+    if (this.#cookies === void 0) {
+      const cookies = {};
+      for (const part of (this.raw.headers.get("cookie") ?? "").split(";")) {
+        const index = part.indexOf("=");
+        if (index === -1) continue;
+        const name = part.slice(0, index).trim();
+        if (name === "" || Object.hasOwn(cookies, name)) continue;
+        let value = part.slice(index + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+        try {
+          cookies[name] = decodeURIComponent(value);
+        } catch {
+          cookies[name] = value;
+        }
+      }
+      this.#cookies = cookies;
+    }
+    return { ...this.#cookies };
+  }
+  /** Replaces the parsed cookies (EncryptCookies calls this after decrypting). */
+  setCookies(cookies) {
+    this.#cookies = { ...cookies };
+  }
+  /** One route parameter (after model binding), or all of them. */
+  route(key) {
+    const parameters = this.#currentRoute()?.parameters ?? {};
+    return key === void 0 ? { ...parameters } : parameters[key];
+  }
+  session() {
+    return inject3(Session2);
+  }
+  user(guard) {
+    return this.#userResolver?.(guard);
+  }
+  setUserResolver(resolver) {
+    this.#userResolver = resolver;
+  }
+  /** Validates all() through the ValidationFactory; throws its Validation error on failure. */
+  validate(rules, messages, attributes) {
+    return inject3(ValidationFactory).make(this.all(), rules, messages, attributes).validated();
+  }
+  #currentRoute() {
+    const container = currentContainer2();
+    return container?.bound(CurrentRoute) ? container.make(CurrentRoute) : void 0;
+  }
+};
+function structuredCloneInput(tree) {
+  const out = {};
+  for (const [key, value] of Object.entries(tree)) {
+    out[key] = isPlainObject(value) ? structuredCloneInput(value) : Array.isArray(value) ? [...value] : value;
+  }
+  return out;
+}
+
+// helpers.ts
+import {
+  HttpRequest as HttpRequest2,
+  Redirector,
+  ResponseFactory,
+  UrlGenerator as UrlGenerator2
+} from "@orieljs/contracts";
+import { inject as inject4 } from "@orieljs/container";
+function request(key, defaultValue) {
+  const current = inject4(HttpRequest2);
+  return key === void 0 ? current : current.input(key, defaultValue);
+}
+function response(content, status, headers) {
+  const factory = inject4(ResponseFactory);
+  return content === void 0 ? factory : factory.make(content, status, headers);
+}
+function redirect(to, status) {
+  const redirector = inject4(Redirector);
+  return to === void 0 ? redirector : redirector.to(to, status);
+}
+function back(fallback, status) {
+  return inject4(Redirector).back(fallback, status);
+}
+function url(path, query, absolute) {
+  const generator = inject4(UrlGenerator2);
+  return path === void 0 ? generator : generator.to(path, query, absolute);
+}
+function route(name, parameters, absolute) {
+  return inject4(UrlGenerator2).route(name, parameters, absolute);
+}
+function abort(status, message = "", headers = {}) {
+  if (status instanceof Response) throw new HttpResponseException(status);
+  throw new HttpException(status, message, headers);
+}
+function abortIf(condition, status, message = "", headers = {}) {
+  if (condition) abort(status, message, headers);
+}
+function abortUnless(condition, status, message = "", headers = {}) {
+  if (!condition) abort(status, message, headers);
+}
+
+// HttpResponseFactory.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import { basename } from "path";
+import { Readable } from "stream";
+import { ViewFactory } from "@orieljs/contracts";
+import { inject as inject5 } from "@orieljs/container";
+function contentDisposition(type, name) {
+  const fallback = name.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "\\$&");
+  const header = `${type}; filename="${fallback}"`;
+  return /^[\x20-\x7e]*$/.test(name) ? header : `${header}; filename*=UTF-8''${encodeURIComponent(name)}`;
+}
+var HttpResponseFactory = class {
+  /** Strings default to text/html; charset=utf-8, as in Laravel. */
+  make(content = null, status = 200, headers) {
+    const merged = new Headers(headers);
+    if (typeof content === "string" && !merged.has("content-type")) merged.set("content-type", "text/html; charset=utf-8");
+    return new Response(content, { status, headers: merged });
+  }
+  json(data, status = 200, headers) {
+    const merged = new Headers(headers);
+    if (!merged.has("content-type")) merged.set("content-type", "application/json");
+    return new Response(JSON.stringify(data === void 0 ? null : data), { status, headers: merged });
+  }
+  noContent(status = 204) {
+    return new Response(null, { status });
+  }
+  /** Renders a view (through the ViewFactory) into an HTML response. */
+  async view(name, data = {}, status = 200, headers) {
+    const html = await inject5(ViewFactory).make(name, data).render();
+    return this.make(html, status, headers);
+  }
+  /** Streams a file as an attachment. A missing file is a 404. */
+  download(path, name = basename(path), headers) {
+    return this.#file(path, "attachment", name, headers);
+  }
+  /** Streams a file for the browser to display (Laravel's response()->file()). */
+  file(path, headers) {
+    return this.#file(path, "inline", basename(path), headers);
+  }
+  stream(body, status = 200, headers) {
+    return new Response(body, { status, headers });
+  }
+  async #file(path, disposition, name, headers) {
+    const info = await stat(path).catch(() => void 0);
+    if (info === void 0 || !info.isFile()) throw new HttpException(404);
+    const merged = new Headers(headers);
+    if (!merged.has("content-type")) merged.set("content-type", mimeFromExtension(name));
+    merged.set("content-length", String(info.size));
+    merged.set("content-disposition", contentDisposition(disposition, name));
+    const body = Readable.toWeb(createReadStream(path));
+    return new Response(body, { status: 200, headers: merged });
+  }
+};
+
+// Kernel.ts
+import {
+  ConfigRepository,
+  CurrentRoute as CurrentRoute2,
+  ExceptionHandler,
+  HttpRequest as HttpRequest3,
+  PipelineFactory,
+  Router
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer3 } from "@orieljs/container";
+
+// middleware/ConvertEmptyStringsToNull.ts
+var ConvertEmptyStringsToNull = class {
+  async handle(request2, next) {
+    if (request2 instanceof IncomingRequest) request2.transformInput((_key, value) => value === "" ? null : value);
+    return next(request2);
+  }
+};
+
+// middleware/TrimStrings.ts
+var TRIM = /^[\s\uFEFF\u200B\u200E]+|[\s\uFEFF\u200B\u200E]+$/g;
+var TrimStrings = class {
+  /** Dotted input keys left untouched. Override in a subclass to change. */
+  except = ["current_password", "password", "password_confirmation"];
+  async handle(request2, next) {
+    if (request2 instanceof IncomingRequest) {
+      request2.transformInput(
+        (key, value) => typeof value === "string" && !this.except.includes(key) ? value.replace(TRIM, "") : value
+      );
+    }
+    return next(request2);
+  }
+};
+
+// Kernel.ts
+var plainServerError = () => new Response("Server Error", { status: 500, headers: { "content-type": "text/plain; charset=utf-8" } });
+var Kernel = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  #middleware = [TrimStrings, ConvertEmptyStringsToNull];
+  #requests = /* @__PURE__ */ new WeakMap();
+  getGlobalMiddleware() {
+    return [...this.#middleware];
+  }
+  setGlobalMiddleware(middleware) {
+    this.#middleware = [...middleware];
+    return this;
+  }
+  appendMiddleware(...middleware) {
+    for (const cls of middleware) if (!this.#middleware.includes(cls)) this.#middleware.push(cls);
+    return this;
+  }
+  prependMiddleware(...middleware) {
+    for (const cls of [...middleware].reverse()) if (!this.#middleware.includes(cls)) this.#middleware.unshift(cls);
+    return this;
+  }
+  hasMiddleware(middleware) {
+    return this.#middleware.includes(middleware);
+  }
+  /** Runs in the current request scope (Application.handle() opens one); called directly, it opens its own. */
+  handle(raw) {
+    const current = currentContainer3();
+    const scope = current !== void 0 && current !== this.app ? current : this.app.createScope();
+    return scope.run(() => this.#handle(raw, scope));
+  }
+  async #handle(raw, scope) {
+    let request2;
+    let response2;
+    try {
+      request2 = new IncomingRequest(raw, { trustedProxies: this.#trustedProxies(), maxBodySize: this.#maxBodySize() });
+      scope.instance(HttpRequest3, request2);
+      const state = { scope, request: request2, middleware: [] };
+      this.#requests.set(raw, state);
+      await request2.load();
+      response2 = await this.#sendThroughGlobal(state);
+    } catch (error) {
+      request2 ??= this.#bareRequest(scope, raw);
+      if (request2 !== void 0) {
+        response2 = await this.#renderLast(scope, request2, error);
+      } else {
+        await this.#report(scope, error);
+        response2 = plainServerError();
+      }
+    }
+    if (raw.method.toUpperCase() === "HEAD" && response2.body !== null) {
+      await response2.body.cancel().catch(() => void 0);
+      response2 = new Response(null, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
+    }
+    return response2;
+  }
+  /** The request without options, for rendering an error raised while the real one was being built. */
+  #bareRequest(scope, raw) {
+    try {
+      const request2 = new IncomingRequest(raw);
+      scope.instance(HttpRequest3, request2);
+      return request2;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Runs terminate() on the global and route middleware (inside the request's scope), then Application.terminate(), inside the same scope, so terminating callbacks see the request's bindings. */
+  async terminate(raw, response2) {
+    const state = this.#requests.get(raw);
+    if (state !== void 0) {
+      this.#requests.delete(raw);
+      await state.scope.run(async () => {
+        const route2 = state.scope.bound(CurrentRoute2) ? state.scope.make(CurrentRoute2).middleware : [];
+        for (const middleware of [...state.middleware, ...route2]) {
+          if (typeof middleware.terminate !== "function") continue;
+          try {
+            await middleware.terminate(state.request, response2);
+          } catch (error) {
+            await this.#report(state.scope, error);
+          }
+        }
+        await this.app.terminate();
+      });
+      return;
+    }
+    await this.app.terminate();
+  }
+  #sendThroughGlobal(state) {
+    const { scope, request: request2 } = state;
+    const pipes = this.#middleware.map((cls) => {
+      const instance = scope.make(cls);
+      state.middleware.push(instance);
+      return (passable, next) => this.#guard(scope, passable, () => instance.handle(passable, next));
+    });
+    return scope.make(PipelineFactory).make().send(request2).through(pipes).then((passable) => this.#guard(scope, passable, () => this.#dispatch(scope, passable)));
+  }
+  #dispatch(scope, request2) {
+    return scope.make(Router).dispatch(request2);
+  }
+  /** Converts a Responsable result, and renders a thrown error at this stage (Laravel's Routing\Pipeline). */
+  async #guard(scope, request2, run) {
+    try {
+      const result = await run();
+      if (result instanceof Response) return result;
+      const responsable = result;
+      if (typeof responsable?.toResponse === "function") return await responsable.toResponse(request2);
+      throw new HttpServerError("Middleware must return a Response.");
+    } catch (error) {
+      if (!scope.bound(ExceptionHandler)) throw error;
+      const handler = scope.make(ExceptionHandler);
+      await handler.report(error);
+      return handler.render(request2, error);
+    }
+  }
+  /** Last resort: the handler failed or isn't bound. Never throws. */
+  async #renderLast(scope, request2, error) {
+    if (scope.bound(ExceptionHandler)) {
+      try {
+        const handler = scope.make(ExceptionHandler);
+        await handler.report(error);
+        return await handler.render(request2, error);
+      } catch (renderError) {
+        console.error(renderError);
+      }
+    } else {
+      console.error(error);
+    }
+    return plainServerError();
+  }
+  async #report(scope, error) {
+    try {
+      if (scope.bound(ExceptionHandler)) await scope.make(ExceptionHandler).report(error);
+      else console.error(error);
+    } catch (reportError) {
+      console.error(reportError);
+    }
+  }
+  /** config('http.max_body_size'): bytes, or null for no limit. Anything else is a configuration error. */
+  #maxBodySize() {
+    if (!this.app.bound(ConfigRepository)) return 8 * 1024 * 1024;
+    const value = this.app.make(ConfigRepository).get("http.max_body_size", 8 * 1024 * 1024);
+    if (value === null) return null;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
+    throw new HttpServerError(
+      `Invalid http.max_body_size ${JSON.stringify(value) ?? String(value)}: use a number of bytes (0 or more), or null for no limit.`
+    );
+  }
+  /** config('http.trusted_proxies'): an array, or a comma-separated string such as '*' or '10.0.0.0/8,::1'. */
+  #trustedProxies() {
+    if (!this.app.bound(ConfigRepository)) return [];
+    const value = this.app.make(ConfigRepository).get("http.trusted_proxies", []);
+    if (typeof value === "string") return value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+    return Array.isArray(value) ? value.map(String) : [];
+  }
+};
+
+// MiddlewareConfiguration.ts
+import {
+  ConfigRepository as ConfigRepository2,
+  MiddlewareCallbacks,
+  Router as Router2
+} from "@orieljs/contracts";
+var MiddlewareConfiguration = class {
+  constructor(kernel, router, config) {
+    this.kernel = kernel;
+    this.router = router;
+    this.config = config;
+  }
+  kernel;
+  router;
+  config;
+  append(...middleware) {
+    this.kernel.appendMiddleware(...middleware);
+    return this;
+  }
+  prepend(...middleware) {
+    this.kernel.prependMiddleware(...middleware);
+    return this;
+  }
+  web(options) {
+    return this.#modifyGroup("web", options);
+  }
+  api(options) {
+    return this.#modifyGroup("api", options);
+  }
+  alias(aliases) {
+    for (const [name, middleware] of Object.entries(aliases)) this.router.aliasMiddleware(name, middleware);
+    return this;
+  }
+  group(name, middleware) {
+    this.router.middlewareGroup(name, middleware);
+    return this;
+  }
+  /** Stored in config('http.csrf_except'), which the Session component's VerifyCsrfToken reads. */
+  validateCsrfTokens(options) {
+    const current = this.config?.get("http.csrf_except", []) ?? [];
+    this.config?.set("http.csrf_except", [...current, ...options.except]);
+    return this;
+  }
+  /** Stored in config('http.redirect_guests_to'), which the Auth middleware and the exception handler read. */
+  redirectGuestsTo(url2) {
+    this.config?.set("http.redirect_guests_to", url2);
+    return this;
+  }
+  /** Laravel 11's redirectUsersTo(): stored in config('http.redirect_users_to') for Auth's RedirectIfAuthenticated. */
+  redirectUsersTo(url2) {
+    this.config?.set("http.redirect_users_to", url2);
+    return this;
+  }
+  /** Laravel's order: prepends, then the group minus removals, then appends. */
+  #modifyGroup(name, { append = [], prepend = [], remove = [] }) {
+    const current = this.router.getMiddlewareGroups()[name] ?? [];
+    const moved = /* @__PURE__ */ new Set([...append, ...prepend, ...remove]);
+    this.router.middlewareGroup(name, [...prepend, ...current.filter((entry) => !moved.has(entry)), ...append]);
+    return this;
+  }
+};
+function applyMiddlewareCallbacks(app, kernel) {
+  if (!app.bound(MiddlewareCallbacks)) return;
+  const callbacks = app.make(MiddlewareCallbacks);
+  if (callbacks.length === 0) return;
+  const config = app.bound(ConfigRepository2) ? app.make(ConfigRepository2) : void 0;
+  const configurator = new MiddlewareConfiguration(kernel, app.make(Router2), config);
+  for (const callback of callbacks) callback(configurator);
+}
+
+// ErrorHandler.ts
+import {
+  ConfigRepository as ConfigRepository3,
+  LogManager,
+  Redirector as Redirector2,
+  UrlGenerator as UrlGenerator3,
+  ViewFactory as ViewFactory2
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer4 } from "@orieljs/container";
+
+// errorPages.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+var STATUS_TEXTS = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  413: "Content Too Large",
+  415: "Unsupported Media Type",
+  419: "Page Expired",
+  422: "Unprocessable Content",
+  429: "Too Many Requests",
+  500: "Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+function statusText(status) {
+  return STATUS_TEXTS[status] ?? (status >= 500 ? "Server Error" : "Error");
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => `&#${char.charCodeAt(0)};`);
+}
+function minimalPage(status, message) {
+  const title = escapeHtml(message);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>body{margin:0;font-family:ui-sans-serif,system-ui,sans-serif;background:#f7fafc;color:#1a202c;display:flex;align-items:center;justify-content:center;min-height:100vh}.code{padding:0 1rem;border-right:1px solid #a0aec0;font-size:1.125rem}.message{padding:0 1rem;font-size:1.125rem;text-transform:uppercase;letter-spacing:.05em}</style>
+</head>
+<body><div class="code">${status}</div><div class="message">${title}</div></body>
+</html>`;
+}
+function stackFrames(error) {
+  const frames = [];
+  for (const raw of (error.stack ?? "").split("\n").slice(1)) {
+    const text = raw.trim();
+    const match = /(?:\(|@|at )((?:file:\/\/)?(?:\/|[A-Za-z]:\\)[^()]*?):(\d+):(\d+)\)?$/.exec(text);
+    if (match === null) continue;
+    const location = match[1];
+    const file = location.startsWith("file://") ? fileURLToPath(location) : location;
+    frames.push({ file, line: Number(match[2]), column: Number(match[3]), text });
+  }
+  return frames;
+}
+async function excerpt(frame, radius = 5) {
+  const source = await readFile(frame.file, "utf8").catch(() => void 0);
+  if (source === void 0) return void 0;
+  const lines = source.split("\n");
+  const start = Math.max(1, frame.line - radius);
+  const end = Math.min(lines.length, frame.line + radius);
+  const rows = [];
+  for (let number = start; number <= end; number++) {
+    const current = number === frame.line ? ' class="current"' : "";
+    rows.push(`<tr${current}><td class="n">${number}</td><td><code>${escapeHtml(lines[number - 1] ?? "")}</code></td></tr>`);
+  }
+  return `<table class="source">${rows.join("")}</table>`;
+}
+async function debugPage(error, method, url2) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const frames = stackFrames(err);
+  const appFrame = frames.find((frame) => !frame.file.includes("node_modules") && !frame.file.startsWith("node:")) ?? frames[0];
+  const source = appFrame === void 0 ? void 0 : await excerpt(appFrame);
+  const causes = [];
+  for (let cause = err.cause, depth = 0; cause !== void 0 && depth < 5; cause = cause.cause, depth++) {
+    causes.push(`<li>${escapeHtml(cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause))}</li>`);
+  }
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>${escapeHtml(err.message || err.name)}</title>
+<style>body{margin:0;font-family:ui-sans-serif,system-ui,sans-serif;background:#f3f4f6;color:#111827}main{max-width:1100px;margin:2rem auto;padding:0 1rem}header{background:#fff;border-radius:.5rem;padding:1.5rem;box-shadow:0 1px 3px #0001}.class{color:#dc2626;font-weight:600}.message{font-size:1.5rem;margin:.5rem 0}.request{color:#6b7280}section{background:#fff;border-radius:.5rem;padding:1rem;margin-top:1rem;box-shadow:0 1px 3px #0001;overflow:auto}.source td{padding:0 .5rem;white-space:pre;font-size:.85rem}.source .n{color:#9ca3af;text-align:right}.source .current{background:#fee2e2}ol{font-family:ui-monospace,monospace;font-size:.85rem}</style>
+</head>
+<body><main>
+<header><div class="class">${escapeHtml(err.name)}</div><div class="message">${escapeHtml(err.message)}</div><div class="request">${escapeHtml(method)} ${escapeHtml(url2)}</div></header>
+${appFrame === void 0 ? "" : `<section><div>${escapeHtml(appFrame.file)}:${appFrame.line}</div>${source ?? ""}</section>`}
+<section><ol>${frames.map((frame) => `<li>${escapeHtml(frame.text)}</li>`).join("")}</ol></section>
+${causes.length === 0 ? "" : `<section><div>Caused by</div><ul>${causes.join("")}</ul></section>`}
+</main></body>
+</html>`;
+}
+
+// ErrorHandler.ts
+var NOT_REPORTED = /* @__PURE__ */ new Set(["Http", "ModelNotFound", "Validation", "Authentication", "Authorization", "TokenMismatch"]);
+var HTTP_KINDS = /* @__PURE__ */ new Set(["Http", "ModelNotFound", "Authorization", "TokenMismatch"]);
+var kindOf = (error) => typeof error === "object" && error !== null && typeof error.kind === "string" ? error.kind : void 0;
+function statusFor(error) {
+  const status = error?.status;
+  switch (kindOf(error)) {
+    case "Http":
+      return status ?? 500;
+    case "ModelNotFound":
+      return 404;
+    case "Authorization":
+      return status ?? 403;
+    case "TokenMismatch":
+      return 419;
+    case "Authentication":
+      return 401;
+    case "Validation":
+      return status ?? 422;
+    case "Server":
+      return status ?? 500;
+    default:
+      return 500;
+  }
+}
+function summarizeValidation(errors) {
+  const messages = Object.values(errors).flat();
+  if (messages.length === 0) return "The given data was invalid.";
+  const more = messages.length - 1;
+  return more === 0 ? messages[0] : `${messages[0]} (and ${more} more ${more === 1 ? "error" : "errors"})`;
+}
+var isHttpLike = (error) => {
+  const kind = kindOf(error);
+  return kind !== void 0 && HTTP_KINDS.has(kind);
+};
+var ErrorHandler = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  /** Input keys never flashed back on a validation redirect. */
+  dontFlash = ["current_password", "password", "password_confirmation"];
+  #reportCallbacks = [];
+  #renderCallbacks = [];
+  #dontReport = [];
+  #reported = /* @__PURE__ */ new WeakSet();
+  reportUsing(callback) {
+    this.#reportCallbacks.push(callback);
+  }
+  renderUsing(callback) {
+    this.#renderCallbacks.push(callback);
+  }
+  ignore(...classes) {
+    this.#dontReport.push(...classes);
+  }
+  shouldReport(error) {
+    const kind = kindOf(error);
+    if (kind !== void 0 && NOT_REPORTED.has(kind)) return false;
+    return !this.#dontReport.some((cls) => error instanceof cls);
+  }
+  /** Report callbacks first (returning false stops the default log), then LogManager.error(), else console.error. Once per error. */
+  async report(error) {
+    if (!this.shouldReport(error)) return;
+    if (typeof error === "object" && error !== null) {
+      if (this.#reported.has(error)) return;
+      this.#reported.add(error);
+    }
+    try {
+      for (const callback of this.#reportCallbacks) if (await callback(error) === false) return;
+      const container = this.#container();
+      if (container.bound(LogManager)) {
+        const message = error instanceof Error ? error.message : String(error);
+        container.make(LogManager).error(message, { exception: error });
+      } else {
+        console.error(error);
+      }
+    } catch (reportError) {
+      console.error(reportError);
+    }
+  }
+  async render(request2, error) {
+    for (const callback of this.#renderCallbacks) {
+      const response3 = await callback(error, request2);
+      if (response3 instanceof Response) return response3;
+    }
+    if (error instanceof HttpResponseException) return error.response;
+    const custom = await this.#renderCustom(request2, error);
+    if (custom !== void 0) return custom;
+    const http = this.#httpRequest(request2);
+    const kind = kindOf(error);
+    let response2;
+    if (kind === "Validation") response2 = await this.#renderValidation(http, error);
+    else if (kind === "Authentication") response2 = await this.#renderAuthentication(http, error);
+    else if (http.expectsJson()) response2 = this.#renderJson(error);
+    else response2 = await this.#renderHtml(http, error);
+    const headers = error?.headers;
+    if (headers !== void 0) for (const [name, value] of Object.entries(headers)) response2.headers.set(name, value);
+    return response2;
+  }
+  /** An error with its own render(request) or toResponse(request) (Laravel's renderable exceptions / Responsable). */
+  async #renderCustom(request2, error) {
+    if (typeof error !== "object" || error === null) return void 0;
+    const candidate = error;
+    for (const method of [candidate.render, candidate.toResponse]) {
+      if (typeof method !== "function") continue;
+      const response2 = await method.call(error, request2);
+      if (response2 instanceof Response) return response2;
+    }
+    return void 0;
+  }
+  async #renderValidation(request2, error) {
+    if (request2.expectsJson()) {
+      return this.#json({ message: summarizeValidation(error.errors), errors: error.errors }, statusFor(error));
+    }
+    const input = { ...request2.input() };
+    for (const key of this.dontFlash) delete input[key];
+    const container = this.#container();
+    if (!container.bound(Redirector2)) {
+      return this.#redirect(error.redirectTo ?? request2.header("referer") ?? "/");
+    }
+    const redirector = container.make(Redirector2);
+    const redirect2 = error.redirectTo !== void 0 ? redirector.to(error.redirectTo) : redirector.back();
+    const response2 = await redirect2.withInput(input).withErrors(error.errors, error.errorBag).toResponse(request2);
+    return response2;
+  }
+  async #renderAuthentication(request2, error) {
+    if (request2.expectsJson()) return this.#json({ message: error.message || "Unauthenticated." }, 401);
+    const target = error.redirectTo ?? this.#guestRedirect(request2);
+    const container = this.#container();
+    if (!container.bound(Redirector2)) return this.#redirect(target);
+    const redirector = container.make(Redirector2);
+    const redirect2 = typeof redirector.guest === "function" ? redirector.guest(target) : redirector.to(target);
+    return await redirect2.toResponse(request2);
+  }
+  /** config('http.redirect_guests_to'), then route('login'), then '/login'. */
+  #guestRedirect(request2) {
+    const configured = this.#config("http.redirect_guests_to", void 0);
+    if (typeof configured === "function") return String(configured(request2));
+    if (typeof configured === "string" && configured !== "") return configured;
+    const container = this.#container();
+    if (container.bound(UrlGenerator3)) {
+      const url2 = container.make(UrlGenerator3);
+      if (url2.hasRoute("login")) return url2.route("login");
+    }
+    return "/login";
+  }
+  #renderJson(error) {
+    const status = statusFor(error);
+    if (isHttpLike(error)) {
+      const message = error instanceof Error && error.message !== "" ? error.message : statusText(status);
+      return this.#json({ message }, status);
+    }
+    if (!this.#debug()) return this.#json({ message: "Server Error" }, status);
+    const err = error instanceof Error ? error : new Error(String(error));
+    const [frame] = stackFrames(err);
+    return this.#json(
+      {
+        message: err.message,
+        exception: err.name,
+        file: frame?.file,
+        line: frame?.line,
+        trace: stackFrames(err).map((entry) => entry.text)
+      },
+      status
+    );
+  }
+  async #renderHtml(request2, error) {
+    const status = statusFor(error);
+    if (!isHttpLike(error) && this.#debug()) {
+      return this.#html(await debugPage(error, request2.method(), request2.fullUrl()), status);
+    }
+    const message = status === 403 && error instanceof Error && error.message !== "" ? error.message : statusText(status);
+    const view = await this.#errorView(status, error, message);
+    return this.#html(view ?? minimalPage(status, message), status);
+  }
+  /** resources/views/errors/{status}.tsx, then errors/4xx or errors/5xx, through the ViewFactory. */
+  async #errorView(status, error, message) {
+    const container = this.#container();
+    if (!container.bound(ViewFactory2)) return void 0;
+    const views = container.make(ViewFactory2);
+    for (const name of [`errors.${status}`, `errors.${Math.floor(status / 100)}xx`]) {
+      if (!views.exists(name)) continue;
+      try {
+        return await views.make(name, { exception: error, status, message }).render();
+      } catch (viewError) {
+        await this.report(viewError);
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  #httpRequest(request2) {
+    if (typeof request2 === "object" && request2 !== null && typeof request2.expectsJson === "function") {
+      return request2;
+    }
+    return new IncomingRequest(request2 instanceof Request ? request2 : new Request("http://localhost/"));
+  }
+  #json(body, status) {
+    return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+  }
+  #html(body, status) {
+    return new Response(body, { status, headers: { "content-type": "text/html; charset=utf-8" } });
+  }
+  #redirect(location) {
+    return new Response(null, { status: 302, headers: { Location: location } });
+  }
+  #debug() {
+    return this.#config("app.debug", false) === true;
+  }
+  #config(key, fallback) {
+    return this.app.bound(ConfigRepository3) ? this.app.make(ConfigRepository3).get(key, fallback) : fallback;
+  }
+  /** The request scope while handling a request (so scoped services resolve), else the application. */
+  #container() {
+    return currentContainer4() ?? this.app;
+  }
+};
+
+// ExceptionsConfiguration.ts
+import { ExceptionCallbacks } from "@orieljs/contracts";
+var ExceptionsConfiguration = class {
+  constructor(handler) {
+    this.handler = handler;
+  }
+  handler;
+  report(callback) {
+    this.handler.reportUsing(callback);
+    return this;
+  }
+  render(callback) {
+    this.handler.renderUsing(callback);
+    return this;
+  }
+  dontReport(...classes) {
+    this.handler.ignore(...classes);
+    return this;
+  }
+};
+function applyExceptionCallbacks(app, handler) {
+  if (!app.bound(ExceptionCallbacks)) return;
+  const configurator = new ExceptionsConfiguration(handler);
+  for (const callback of app.make(ExceptionCallbacks)) callback(configurator);
+}
+
+// server/types.ts
+import { HttpKernel } from "@orieljs/contracts";
+async function terminateRequest(app, request2, response2) {
+  try {
+    if (app.bound(HttpKernel)) await app.make(HttpKernel).terminate?.(request2, response2);
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function handleSafely(app, request2) {
+  try {
+    return await app.handle(request2);
+  } catch (error) {
+    console.error(error);
+    return plainServerError();
+  }
+}
+function exitOnSignals(close, closed) {
+  const onSignal = () => {
+    void close().then(() => process.exit(0));
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  void closed.then(() => {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  });
+}
+var displayHost = (hostname) => hostname.includes(":") ? `[${hostname}]` : hostname;
+
+// server/bun.ts
+function bunRuntime() {
+  return globalThis.Bun;
+}
+async function serveBun(app, options) {
+  const bun = bunRuntime();
+  if (bun === void 0) throw new HttpServerError("Bun.serve is not available: the process is not running on Bun.");
+  let markClosed = () => void 0;
+  const closed = new Promise((resolve) => markClosed = resolve);
+  const server = bun.serve({
+    port: options.port,
+    hostname: options.hostname,
+    async fetch(request2, current) {
+      setClientAddress(request2, current.requestIP(request2)?.address);
+      const response2 = await handleSafely(app, request2);
+      setTimeout(() => void terminateRequest(app, request2, response2), 0);
+      return response2;
+    },
+    error(error) {
+      console.error(error);
+      return plainServerError();
+    }
+  });
+  let closing;
+  const close = () => closing ??= (async () => {
+    let timer;
+    const forced = new Promise((resolve) => {
+      timer = setTimeout(() => void Promise.resolve(server.stop(true)).then(resolve), options.shutdownTimeout);
+    });
+    await Promise.race([Promise.resolve(server.stop(false)), forced]);
+    clearTimeout(timer);
+    markClosed();
+  })();
+  if (options.signals) exitOnSignals(close, closed);
+  return {
+    runtime: "bun",
+    hostname: options.hostname,
+    port: server.port,
+    url: `http://${displayHost(options.hostname)}:${server.port}`,
+    close,
+    closed
+  };
+}
+
+// server/node.ts
+import { createServer } from "http";
+import { Readable as Readable2 } from "stream";
+import { pipeline } from "stream/promises";
+function requestBody(req) {
+  let finished = false;
+  const detach = () => {
+    finished = true;
+    req.off("data", onData);
+    req.off("end", onEnd);
+    req.off("error", onError);
+    req.off("close", onClose);
+  };
+  let controller;
+  const onData = (chunk) => {
+    if (finished) return;
+    controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    if ((controller.desiredSize ?? 0) <= 0) req.pause();
+  };
+  const onEnd = () => {
+    if (finished) return;
+    detach();
+    controller.close();
+  };
+  const onError = (error) => {
+    if (finished) return;
+    detach();
+    controller.error(error);
+  };
+  const onClose = () => {
+    if (!finished && !req.complete) onError(new Error("The request was aborted."));
+  };
+  return new ReadableStream(
+    {
+      start(c) {
+        controller = c;
+        req.on("data", onData);
+        req.on("end", onEnd);
+        req.on("error", onError);
+        req.on("close", onClose);
+        req.pause();
+      },
+      pull() {
+        req.resume();
+      },
+      cancel() {
+        detach();
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+function toWebRequest(req, res, fallbackHost) {
+  const target = req.url ?? "/";
+  const url2 = new URL(`http://${req.headers.host ?? fallbackHost}${target.startsWith("/") ? target : `/${target}`}`);
+  const headers = new Headers();
+  for (let i = 0; i < req.rawHeaders.length; i += 2) {
+    const name = req.rawHeaders[i];
+    if (!name.startsWith(":")) headers.append(name, req.rawHeaders[i + 1]);
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const controller = new AbortController();
+  res.once("close", () => {
+    if (!res.writableFinished) controller.abort();
+  });
+  const init = { method, headers, signal: controller.signal };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = requestBody(req);
+    init.duplex = "half";
+  }
+  return new Request(url2, init);
+}
+async function writeResponse(res, response2) {
+  res.statusCode = response2.status;
+  if (response2.statusText !== "") res.statusMessage = response2.statusText;
+  response2.headers.forEach((value, name) => {
+    if (name !== "set-cookie") res.setHeader(name, value);
+  });
+  const cookies = response2.headers.getSetCookie();
+  if (cookies.length > 0) res.setHeader("set-cookie", cookies);
+  if (response2.body === null) {
+    res.end();
+    return;
+  }
+  await pipeline(Readable2.fromWeb(response2.body), res);
+}
+async function serveNode(app, options) {
+  const fallbackHost = `${displayHost(options.hostname)}:${options.port}`;
+  const server = createServer((req, res) => {
+    void (async () => {
+      let request2;
+      try {
+        request2 = toWebRequest(req, res, fallbackHost);
+      } catch {
+        res.statusCode = 400;
+        res.end("Bad Request");
+        return;
+      }
+      setClientAddress(request2, req.socket.remoteAddress);
+      const response2 = await handleSafely(app, request2);
+      try {
+        await writeResponse(res, response2);
+      } catch {
+        res.destroy();
+      }
+      await terminateRequest(app, request2, response2);
+    })();
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.hostname, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const closed = new Promise((resolve) => server.once("close", () => resolve()));
+  let closing;
+  const close = () => closing ??= (async () => {
+    const done = new Promise((resolve) => server.close(() => resolve()));
+    server.closeIdleConnections();
+    const idle = setInterval(() => server.closeIdleConnections(), 50);
+    const force = setTimeout(() => server.closeAllConnections(), options.shutdownTimeout);
+    await done;
+    clearInterval(idle);
+    clearTimeout(force);
+  })();
+  if (options.signals) exitOnSignals(close, closed);
+  return {
+    runtime: "node",
+    hostname: options.hostname,
+    port: address.port,
+    url: `http://${displayHost(options.hostname)}:${address.port}`,
+    close,
+    closed
+  };
+}
+
+// server/serve.ts
+function detectRuntime() {
+  return bunRuntime() !== void 0 ? "bun" : "node";
+}
+async function serve(app, options = {}) {
+  const resolved = {
+    port: options.port ?? Number(process.env.PORT ?? process.env.SERVER_PORT ?? 8e3),
+    hostname: options.hostname ?? "127.0.0.1",
+    signals: options.signals ?? true,
+    shutdownTimeout: options.shutdownTimeout ?? 1e4
+  };
+  await app.boot();
+  const runtime = options.runtime ?? detectRuntime();
+  const server = runtime === "bun" ? await serveBun(app, resolved) : await serveNode(app, resolved);
+  const onListen = options.onListen ?? ((running) => console.log(`Server running on [${running.url}].`));
+  onListen(server);
+  return server;
+}
+
+// commands.ts
+import { existsSync } from "fs";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname } from "path";
+import {
+  Router as Router3
+} from "@orieljs/contracts";
+function io(command) {
+  return {
+    option: (name) => {
+      const value = command.option(name);
+      return value === void 0 || value === null || value === false || value === "" ? void 0 : String(value);
+    },
+    flag: (name) => {
+      const value = command.option(name);
+      return value === true || value === "true" || value === "1";
+    },
+    info: (message) => command.info(message),
+    line: (message) => command.line(message),
+    warn: (message) => command.warn(message),
+    error: (message) => command.error(message)
+  };
+}
+var middlewareName = (reference) => typeof reference === "string" ? reference : reference.name;
+function routeListRows(routes) {
+  const rows = routes.map((route2) => {
+    const listable = route2;
+    return {
+      method: route2.methods.join("|"),
+      uri: route2.uri,
+      name: route2.getName() ?? null,
+      action: typeof listable.getActionName === "function" ? listable.getActionName() : "Closure",
+      middleware: typeof listable.gatherMiddleware === "function" ? listable.gatherMiddleware().map(middlewareName) : []
+    };
+  });
+  return rows.sort((a, b) => a.uri < b.uri ? -1 : a.uri > b.uri ? 1 : 0);
+}
+function filterRouteList(rows, filters) {
+  const excluded = (filters.exceptPath ?? "").split(",").filter((path) => path !== "");
+  return rows.filter((row) => {
+    if (filters.name !== void 0 && !(row.name ?? "").includes(filters.name)) return false;
+    if (filters.path !== void 0 && !row.uri.includes(filters.path)) return false;
+    if (filters.method !== void 0 && !row.method.includes(filters.method.toUpperCase())) return false;
+    return !excluded.some((path) => row.uri.includes(path));
+  });
+}
+function formatRouteList(rows, width) {
+  const methodWidth = Math.max(...rows.map((row) => row.method.length));
+  const lines = rows.map((row) => {
+    const spaces = " ".repeat(Math.max(methodWidth + 6 - row.method.length, 0));
+    const action = row.action === "Closure" ? row.name ?? "" : row.name === null ? row.action : `${row.name} \u203A ${row.action}`;
+    const used = row.method.length + spaces.length + row.uri.length + action.length + 6 + (action === "" ? 0 : 1);
+    const dots = ".".repeat(Math.max(width - used, 0));
+    return `  ${row.method} ${spaces}${row.uri}${dots === "" ? "" : ` ${dots}`}${action === "" ? "" : ` ${action}`}`;
+  });
+  const count = `Showing [${rows.length}] ${rows.length === 1 ? "route" : "routes"}`;
+  return [...lines, "", `${" ".repeat(Math.max(width - count.length - 2, 0))}${count}`];
+}
+var API_ROUTES_STUB = `import { request, Route } from '@orieljs/framework'
+
+Route.get('/user', () => request().user()).middleware('auth:token')
+`;
+function addApiRouting(source) {
+  const code = source.replace(/^[ \t]*\/\/.*$/gm, "");
+  if (/withRouting\(\s*\{[^}]*\bapi\s*:/.test(code)) return source;
+  const commented = /^([ \t]*)\/\/\s*(api:\s*['"`][^'"`\n]*['"`],?)[ \t]*$/m.exec(source);
+  if (commented !== null) return source.replace(commented[0], () => `${commented[1]}${commented[2]}`);
+  const web = /^([ \t]*)web:\s*(['"`])[^'"`\n]*\2[ \t]*,?[ \t]*$/m.exec(source);
+  if (web !== null) {
+    const line = web[0].trimEnd();
+    return source.replace(web[0], () => `${line.endsWith(",") ? line : `${line},`}
+${web[1]}api: 'routes/api.ts',`);
+  }
+  const inline = /withRouting\(\s*\{/.exec(source);
+  if (inline !== null) return source.replace(inline[0], () => `${inline[0]} api: 'routes/api.ts',`);
+  const create = /^([ \t]*)\.create\(\)/m.exec(source);
+  if (create !== null) return source.replace(create[0], () => `${create[1]}.withRouting({ api: 'routes/api.ts' })
+${create[0]}`);
+  return void 0;
+}
+function registerHttpCommands(kernel, app, options = {}) {
+  const serveApp = options.serve ?? serve;
+  const terminalWidth = options.terminalWidth ?? (() => process.stdout.columns ?? 120);
+  kernel.command(
+    "serve {--host=127.0.0.1 : The host address to serve the application on} {--port= : The port to serve the application on}",
+    async function() {
+      const out = io(this);
+      const port = out.option("port");
+      if (port !== void 0 && !/^\d+$/.test(port)) {
+        out.error("The --port option must be a number.");
+        return 1;
+      }
+      const server = await serveApp(app, {
+        hostname: out.option("host") ?? "127.0.0.1",
+        ...port !== void 0 && { port: Number(port) },
+        onListen: (running) => {
+          out.info(`Server running on [${running.url}].`);
+          out.line("Press Ctrl+C to stop the server");
+        }
+      });
+      await server.closed;
+      return 0;
+    }
+  ).purpose("Serve the application on the Oriel development server");
+  kernel.command(
+    "route:list {--method= : Filter the routes by method} {--name= : Filter the routes by name} {--path= : Only show routes matching the given path pattern} {--except-path= : Do not display the routes matching the given path pattern} {--reverse : Reverse the ordering of the routes} {--json : Output the route list as JSON}",
+    function() {
+      const out = io(this);
+      if (!app.bound(Router3)) {
+        out.error("The router is not available. Is the Routing service provider registered?");
+        return 1;
+      }
+      const all = routeListRows(app.make(Router3).getRoutes());
+      if (all.length === 0) {
+        out.error("Your application doesn't have any routes.");
+        return 0;
+      }
+      const rows = filterRouteList(all, {
+        ...out.option("method") !== void 0 && { method: out.option("method") },
+        ...out.option("name") !== void 0 && { name: out.option("name") },
+        ...out.option("path") !== void 0 && { path: out.option("path") },
+        ...out.option("except-path") !== void 0 && { exceptPath: out.option("except-path") }
+      });
+      if (rows.length === 0) {
+        out.error("Your application doesn't have any routes matching the given criteria.");
+        return 0;
+      }
+      if (out.flag("reverse")) rows.reverse();
+      if (out.flag("json")) {
+        out.line(JSON.stringify(rows));
+        return 0;
+      }
+      for (const line of formatRouteList(rows, terminalWidth())) out.line(line);
+      return 0;
+    }
+  ).purpose("List all registered routes");
+  kernel.command("install:api {--force : Overwrite any existing API routes file}", async function() {
+    const out = io(this);
+    const routesFile = app.basePath("routes/api.ts");
+    if (existsSync(routesFile) && !out.flag("force")) {
+      out.error("API routes file already exists.");
+    } else {
+      await mkdir(dirname(routesFile), { recursive: true });
+      await writeFile(routesFile, API_ROUTES_STUB);
+      out.info("Published API routes file.");
+    }
+    const bootstrapFile = app.bootstrapPath("app.ts");
+    const source = existsSync(bootstrapFile) ? await readFile2(bootstrapFile, "utf8") : void 0;
+    const updated = source === void 0 ? void 0 : addApiRouting(source);
+    if (updated === void 0) {
+      out.warn(
+        "Unable to automatically add API route definition to bootstrap file. Add api: 'routes/api.ts' to withRouting() in bootstrap/app.ts."
+      );
+    } else if (updated !== source) {
+      await writeFile(bootstrapFile, updated);
+    }
+    out.info("API scaffolding installed. Run [oriel migrate] to create the personal access tokens table.");
+    return 0;
+  }).purpose("Create an API routes file and prepare the application for API authentication");
+}
+
+// HttpServiceProvider.ts
+import { ConsoleKernel, ExceptionHandler as ExceptionHandler2, HttpKernel as HttpKernel2, Redirector as Redirector3, ResponseFactory as ResponseFactory2, Router as Router4 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var HttpServiceProvider = class extends ServiceProvider {
+  register() {
+    this.mergeConfigFrom(
+      {
+        trusted_proxies: [],
+        max_body_size: 8 * 1024 * 1024,
+        csrf_except: [],
+        redirect_guests_to: void 0,
+        redirect_users_to: void 0
+      },
+      "http"
+    );
+    this.app.singleton(HttpKernel2, () => new Kernel(this.app));
+    this.app.singleton(ExceptionHandler2, () => {
+      const handler = new ErrorHandler(this.app);
+      applyExceptionCallbacks(this.app, handler);
+      return handler;
+    });
+    this.app.singleton(ResponseFactory2, () => new HttpResponseFactory());
+    this.app.singleton(Redirector3, () => new HttpRedirector());
+  }
+  boot() {
+    this.app.booted(() => {
+      const kernel = this.app.make(HttpKernel2);
+      if (kernel instanceof Kernel && this.app.bound(Router4)) applyMiddlewareCallbacks(this.app, kernel);
+    });
+    if (this.app.bound(ConsoleKernel)) registerHttpCommands(this.app.make(ConsoleKernel), this.app);
+  }
+};
+export {
+  API_ROUTES_STUB,
+  ConvertEmptyStringsToNull,
+  ErrorHandler,
+  ExceptionsConfiguration,
+  FormUploadedFile,
+  HttpException,
+  HttpRedirectResponse,
+  HttpRedirector,
+  HttpResponseException,
+  HttpResponseFactory,
+  HttpServerError,
+  HttpServiceProvider,
+  IncomingRequest,
+  Kernel,
+  MiddlewareConfiguration,
+  TrimStrings,
+  abort,
+  abortIf,
+  abortUnless,
+  addApiRouting,
+  applyExceptionCallbacks,
+  applyMiddlewareCallbacks,
+  back,
+  bunRuntime,
+  clientAddress,
+  contentDisposition,
+  currentRequest,
+  debugPage,
+  detectRuntime,
+  escapeHtml,
+  extensionFromMime,
+  filterRouteList,
+  formatRouteList,
+  fromEntries,
+  ipMatches,
+  isBlank,
+  mergeRecursive,
+  mimeFromExtension,
+  minimalPage,
+  normalizeLists,
+  optionalCookieJar,
+  optionalSession,
+  parseBracketKey,
+  readBody,
+  redirect,
+  registerHttpCommands,
+  request,
+  requestScope,
+  response,
+  route,
+  routeListRows,
+  sanitize,
+  serve,
+  serveBun,
+  serveNode,
+  setClientAddress,
+  stackFrames,
+  statusFor,
+  statusText,
+  summarizeValidation,
+  toWebRequest,
+  transformLeaves,
+  url,
+  writeResponse
+};
+//# sourceMappingURL=index.js.map