@mpen/routekit 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1152 @@
+import { A as stream, B as parseMediaType, C as isChunkDirective, D as isStatusDirective, E as isRoutekitDirective, F as mediaRangeToContentType, I as mediaTypeMatches, L as normalizeMediaType, N as mediaRangeAccepts, O as isStreamDirective, P as mediaRangeQuality, R as parseAcceptHeader, S as headers, T as isHeadersDirective, _ as jsonResponseBodySerializer, a as createRoutekitRequest, b as chunk, c as jsonRequestBodyParser, d as urlEncodedRequestBodyParser, f as defineMiddleware, g as defaultResponseBodySerializers, h as createStartStream, i as UnsupportedRequestBodyMediaTypeError, j as mergeRouteSchemas, k as status, l as responseFromRequestBodyError, m as createAsyncStream, n as RequestBodyLengthMismatchError, o as defaultRequestBodyParsers, p as isDeclaredMiddleware, r as RequestBodyTooLargeError, s as formDataRequestBodyParser, t as RequestBodyError, u as textRequestBodyParser, v as jsonLinesFramer, w as isHeadDirective, x as head, y as sseFramer, z as parseContentType } from "./request-Dn0zc-xm.mjs";
+import { a as response, i as isRoutekitResponse, n as isResponseBodyInit, r as isRoutekitBody, t as body } from "./core-DbmQauwS.mjs";
+import { a as text } from "./content-BuDOmhH_.mjs";
+import { CommonHeaders, HttpMethod, HttpStatus, StatusText } from "@mpen/http";
+import { ConsoleLogger } from "@mpen/logger";
+//#region src/router/lib/pathname.ts
+function joinPrefixPathname(prefix, pathname) {
+	if (!prefix) return pathname;
+	if (!prefix.startsWith("/")) prefix = "/" + prefix;
+	if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	if (pathname === "/") return prefix || "/";
+	if (!pathname.startsWith("/")) pathname = "/" + pathname;
+	return prefix + pathname || "/";
+}
+function stripPrefixPathname(prefix, pathname) {
+	if (!prefix) return pathname;
+	if (!prefix.startsWith("/")) prefix = "/" + prefix;
+	if (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+	if (prefix === "/") return pathname;
+	if (pathname === prefix) return "/";
+	if (pathname.startsWith(prefix + "/")) return pathname.slice(prefix.length);
+	return null;
+}
+//#endregion
+//#region src/router/lib/route-names.ts
+function sanitizeNamePart(part) {
+	const cleaned = part.replace(/:([a-zA-Z_$][a-zA-Z0-9_$]*)/g, "$$$1").replace(/[^a-zA-Z0-9_$]/g, "");
+	if (cleaned.length === 0) return "index";
+	if (!/^[a-zA-Z_$]/.test(cleaned)) return "_" + cleaned;
+	return cleaned;
+}
+function sanitizeNameParts(parts) {
+	return parts.map(sanitizeNamePart).filter(Boolean);
+}
+function splitNameString(name) {
+	const parts = [];
+	let current = "";
+	let escaping = false;
+	for (const char of name) {
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (char === ".") {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	parts.push(current);
+	return parts.filter((p) => p.length > 0);
+}
+function upperFirst(str) {
+	return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+function lowerFirst(str) {
+	return str.slice(0, 1).toLowerCase() + str.slice(1);
+}
+function segmentToDefaultName(segment) {
+	const paramMatch = segment.match(/^:([a-zA-Z0-9_]+)(?:\\(.+\\))?$/);
+	if (paramMatch) {
+		const key = paramMatch[1];
+		if (key) return "By" + upperFirst(key);
+	}
+	const cleaned = segment.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (cleaned.length === 0) return "Index";
+	return cleaned.map(upperFirst).join("");
+}
+function pattToName(_method, patt) {
+	const parts = patt.pathname.split("/").filter((p) => p.length > 0);
+	if (parts.length === 0) return [];
+	return sanitizeNameParts([lowerFirst(parts.map(segmentToDefaultName).join(""))]);
+}
+//#endregion
+//#region src/router/lib/route-normalize.ts
+function normalizeRouteName(name, method, path) {
+	const methodName = Array.isArray(method) ? method[0] : method;
+	if (!name) return pattToName(methodName ?? "ANY", path);
+	if (typeof name === "string") return sanitizeNameParts(splitNameString(name));
+	return sanitizeNameParts(name);
+}
+function normalizeRoute(route) {
+	if (!route.path) throw new Error("Route is missing a path");
+	const path = typeof route.path === "string" ? new URLPattern({ pathname: route.path }) : route.path;
+	const method = route.method;
+	const accept = route.accept;
+	let normalizedAccept;
+	if (accept) {
+		normalizedAccept = (Array.isArray(accept) ? accept : [accept]).map((entry) => {
+			if (typeof entry === "string") {
+				const parsed = parseMediaType(entry);
+				if (!parsed) throw new Error(`Invalid accept media type: ${entry}`);
+				return parsed;
+			}
+			return normalizeMediaType(entry);
+		});
+		if (normalizedAccept.length === 0) normalizedAccept = void 0;
+	}
+	return {
+		name: normalizeRouteName(route.name, route.method, path),
+		path,
+		handler: route.handler,
+		...route.match === void 0 ? {} : { match: route.match },
+		...route.meta === void 0 ? {} : { meta: route.meta },
+		...route.schema === void 0 ? {} : { schema: route.schema },
+		...method === void 0 ? {} : { method },
+		...normalizedAccept === void 0 ? {} : { accept: normalizedAccept }
+	};
+}
+//#endregion
+//#region src/router/router.ts
+function normalizeMiddlewareList(middleware) {
+	if (!middleware) return [];
+	if (Array.isArray(middleware)) return middleware.filter(Boolean);
+	return [middleware];
+}
+function normalizeRequestMiddlewareList(middleware) {
+	if (!middleware) return [];
+	if (Array.isArray(middleware)) return middleware.filter(Boolean);
+	return [middleware];
+}
+function normalizeRequestBodyParsers(input) {
+	if (!input) return [];
+	if (Array.isArray(input)) return input.filter(Boolean);
+	return [input];
+}
+function normalizeResponseBodySerializers(input) {
+	if (!input) return [];
+	if (Array.isArray(input)) return input.filter(Boolean);
+	return [input];
+}
+function isHandler(input) {
+	return typeof input === "function";
+}
+/**
+* Router that matches requests against registered routes and executes middleware.
+*
+* @example
+* ```ts
+* const router = new Router()
+* router.add({method: HttpMethod.GET, path: '/', handler: async ({request}) => new Response(request.url)})
+* ```
+*/
+var Router = class Router {
+	_entries = [];
+	_middleware = [];
+	_requestMiddleware = [];
+	_responseBodySerializers = [];
+	_responseBodySerializersMode = "inherit";
+	_requestBodyParsers = [];
+	_requestBodyParsersMode = "inherit";
+	_logger;
+	_defaultLogger = new ConsoleLogger();
+	_onNotFoundHandler;
+	_onMethodNotAllowedHandler;
+	_onUnsupportedMediaTypeHandler;
+	_onInternalErrorHandler;
+	/**
+	* Create a new router instance.
+	*/
+	constructor() {}
+	/**
+	* Install an extension that configures this router instance.
+	*
+	* @example
+	* ```ts
+	* router.install(problemRootErrors())
+	* ```
+	*
+	* @param extension - Extension function that mutates or configures this router.
+	* @returns The router instance for chaining.
+	*/
+	install(extension) {
+		extension(this);
+		return this;
+	}
+	/**
+	* Register a handler for requests that do not match any route.
+	*
+	* @example
+	* ```ts
+	* router.onNotFound(() => new Response('missing', {status: 404}))
+	* ```
+	*
+	* @param handler - Handler invoked when no route matches.
+	* @returns The router instance for chaining.
+	*/
+	onNotFound(handler) {
+		this._onNotFoundHandler = handler;
+		return this;
+	}
+	/**
+	* Register a handler for requests that match a path but use an unsupported method.
+	*
+	* @example
+	* ```ts
+	* router.onMethodNotAllowed(() => new Response('nope', {status: 405}))
+	* ```
+	*
+	* @param handler - Handler invoked when a route exists but the method does not match.
+	* @returns The router instance for chaining.
+	*/
+	onMethodNotAllowed(handler) {
+		this._onMethodNotAllowedHandler = handler;
+		return this;
+	}
+	/**
+	* Register a handler for requests with unsupported request body media types.
+	*
+	* @example
+	* ```ts
+	* router.onUnsupportedMediaType(() => new Response('unsupported', {status: 415}))
+	* ```
+	*
+	* @param handler - Handler invoked when the incoming `Content-Type` is not accepted.
+	* @returns The router instance for chaining.
+	*/
+	onUnsupportedMediaType(handler) {
+		this._onUnsupportedMediaTypeHandler = handler;
+		return this;
+	}
+	/**
+	* Register a handler for unhandled errors thrown by route handlers.
+	*
+	* @example
+	* ```ts
+	* router.onInternalError(() => new Response('oops', {status: 500}))
+	* ```
+	*
+	* @param handler - Handler invoked when a route handler throws.
+	* @returns The router instance for chaining.
+	*/
+	onInternalError(handler) {
+		this._onInternalErrorHandler = handler;
+		return this;
+	}
+	/**
+	* Add a request body parser to the inherited parser list.
+	*
+	* @example
+	* ```ts
+	* router.addRequestBodyParser(jsonRequestBodyParser())
+	* ```
+	*
+	* @param parser - Request body parser to append.
+	* @returns The router instance for chaining.
+	*/
+	addRequestBodyParser(parser) {
+		return this.addRequestBodyParsers([parser]);
+	}
+	/**
+	* Add request body parsers to the inherited parser list.
+	*
+	* @example
+	* ```ts
+	* router.addRequestBodyParsers([jsonRequestBodyParser(), textRequestBodyParser()])
+	* ```
+	*
+	* @param parsers - Request body parsers to append.
+	* @returns The router instance for chaining.
+	*/
+	addRequestBodyParsers(parsers) {
+		this._requestBodyParsers.push(...normalizeRequestBodyParsers(parsers));
+		return this;
+	}
+	/**
+	* Replace the inherited request body parser list for this router subtree.
+	*
+	* @example
+	* ```ts
+	* router.setRequestBodyParsers([jsonRequestBodyParser()])
+	* ```
+	*
+	* @param parsers - Exact request body parsers to use for this router subtree.
+	* @returns The router instance for chaining.
+	*/
+	setRequestBodyParsers(parsers) {
+		this._requestBodyParsers = normalizeRequestBodyParsers(parsers);
+		this._requestBodyParsersMode = "replace";
+		return this;
+	}
+	/**
+	* Add a response body serializer to the inherited serializer list.
+	*
+	* @example
+	* ```ts
+	* router.addResponseBodySerializer(jsonResponseBodySerializer())
+	* ```
+	*
+	* @param serializer - Response body serializer to append.
+	* @returns The router instance for chaining.
+	*/
+	addResponseBodySerializer(serializer) {
+		return this.addResponseBodySerializers([serializer]);
+	}
+	/**
+	* Add response body serializers to the inherited serializer list.
+	*
+	* @example
+	* ```ts
+	* router.addResponseBodySerializers([jsonResponseBodySerializer(), yamlSerializer])
+	* ```
+	*
+	* @param serializers - Response body serializers to append.
+	* @returns The router instance for chaining.
+	*/
+	addResponseBodySerializers(serializers) {
+		this._responseBodySerializers.push(...normalizeResponseBodySerializers(serializers));
+		return this;
+	}
+	/**
+	* Replace the inherited response body serializer list for this router subtree.
+	*
+	* @example
+	* ```ts
+	* router.setResponseBodySerializers([jsonResponseBodySerializer()])
+	* ```
+	*
+	* @param serializers - Exact response body serializers to use for this router subtree.
+	* @returns The router instance for chaining.
+	*/
+	setResponseBodySerializers(serializers) {
+		this._responseBodySerializers = normalizeResponseBodySerializers(serializers);
+		this._responseBodySerializersMode = "replace";
+		return this;
+	}
+	/**
+	* Set the logger for this router subtree.
+	*
+	* @example
+	* ```ts
+	* router.setLogger(logger)
+	* ```
+	*
+	* @param logger - Logger exposed through request contexts and used for internal server errors.
+	* @returns The router instance for chaining.
+	*/
+	setLogger(logger) {
+		this._logger = logger;
+		return this;
+	}
+	use(middleware) {
+		const list = normalizeMiddlewareList(middleware);
+		this._middleware.push(...list);
+		return this;
+	}
+	useRequest(middleware) {
+		this._requestMiddleware.push(...normalizeRequestMiddlewareList(middleware));
+		return this;
+	}
+	mount(prefixOrOptionsOrRouter, routerOrConfigure) {
+		const mountOptions = typeof prefixOrOptionsOrRouter === "string" ? { prefix: prefixOrOptionsOrRouter } : prefixOrOptionsOrRouter instanceof Router || typeof prefixOrOptionsOrRouter === "function" ? {} : prefixOrOptionsOrRouter;
+		const target = prefixOrOptionsOrRouter instanceof Router || typeof prefixOrOptionsOrRouter === "function" ? prefixOrOptionsOrRouter : routerOrConfigure;
+		if (target instanceof Router && !mountOptions.middleware) {
+			this._entries.push({
+				kind: "router",
+				prefix: mountOptions.prefix,
+				router: target
+			});
+			return this;
+		}
+		const scope = new Router();
+		if (mountOptions.middleware) scope.use(normalizeMiddlewareList(mountOptions.middleware));
+		if (target instanceof Router) scope.mount(target);
+		else target?.(scope);
+		this._entries.push({
+			kind: "router",
+			prefix: mountOptions.prefix,
+			router: scope
+		});
+		return this;
+	}
+	/**
+	* Add a route definition to this router.
+	*
+	* @example
+	* ```ts
+	* router.add({method: HttpMethod.POST, path: '/items', handler: ({request}) => new Response(request.url)})
+	* ```
+	*
+	* @param route - Route definition to normalize and register.
+	* @returns The router instance for chaining.
+	*/
+	add(route) {
+		this._entries.push({
+			kind: "route",
+			route: normalizeRoute(route),
+			middleware: normalizeMiddlewareList(route.middleware)
+		});
+		return this;
+	}
+	_addMethod(method, path, input) {
+		return this.add({
+			...isHandler(input) ? { handler: input } : input,
+			path,
+			method
+		});
+	}
+	get(path, input) {
+		return this._addMethod(HttpMethod.GET, path, input);
+	}
+	head(path, input) {
+		return this._addMethod(HttpMethod.HEAD, path, input);
+	}
+	post(path, input) {
+		return this._addMethod(HttpMethod.POST, path, input);
+	}
+	put(path, input) {
+		return this._addMethod(HttpMethod.PUT, path, input);
+	}
+	delete(path, input) {
+		return this._addMethod(HttpMethod.DELETE, path, input);
+	}
+	patch(path, input) {
+		return this._addMethod(HttpMethod.PATCH, path, input);
+	}
+	/**
+	* Return a flattened list of registered routes.
+	*
+	* @example
+	* ```ts
+	* const routes = router.getRoutes()
+	* ```
+	*
+	* @returns Array of normalized routes.
+	*/
+	getRoutes() {
+		return this._getRoutes([]);
+	}
+	_getRoutes(parentMiddleware) {
+		const routes = [];
+		const middleware = [...parentMiddleware, ...this._middleware];
+		for (const entry of this._entries) {
+			if (entry.kind === "route") {
+				const schema = mergeRouteSchemas(...[...middleware, ...entry.middleware].flatMap((value) => isDeclaredMiddleware(value) && (!value.schemaAppliesTo || value.schemaAppliesTo(entry.route)) ? [value.schema] : []), entry.route.schema);
+				routes.push({
+					...entry.route,
+					...schema === void 0 ? {} : { schema }
+				});
+				continue;
+			}
+			for (const subRoute of entry.router._getRoutes(middleware)) {
+				if (!entry.prefix) {
+					routes.push(subRoute);
+					continue;
+				}
+				const path = new URLPattern({ pathname: joinPrefixPathname(entry.prefix, subRoute.path.pathname) });
+				routes.push({
+					...subRoute,
+					path
+				});
+			}
+		}
+		return routes;
+	}
+	_defaultRuntimeConfig() {
+		return {
+			requestBodyParsers: defaultRequestBodyParsers(),
+			responseBodySerializers: defaultResponseBodySerializers(),
+			logger: this._defaultLogger,
+			requestMiddleware: []
+		};
+	}
+	_handlerRegistration(handler) {
+		return handler ? {
+			handler,
+			router: this
+		} : void 0;
+	}
+	_resolveRuntimeConfig(parent) {
+		return {
+			requestBodyParsers: this._requestBodyParsersMode === "replace" ? [...this._requestBodyParsers] : [...parent.requestBodyParsers, ...this._requestBodyParsers],
+			responseBodySerializers: this._responseBodySerializersMode === "replace" ? [...this._responseBodySerializers] : [...parent.responseBodySerializers, ...this._responseBodySerializers],
+			logger: this._logger ?? parent.logger,
+			requestMiddleware: [...parent.requestMiddleware, ...this._requestMiddleware],
+			onNotFoundHandler: this._handlerRegistration(this._onNotFoundHandler) ?? parent.onNotFoundHandler,
+			onMethodNotAllowedHandler: this._handlerRegistration(this._onMethodNotAllowedHandler) ?? parent.onMethodNotAllowedHandler,
+			onUnsupportedMediaTypeHandler: this._handlerRegistration(this._onUnsupportedMediaTypeHandler) ?? parent.onUnsupportedMediaTypeHandler,
+			onInternalErrorHandler: this._handlerRegistration(this._onInternalErrorHandler) ?? parent.onInternalErrorHandler
+		};
+	}
+	_match(request, method, url, parentConfig) {
+		if (method === HttpMethod.HEAD) {
+			const headOnly = this._matchWithMethodCheck(request, url, (routeMethod) => this._methodMatches(routeMethod, HttpMethod.HEAD), parentConfig, []);
+			if (headOnly.match) return headOnly.match;
+			const getOnly = this._matchWithMethodCheck(request, url, (routeMethod) => this._methodMatches(routeMethod, HttpMethod.GET), parentConfig, []);
+			if (getOnly.match) return getOnly.match;
+			if (headOnly.unsupportedMediaType) return {
+				kind: "unsupported_media_type",
+				found: headOnly.unsupportedMediaType
+			};
+			if (getOnly.unsupportedMediaType) return {
+				kind: "unsupported_media_type",
+				found: getOnly.unsupportedMediaType
+			};
+			const methodNotAllowedConfig = headOnly.methodNotAllowedConfig ?? getOnly.methodNotAllowedConfig;
+			if (methodNotAllowedConfig) return {
+				kind: "method_not_allowed",
+				config: methodNotAllowedConfig
+			};
+			return {
+				kind: "not_found",
+				config: headOnly.notFoundConfig
+			};
+		}
+		const match = this._matchWithMethodCheck(request, url, (routeMethod) => this._methodMatches(routeMethod, method), parentConfig, []);
+		if (match.match) return match.match;
+		if (match.unsupportedMediaType) return {
+			kind: "unsupported_media_type",
+			found: match.unsupportedMediaType
+		};
+		if (match.methodNotAllowedConfig) return {
+			kind: "method_not_allowed",
+			config: match.methodNotAllowedConfig
+		};
+		return {
+			kind: "not_found",
+			config: match.notFoundConfig
+		};
+	}
+	_collectAllowedMethods(url) {
+		const methods = /* @__PURE__ */ new Set();
+		function addMethods(routeMethod) {
+			if (!routeMethod) return;
+			const normalized = Array.isArray(routeMethod) ? routeMethod : [routeMethod];
+			for (const method of normalized) methods.add(method);
+		}
+		function visit(entries, currentUrl) {
+			for (const entry of entries) {
+				if (entry.kind === "route") {
+					if (entry.route.match) continue;
+					if (!entry.route.path.exec(currentUrl)) continue;
+					addMethods(entry.route.method);
+					continue;
+				}
+				if (entry.prefix) {
+					const subPathname = stripPrefixPathname(entry.prefix, currentUrl.pathname);
+					if (subPathname == null) continue;
+					const subUrl = new URL(currentUrl.toString());
+					subUrl.pathname = subPathname;
+					visit(entry.router._entries, subUrl);
+				} else visit(entry.router._entries, currentUrl);
+			}
+		}
+		visit(this._entries, url);
+		return methods;
+	}
+	_acceptMatches(route, request) {
+		if (!route.accept || route.accept.length === 0) return true;
+		const contentTypeHeader = request.headers.get(CommonHeaders.CONTENT_TYPE);
+		if (!contentTypeHeader) return false;
+		const contentType = parseContentType(contentTypeHeader);
+		if (!contentType) return false;
+		return route.accept.some((accept) => mediaTypeMatches(accept, contentType));
+	}
+	_formatAllowMethods(methods) {
+		const order = [
+			HttpMethod.GET,
+			HttpMethod.HEAD,
+			HttpMethod.POST,
+			HttpMethod.PUT,
+			HttpMethod.PATCH,
+			HttpMethod.DELETE,
+			HttpMethod.OPTIONS
+		];
+		const ordered = [];
+		for (const method of order) if (methods.has(method)) ordered.push(method);
+		const remaining = [...methods].filter((method) => !order.includes(method)).sort();
+		return [...ordered, ...remaining].join(", ");
+	}
+	_buildHandlerContext(request, url, path, config, routePath) {
+		return {
+			request,
+			url,
+			path,
+			logger: config.logger.withContext({
+				"http.request.method": request.method,
+				"url.path": url.pathname,
+				...routePath == null ? {} : { "http.route": routePath }
+			})
+		};
+	}
+	_runRequestMiddleware(middleware, ctx, respond) {
+		let index = -1;
+		const dispatch = async (nextIndex) => {
+			if (nextIndex <= index) throw new Error("next() called multiple times");
+			index = nextIndex;
+			const current = middleware[nextIndex];
+			if (current == null) return nextIndex >= middleware.length ? await respond() : await dispatch(nextIndex + 1);
+			return await current(ctx, () => dispatch(nextIndex + 1));
+		};
+		return dispatch(0);
+	}
+	async _executeHandler(handler, middleware, ctx, router, request, config) {
+		const result = await this._run(handler, middleware, ctx, router);
+		if (result instanceof Response) return result;
+		if (this._isAsyncGenerator(result)) {
+			const response = await this._responseFromGenerator(result, request, config);
+			if (response) return response;
+			return new Response(null, { status: HttpStatus.CLIENT_CLOSED_REQUEST });
+		}
+		return await this._finalizeResult(result, request, config);
+	}
+	_statusResponse(status, request) {
+		const result = text(StatusText[status] ?? `HTTP Status ${status}`, { status });
+		return new Response(request?.method.toUpperCase() === HttpMethod.HEAD ? null : result.body, {
+			status,
+			headers: result.headers
+		});
+	}
+	_logInternalServerError(error, logger) {
+		try {
+			logger.error("Routekit internal server error", error);
+		} catch {}
+	}
+	async _finalizeResult(result, request, config) {
+		if (result instanceof Response) return result;
+		if (this._isAsyncGenerator(result)) {
+			const response = await this._responseFromGenerator(result, request, config);
+			if (response) return response;
+			return new Response(null, { status: HttpStatus.CLIENT_CLOSED_REQUEST });
+		}
+		if (isRoutekitResponse(result)) return await this._responseFromRoutekitResponse(result, request, config);
+		if (isRoutekitBody(result)) return await this._responseFromRoutekitResponse(response(result.value), request, config);
+		if (isResponseBodyInit(result)) {
+			const body = this._toResponseBody(result);
+			const headers = new Headers();
+			this._setContentLength(headers, body);
+			return new Response(body, {
+				status: HttpStatus.OK,
+				headers
+			});
+		}
+		return await this._responseFromRoutekitResponse(response(result), request, config);
+	}
+	async _responseFromRoutekitResponse(result, request, config) {
+		const isHead = request.method.toUpperCase() === HttpMethod.HEAD;
+		const headers = new Headers(result.headers);
+		const status = result.status;
+		if (headers.has(CommonHeaders.CONTENT_TYPE)) {
+			if (!isResponseBodyInit(result.body)) throw new TypeError("Routekit response has Content-Type set, so body must be a native Response body.");
+			const body = this._toResponseBody(result.body);
+			this._setContentLength(headers, body);
+			return new Response(isHead ? null : body, {
+				status,
+				headers
+			});
+		}
+		if (result.body === void 0) return new Response(null, {
+			status,
+			headers
+		});
+		const serializer = this._selectSerializer(result.body, request, config);
+		if (!serializer) return this._statusResponse(HttpStatus.NOT_ACCEPTABLE, request);
+		headers.set(CommonHeaders.CONTENT_TYPE, serializer.mediaType);
+		this._appendVary(headers, CommonHeaders.ACCEPT);
+		const body = await serializer.serializer.serialize(result.body);
+		this._setContentLength(headers, body);
+		return new Response(isHead ? null : body, {
+			status,
+			headers
+		});
+	}
+	_appendVary(headers, value) {
+		const current = headers.get(CommonHeaders.VARY);
+		if (!current) {
+			headers.set(CommonHeaders.VARY, value);
+			return;
+		}
+		if (current.split(",").map((entry) => entry.trim().toLowerCase()).includes(value.toLowerCase())) return;
+		headers.set(CommonHeaders.VARY, `${current}, ${value}`);
+	}
+	_selectSerializer(body, request, config) {
+		const accepted = parseAcceptHeader(request.headers.get(CommonHeaders.ACCEPT) ?? "*/*");
+		const ranges = accepted.length ? accepted : parseAcceptHeader("*/*");
+		let best = null;
+		for (const [acceptIndex, accept] of ranges.entries()) {
+			if (accept.q === 0) continue;
+			for (const [serializerIndex, serializer] of config.responseBodySerializers.entries()) {
+				if (serializer.canSerialize && !serializer.canSerialize(body)) continue;
+				for (const [mediaTypeIndex, mediaTypeRange] of serializer.mediaTypes.entries()) {
+					const mediaTypeQuality = mediaRangeQuality(mediaTypeRange);
+					if (mediaTypeQuality === 0) continue;
+					if (mediaRangeAccepts(accept, mediaTypeRange)) {
+						const mediaType = mediaRangeToContentType(mediaTypeRange);
+						if (!mediaType) continue;
+						const candidate = {
+							serializer,
+							mediaType,
+							acceptQuality: accept.q,
+							mediaTypeQuality,
+							acceptIndex,
+							serializerIndex,
+							mediaTypeIndex
+						};
+						if (this._isBetterSerializerCandidate(candidate, best)) best = candidate;
+					}
+				}
+			}
+		}
+		return best ? {
+			serializer: best.serializer,
+			mediaType: best.mediaType
+		} : null;
+	}
+	_isBetterSerializerCandidate(candidate, best) {
+		if (!best) return true;
+		if (candidate.acceptQuality !== best.acceptQuality) return candidate.acceptQuality > best.acceptQuality;
+		if (candidate.mediaTypeQuality !== best.mediaTypeQuality) return candidate.mediaTypeQuality > best.mediaTypeQuality;
+		if (candidate.acceptIndex !== best.acceptIndex) return candidate.acceptIndex < best.acceptIndex;
+		if (candidate.serializerIndex !== best.serializerIndex) return candidate.serializerIndex < best.serializerIndex;
+		return candidate.mediaTypeIndex < best.mediaTypeIndex;
+	}
+	async _tryCustomHandler(registration, ctx, config, request) {
+		if (!registration) return null;
+		try {
+			return await this._executeHandler(registration.handler, [], ctx, registration.router, request, config);
+		} catch (error) {
+			if (error instanceof RequestBodyError) return responseFromRequestBodyError(error);
+			this._logInternalServerError(error, ctx.logger);
+			return this._statusResponse(HttpStatus.INTERNAL_SERVER_ERROR, request);
+		}
+	}
+	_requestWithBodyParsers(request, config) {
+		return createRoutekitRequest(request.raw, request.url, config.requestBodyParsers);
+	}
+	async _handleNotFound(request, url, config) {
+		request = this._requestWithBodyParsers(request, config);
+		const ctx = this._buildHandlerContext(request, url, {}, config);
+		return await this._runRequestMiddleware(config.requestMiddleware, ctx, async () => {
+			const custom = await this._tryCustomHandler(config.onNotFoundHandler, ctx, config, request);
+			if (custom) return custom;
+			return this._statusResponse(HttpStatus.NOT_FOUND, request);
+		});
+	}
+	async _handleMethodNotAllowed(request, url, config) {
+		request = this._requestWithBodyParsers(request, config);
+		const ctx = this._buildHandlerContext(request, url, {}, config);
+		return await this._runRequestMiddleware(config.requestMiddleware, ctx, async () => {
+			const custom = await this._tryCustomHandler(config.onMethodNotAllowedHandler, ctx, config, request);
+			if (custom) return custom;
+			return this._statusResponse(HttpStatus.METHOD_NOT_ALLOWED, request);
+		});
+	}
+	async _handleInternalError(config, ctx, request, error) {
+		if (error instanceof RequestBodyError) return responseFromRequestBodyError(error);
+		this._logInternalServerError(error, ctx.logger);
+		const custom = await this._tryCustomHandler(config.onInternalErrorHandler, ctx, config, request);
+		if (custom) return custom;
+		return this._statusResponse(HttpStatus.INTERNAL_SERVER_ERROR, request);
+	}
+	async _handleUnsupportedMediaType(found, request, url) {
+		request = this._requestWithBodyParsers(request, found.config);
+		const rawPathParams = found.match?.pathname.groups ?? {};
+		const path = Object.fromEntries(Object.entries(rawPathParams).filter(([, value]) => value !== void 0));
+		const handlerCtx = this._buildHandlerContext(request, url, path, found.config, found.routePath);
+		return await this._runRequestMiddleware(found.config.requestMiddleware, handlerCtx, async () => {
+			const custom = await this._tryCustomHandler(found.config.onUnsupportedMediaTypeHandler, handlerCtx, found.config, request);
+			if (custom) return custom;
+			return this._statusResponse(HttpStatus.UNSUPPORTED_MEDIA_TYPE, request);
+		});
+	}
+	async _handleMatch(found, request, url) {
+		request = this._requestWithBodyParsers(request, found.config);
+		const rawPathParams = found.match?.pathname.groups ?? {};
+		const path = Object.fromEntries(Object.entries(rawPathParams).filter(([, value]) => value !== void 0));
+		const handlerCtx = this._buildHandlerContext(request, url, path, found.config, found.routePath);
+		return await this._runRequestMiddleware(found.config.requestMiddleware, handlerCtx, async () => {
+			try {
+				mergeRouteSchemas(...found.middleware.flatMap((value) => isDeclaredMiddleware(value) && (!value.schemaAppliesTo || value.schemaAppliesTo(found.route)) ? [value.schema] : []), found.route.schema);
+				return await this._executeHandler(found.route.handler, found.middleware, handlerCtx, found.router, request, found.config);
+			} catch (error) {
+				return await this._handleInternalError(found.config, handlerCtx, request, error);
+			}
+		});
+	}
+	_methodMatches(routeMethod, method) {
+		if (!routeMethod) return true;
+		return (Array.isArray(routeMethod) ? routeMethod : [routeMethod]).some((routeValue) => routeValue === method);
+	}
+	_withRoutePrefix(match, prefix) {
+		return prefix == null ? match : {
+			...match,
+			routePath: joinPrefixPathname(prefix, match.routePath)
+		};
+	}
+	_matchWithMethodCheck(request, url, methodCheck, parentConfig, parentMiddleware) {
+		const config = this._resolveRuntimeConfig(parentConfig);
+		const middleware = [...parentMiddleware, ...this._middleware];
+		let methodNotAllowedConfig = null;
+		let unsupportedMediaType = null;
+		let notFoundConfig = config;
+		for (const entry of this._entries) {
+			if (entry.kind === "route") {
+				const route = entry.route;
+				const routeMiddleware = [...middleware, ...entry.middleware];
+				const pathMatch = route.path.exec(url);
+				if (route.match) {
+					if (!route.match(request)) continue;
+					return {
+						match: {
+							kind: "match",
+							route,
+							routePath: route.path.pathname,
+							match: pathMatch,
+							middleware: routeMiddleware,
+							router: this,
+							config
+						},
+						unsupportedMediaType,
+						methodNotAllowedConfig,
+						notFoundConfig
+					};
+				}
+				if (!pathMatch) continue;
+				if (!methodCheck(route.method)) {
+					methodNotAllowedConfig ??= config;
+					continue;
+				}
+				if (!this._acceptMatches(route, request)) {
+					unsupportedMediaType ??= {
+						kind: "match",
+						route,
+						routePath: route.path.pathname,
+						match: pathMatch,
+						middleware: routeMiddleware,
+						router: this,
+						config
+					};
+					continue;
+				}
+				return {
+					match: {
+						kind: "match",
+						route,
+						routePath: route.path.pathname,
+						match: pathMatch,
+						middleware: routeMiddleware,
+						router: this,
+						config
+					},
+					unsupportedMediaType,
+					methodNotAllowedConfig,
+					notFoundConfig
+				};
+			}
+			if (entry.prefix) {
+				const subPathname = stripPrefixPathname(entry.prefix, url.pathname);
+				if (subPathname == null) continue;
+				const subUrl = new URL(url.toString());
+				subUrl.pathname = subPathname;
+				const subMatch = entry.router._matchWithMethodCheck(request, subUrl, methodCheck, config, middleware);
+				if (subMatch.match) return {
+					match: this._withRoutePrefix(subMatch.match, entry.prefix),
+					unsupportedMediaType,
+					methodNotAllowedConfig,
+					notFoundConfig
+				};
+				if (subMatch.unsupportedMediaType && !unsupportedMediaType) unsupportedMediaType = this._withRoutePrefix(subMatch.unsupportedMediaType, entry.prefix);
+				methodNotAllowedConfig ??= subMatch.methodNotAllowedConfig;
+				notFoundConfig = subMatch.notFoundConfig;
+			} else {
+				const subMatch = entry.router._matchWithMethodCheck(request, url, methodCheck, config, middleware);
+				if (subMatch.match) return {
+					match: subMatch.match,
+					unsupportedMediaType,
+					methodNotAllowedConfig,
+					notFoundConfig
+				};
+				if (subMatch.unsupportedMediaType && !unsupportedMediaType) unsupportedMediaType = subMatch.unsupportedMediaType;
+				methodNotAllowedConfig ??= subMatch.methodNotAllowedConfig;
+				notFoundConfig = subMatch.notFoundConfig;
+			}
+		}
+		return {
+			match: null,
+			unsupportedMediaType,
+			methodNotAllowedConfig,
+			notFoundConfig
+		};
+	}
+	_run(handler, middleware, ctx, router) {
+		let idx = -1;
+		const dispatch = async (i) => {
+			if (i <= idx) throw new Error("next() called multiple times");
+			idx = i;
+			if (i === middleware.length) return await Promise.resolve().then(() => handler.call(router, ctx));
+			const mw = middleware[i];
+			if (!mw) return await dispatch(i + 1);
+			if (isDeclaredMiddleware(mw)) return await mw(ctx, () => dispatch(i + 1));
+			await mw(ctx);
+			return await dispatch(i + 1);
+		};
+		return dispatch(0);
+	}
+	_isAsyncGenerator(value) {
+		return !!value && typeof value[Symbol.asyncIterator] === "function";
+	}
+	async _closeGenerator(generator) {
+		try {
+			await generator.return?.(void 0);
+		} catch {}
+	}
+	_toResponseBody(body) {
+		if (body == null) return null;
+		return body;
+	}
+	_setContentLength(headers, body) {
+		if (headers.has(CommonHeaders.CONTENT_LENGTH) || body == null) return;
+		const size = this._getBodyByteLength(body);
+		if (size != null) headers.set(CommonHeaders.CONTENT_LENGTH, String(size));
+	}
+	_getBodyByteLength(body) {
+		if (typeof body === "string") return new TextEncoder().encode(body).byteLength;
+		if (body instanceof Blob) return body.size;
+		if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString()).byteLength;
+		if (body instanceof ArrayBuffer) return body.byteLength;
+		if (ArrayBuffer.isView(body)) return body.byteLength;
+	}
+	_isBodyChunk(value) {
+		return typeof value === "string" || value instanceof Uint8Array;
+	}
+	_toBodyChunk(value) {
+		if (typeof value === "string") return new TextEncoder().encode(value);
+		return value;
+	}
+	_mergeHeaders(target, source) {
+		source.forEach((value, key) => target.set(key, value));
+	}
+	async _frameChunk(value, framer) {
+		if (!framer) {
+			if (!this._isBodyChunk(value)) throw new TypeError("Generator yielded a structured chunk without stream(). Use stream(sseFramer()) or yield raw string/bytes chunks.");
+			return this._toBodyChunk(value);
+		}
+		if (framer.canFrame && !framer.canFrame(value)) throw new TypeError("Stream framer cannot encode the yielded chunk.");
+		return this._toBodyChunk(await framer.frame(value));
+	}
+	async _responseFromGenerator(generator, request, config) {
+		const isHead = request.method.toUpperCase() === HttpMethod.HEAD;
+		let status;
+		let statusSet = false;
+		const headers = new Headers();
+		let framer;
+		let bodyStream;
+		let bodyController;
+		let responseResolved = false;
+		let resolveResponse;
+		let rejectResponse;
+		const responsePromise = new Promise((resolve, reject) => {
+			resolveResponse = resolve;
+			rejectResponse = reject;
+		});
+		let abortListener;
+		const abortSignal = request.signal;
+		const abortPromise = abortSignal ? new Promise((resolve) => {
+			if (abortSignal.aborted) {
+				resolve("aborted");
+				return;
+			}
+			abortListener = () => resolve("aborted");
+			abortSignal.addEventListener("abort", abortListener, { once: true });
+		}) : null;
+		if (abortSignal?.aborted) {
+			await this._closeGenerator(generator);
+			return null;
+		}
+		const resolveResponseOnce = (response) => {
+			if (responseResolved) return;
+			responseResolved = true;
+			resolveResponse?.(response);
+		};
+		const rejectResponseOnce = (error) => {
+			if (responseResolved) {
+				bodyController?.error?.(error);
+				return;
+			}
+			responseResolved = true;
+			rejectResponse?.(error);
+		};
+		const buildResponseInit = () => ({
+			status: status ?? HttpStatus.OK,
+			headers
+		});
+		const ensureStreamResponse = () => {
+			if (responseResolved) return;
+			if (!bodyStream) bodyStream = new ReadableStream({ start(controller) {
+				bodyController = controller;
+			} });
+			resolveResponseOnce(new Response(bodyStream, buildResponseInit()));
+		};
+		const setStatus = (value) => {
+			if (bodyStream) throw new TypeError("Generator cannot set status after streaming has started.");
+			if (statusSet) throw new TypeError("Generator response status was already set.");
+			status = value;
+			statusSet = true;
+		};
+		const mergeHeaders = (value) => {
+			if (bodyStream) throw new TypeError("Generator cannot set headers after streaming has started.");
+			this._mergeHeaders(headers, value);
+		};
+		const finalizeReturnedValue = async (value) => {
+			if (isRoutekitResponse(value)) {
+				if (statusSet) throw new TypeError("Generator returned a Routekit response after status was already set.");
+				const mergedHeaders = new Headers(headers);
+				this._mergeHeaders(mergedHeaders, value.headers);
+				return await this._responseFromRoutekitResponse(response(value.body, {
+					status: value.status,
+					headers: mergedHeaders
+				}), request, config);
+			}
+			if (value instanceof Response) {
+				if (statusSet || [...headers.keys()].length > 0) throw new TypeError("Generator returned a native Response after response metadata was already set.");
+				return value;
+			}
+			const returnedBody = isRoutekitBody(value) ? value.value : value;
+			return await this._responseFromRoutekitResponse(response(returnedBody, {
+				status: status ?? HttpStatus.OK,
+				headers
+			}), request, config);
+		};
+		try {
+			const pump = async () => {
+				try {
+					while (true) {
+						const next = abortPromise ? await Promise.race([generator.next(), abortPromise]) : await generator.next();
+						if (next === "aborted") {
+							await this._closeGenerator(generator);
+							bodyController?.error?.(/* @__PURE__ */ new Error("Request aborted"));
+							resolveResponseOnce(null);
+							return;
+						}
+						if (next.done) {
+							if (bodyStream) {
+								if (next.value !== void 0) throw new TypeError("Generator cannot return a final body after yielding chunks.");
+								if (framer?.close && !isHead) {
+									const finalChunk = await framer.close();
+									if (finalChunk !== void 0) bodyController?.enqueue(this._toBodyChunk(finalChunk));
+								}
+								bodyController?.close();
+								if (!responseResolved) resolveResponseOnce(new Response(bodyStream, buildResponseInit()));
+								return;
+							}
+							resolveResponseOnce(await finalizeReturnedValue(next.value));
+							return;
+						}
+						const yielded = next.value;
+						if (yielded === void 0) continue;
+						if (isStatusDirective(yielded)) {
+							setStatus(yielded.status);
+							continue;
+						}
+						if (isHeadersDirective(yielded)) {
+							mergeHeaders(yielded.headers);
+							if (isHead) {
+								await this._closeGenerator(generator);
+								resolveResponseOnce(new Response(null, buildResponseInit()));
+								return;
+							}
+							continue;
+						}
+						if (isHeadDirective(yielded)) {
+							setStatus(yielded.status);
+							mergeHeaders(yielded.headers);
+							if (isHead) {
+								await this._closeGenerator(generator);
+								resolveResponseOnce(new Response(null, buildResponseInit()));
+								return;
+							}
+							continue;
+						}
+						if (isStreamDirective(yielded)) {
+							if (bodyStream) throw new TypeError("Generator cannot select a stream framer after streaming has started.");
+							framer = yielded.framer;
+							mergeHeaders(yielded.headers);
+							headers.set(CommonHeaders.CONTENT_TYPE, framer.contentType);
+							if (isHead) {
+								await this._closeGenerator(generator);
+								resolveResponseOnce(new Response(null, buildResponseInit()));
+								return;
+							}
+							continue;
+						}
+						if (isChunkDirective(yielded)) {
+							if (isHead) {
+								await this._closeGenerator(generator);
+								resolveResponseOnce(new Response(null, buildResponseInit()));
+								return;
+							}
+							ensureStreamResponse();
+							bodyController?.enqueue(await this._frameChunk(yielded.value, framer));
+							continue;
+						}
+						throw new TypeError("Generator yielded an unsupported value. Use status(), headers(), head(), stream(), or chunk().");
+					}
+				} catch (err) {
+					rejectResponseOnce(err);
+				}
+			};
+			pump();
+			return await responsePromise;
+		} finally {
+			if (abortSignal && abortListener) abortSignal.removeEventListener("abort", abortListener);
+		}
+	}
+	async _handleRequest(request) {
+		const url = new URL(request.url);
+		const method = request.method.toUpperCase();
+		const routekitRequest = createRoutekitRequest(request, url, this._resolveRuntimeConfig(this._defaultRuntimeConfig()).requestBodyParsers);
+		if (method === HttpMethod.OPTIONS) {
+			const explicit = this._match(routekitRequest, method, url, this._defaultRuntimeConfig());
+			if (explicit.kind === "match") return await this._handleMatch(explicit, routekitRequest, url);
+			if (explicit.kind === "unsupported_media_type") return await this._handleUnsupportedMediaType(explicit.found, routekitRequest, url);
+			const allowedMethods = this._collectAllowedMethods(url);
+			if (allowedMethods.size === 0) return await this._handleNotFound(routekitRequest, url, explicit.config);
+			if (allowedMethods.has(HttpMethod.GET)) allowedMethods.add(HttpMethod.HEAD);
+			allowedMethods.add(HttpMethod.OPTIONS);
+			const optionsRequest = this._requestWithBodyParsers(routekitRequest, explicit.config);
+			const ctx = this._buildHandlerContext(optionsRequest, url, {}, explicit.config);
+			return await this._runRequestMiddleware(explicit.config.requestMiddleware, ctx, async () => new Response(null, {
+				status: HttpStatus.NO_CONTENT,
+				headers: { "access-control-allow-methods": this._formatAllowMethods(allowedMethods) }
+			}));
+		}
+		const found = this._match(routekitRequest, method, url, this._defaultRuntimeConfig());
+		if (found.kind === "not_found") return await this._handleNotFound(routekitRequest, url, found.config);
+		if (found.kind === "method_not_allowed") return await this._handleMethodNotAllowed(routekitRequest, url, found.config);
+		if (found.kind === "unsupported_media_type") return await this._handleUnsupportedMediaType(found.found, routekitRequest, url);
+		return await this._handleMatch(found, routekitRequest, url);
+	}
+	/**
+	* Handle an incoming request by matching routes and executing middleware.
+	*
+	* @example
+	* ```ts
+	* const response = await router.fetch(new Request('https://example.com/'))
+	* ```
+	*
+	* @param request - Incoming request to route.
+	* @returns The response produced by the matched handler.
+	*/
+	fetch = (request) => {
+		return this._handleRequest(request);
+	};
+};
+//#endregion
+export { RequestBodyError, RequestBodyLengthMismatchError, RequestBodyTooLargeError, Router, UnsupportedRequestBodyMediaTypeError, body, chunk, createAsyncStream, createRoutekitRequest, createStartStream, defaultRequestBodyParsers, defaultResponseBodySerializers, defineMiddleware, formDataRequestBodyParser, head, headers, isChunkDirective, isHeadDirective, isHeadersDirective, isResponseBodyInit, isRoutekitBody, isRoutekitDirective, isRoutekitResponse, isStatusDirective, isStreamDirective, jsonLinesFramer, jsonRequestBodyParser, jsonResponseBodySerializer, response, responseFromRequestBodyError, sseFramer, status, stream, textRequestBodyParser, urlEncodedRequestBodyParser };