@barqel/barq 1.0.0 → 1.0.2

package/dist/app.js

@@ -1,1370 +0,0 @@
-import { cpus } from "node:os";
-import { Context } from "./context";
-import { applyPendingCookies } from "./cookies";
-import { errorToResponse, HttpError } from "./errors";
-import { compileTrustProxy, isIpRange } from "./internal/ip";
-import { scanPathname } from "./internal/pathname";
-import { findQueryParam, findQueryParamAll } from "./internal/query";
-import { analyzeHandler, } from "./internal/scan";
-import { stopServer } from "./internal/shutdown";
-import { MATCH_HANDLER, MATCH_NOT_ALLOWED, SegmentTrie } from "./internal/trie";
-import { composeMiddlewareDispatcher, composeMiddlewares, isThenable, unwindAfter, } from "./middleware";
-const METHODS = [
-    "GET",
-    "POST",
-    "PUT",
-    "DELETE",
-    "PATCH",
-    "HEAD",
-    "OPTIONS",
-];
-const MAX_ROUTE_SEGMENTS = 256;
-const EMPTY_PARAMS = Object.freeze(Object.create(null));
-// Prebuilt `Headers` instances rather than plain objects: the `Response`
-// constructor has to parse/validate header names and values on every call, and
-// handing it an already-built `Headers` skips that work. Measured ~285ns per
-// response versus a frozen plain object on Bun 1.4.
-//
-// Safe to share: `new Response(body, { headers })` copies the entries into a
-// fresh `Headers` on the response, so mutating `response.headers` later (cookie
-// application, `stripBody`) never touches these. Never mutate them here.
-const FAST_JSON_HEADERS = new Headers({
-    "content-type": "application/json; charset=utf-8",
-});
-const FAST_TEXT_HEADERS = new Headers({
-    "content-type": "text/plain; charset=utf-8",
-});
-const _FAST_JSON_INIT = Object.freeze({
-    headers: FAST_JSON_HEADERS,
-});
-const _FAST_TEXT_INIT = Object.freeze({
-    headers: FAST_TEXT_HEADERS,
-});
-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);
-}
-const 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;
-}
-const 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() {
-        // biome-ignore lint/suspicious/noAssignInExpressions: Preserve the lazy-cache fast path.
-        return this._url ?? (this._url = this.req.url);
-    }
-    get pathname() {
-        if (this._pathname !== undefined)
-            return this._pathname;
-        // biome-ignore lint/suspicious/noAssignInExpressions: Preserve the lazy-cache fast path.
-        return (this._pathname = scanPathname(this.url));
-    }
-    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;
-    }
-}
-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 = decodeSegment(seg);
-        if (decoded === "." || decoded === "..") {
-            throw new Error(`Invalid route pattern "${pattern}": dot segments '.', '..' not allowed in route patterns`);
-        }
-    }
-}
-function decodeSegment(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((process) => !process.killed);
-    if (running.length === 0)
-        return false;
-    for (const process of running)
-        process.kill("SIGTERM");
-    const exited = Promise.all(running.map((process) => process.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 process of running) {
-            if (!process.killed)
-                process.kill("SIGKILL");
-        }
-        await exited;
-    }
-    return forced;
-}
-export 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;
-    }
-}
-export class App {
-    fetchHandler = (req, srv) => this.handle(req, srv);
-    trie = new SegmentTrie();
-    middlewares = [];
-    nativeRoutes = [];
-    server = null;
-    clusterProcesses = null;
-    _options;
-    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Accessed through ContextApplication.
-    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 ?? process.env.NODE_ENV === "development";
-        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;
-    }
-    /** @internal */
-    _register(method, pattern, args) {
-        return this._registerMethods([method], pattern, args);
-    }
-    /** @internal */
-    _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 &&
-                            raw.constructor.name !== "AsyncFunction") {
-                            const serializer = analysis.paramSerializer;
-                            const responseInit = { headers: FAST_JSON_HEADERS };
-                            methodMap[nr.method] = (req) => {
-                                const params = req.params ?? EMPTY_PARAMS;
-                                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) {
-                        const isAsync = raw.constructor.name === "AsyncFunction";
-                        const reusedLightCtx = new FastLightContext(null, EMPTY_PARAMS);
-                        let lightCtxInUse = false;
-                        methodMap[nr.method] = (req) => {
-                            const params = isDyn
-                                ? (req
-                                    .params ?? EMPTY_PARAMS)
-                                : EMPTY_PARAMS;
-                            const useFresh = isAsync || lightCtxInUse;
-                            const ctx = useFresh
-                                ? new FastLightContext(req, params)
-                                : reusedLightCtx.init(req, params);
-                            if (!useFresh)
-                                lightCtxInUse = true;
-                            let res;
-                            try {
-                                res = raw(ctx);
-                            }
-                            catch (err) {
-                                if (!useFresh)
-                                    lightCtxInUse = false;
-                                return errorToResponse(err, this.development);
-                            }
-                            if (typeof res === "object" && res !== null) {
-                                if (res instanceof Response) {
-                                    if (!useFresh)
-                                        lightCtxInUse = false;
-                                    return res;
-                                }
-                                if (!isThenable(res)) {
-                                    if (!useFresh)
-                                        lightCtxInUse = false;
-                                    return Response.json(res);
-                                }
-                            }
-                            else if (typeof res === "string") {
-                                if (!useFresh)
-                                    lightCtxInUse = false;
-                                return new Response(res, { headers: FAST_TEXT_HEADERS });
-                            }
-                            else if (!isThenable(res)) {
-                                if (!useFresh)
-                                    lightCtxInUse = false;
-                                return new Response(JSON.stringify(res), {
-                                    headers: FAST_JSON_HEADERS,
-                                });
-                            }
-                            return Promise.resolve(res)
-                                .then((r) => {
-                                if (!useFresh)
-                                    lightCtxInUse = false;
-                                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) => {
-                                if (!useFresh)
-                                    lightCtxInUse = false;
-                                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 = [];
-        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 idx = processes.indexOf(proc);
-                    if (idx !== -1) {
-                        processes.splice(idx, 1);
-                    }
-                    processes.push(spawnWorker());
-                }
-            });
-            return proc;
-        };
-        try {
-            for (let i = 0; i < cpus().length; i++) {
-                processes.push(spawnWorker());
-            }
-        }
-        catch (error) {
-            for (const process of processes)
-                process.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,
-    });
-}
-//# sourceMappingURL=app.js.map