@znight/http 0.1.3 → 0.2.0

package/dist/index.d.mts

@@ -654,14 +654,31 @@ interface RouteMetaEntry<T = unknown> {
   /** Default `false`. */
   readonly required?: boolean;
 }
+/**
+ * Anything that carries effective route metadata: the {@link HttpContext} of a request, and the
+ * contexts of other transports that reuse route decorators (a GraphQL resolver context, a WebSocket
+ * gateway context). {@link RouteDecorator.get} reads `route.meta[key]`; nothing else is required.
+ *
+ * ```ts
+ * const carrier: RouteMetaCarrier = { route: { meta: { roles: ['admin'] } } }
+ * Roles.get(carrier) // ['admin']
+ * ```
+ */
+interface RouteMetaCarrier {
+  /** The matched route (or field, or handler), `undefined` when there is none. */
+  readonly route?: {
+    readonly meta: Readonly<Record<string, unknown>>;
+  } | undefined;
+}
 /** A user-defined route metadata decorator created with {@link createRouteDecorator}. */
 interface RouteDecorator<T> extends RouteDecoratorInfo {
   (...args: RouteDecoratorArgs<T>): ClassMarker & MethodMarker;
   /**
    * The value of the current route, if set. Reads the effective metadata: the route's decision of
-   * a group wins over the controller's.
+   * a group wins over the controller's. Accepts any {@link RouteMetaCarrier}: an
+   * {@link HttpContext}, or the context of another transport exposing `route.meta`.
    */
-  get(ctx: HttpContext): T | undefined;
+  get(ctx: RouteMetaCarrier): T | undefined;
   /**
    * The same metadata as data (`{ key, value, group, required }`), for routes that are not compiled
    * controllers (plugin routes: `OpenApiPlugin.configure({ meta: [Public.meta()] })`). The value is
@@ -1113,6 +1130,13 @@ interface PluginRoute {
   readonly meta?: readonly RouteMetaEntry[];
   /** Guards of the route (provider classes or instances), run after the global guards. */
   readonly guards?: readonly GuardRef[];
+  /**
+   * Maximum body size of this route (`'100kb'`, `1048576`, `Infinity`), with the grammar of the
+   * `HttpPlugin` option `bodyLimit`, which it replaces for this route only (lower or higher, like
+   * `@BodyLimit` on a controller route). Past it, reading the body answers 413. Default: the
+   * `HttpPlugin` option.
+   */
+  readonly bodyLimit?: ByteSize;
 }
 /** What {@link PluginHttpRoutes.httpRoutes} receives. */
 interface PluginHttpRoutesContext {
@@ -1258,5 +1282,5 @@ export declare function isThenable<T>(value: T): value is unknown extends T ? T
  * @throws TypeError when `schema` is not a Standard Schema v1 (a programming error → 500).
  */
 export declare function validate<S extends StandardSchemaV1>(schema: S, value: unknown, location: string): InferSchemaOutput<S> | Promise<InferSchemaOutput<S>>;
-export { type AdapterCloseOptions, type AdapterHandler, type AdapterReply, type AdapterRequest, type AdapterRoute, BadGatewayException, BadRequestException, type ByteRange, type ByteSize, type CallHandler, type CanActivate, type ClearCookieOptions, type Coercer, type Coercers, ConflictException, type ContentDispositionType, type ControllerOptions, type CookieDefaults, type CookieOptions, type CorsOptions, type CorsOrigin, type EnforcementMode, type EventChannelOptions, type ExceptionMapper, type ExceptionMapperClass, type ExceptionMapperRef, type ExceptionMapperResult, type FallbackHandler, type FileBody, type FileResponseOptions, ForbiddenException, GatewayTimeoutException, GoneException, type GuardClass, type GuardEnforcement, type GuardRef, type HeaderValue, type HstsOptions, type HttpAdapter, type HttpContext, type HttpControllerDefinition, type HttpCookieOptions, type HttpErrorBody, HttpException, type HttpExceptionOptions, type HttpInterceptor, type HttpInterceptorClass, type HttpMetadata, type HttpMethod, type HttpParamDefinition, type HttpParamSource, type HttpPluginOptions, type HttpResponseInit, type HttpRouteDefinition, type HttpRouteGroupDefinition, type HttpRouteInfo, type HttpRouteSummary, type HttpServerAddress, type HttpSseDefinition, type HttpSseOptions, type HttpUploadDefinition, type InferSchemaInput, type InferSchemaOutput, type InjectRequest, type InjectResponse, type InjectSseResponse, type InjectSseWaitOptions, type InjectStreamOptions, type InjectStreamRequest, type InjectStreamResponse, type InterceptorRef, InternalServerErrorException, type MediaType, MethodNotAllowedException, type NodeAdapter, type NodeAdapterOptions, NotFoundException, NotImplementedException, type ParseSseOptions, PayloadTooLargeException, type PluginHttpRoutes, type PluginHttpRoutesContext, type PluginRoute, type QueryRecord, type RedirectStatus, type ReplyBody, type RequestAbortKind, RequestAbortedError, type RequestId, type ResponseCookie, type RouteDecorator, type RouteDecoratorArgs, type RouteDecoratorInfo, type RouteDecoratorOptions, type RouteMetaEntry, type SecurityHeadersOptions, ServiceUnavailableException, type SetCookieInfo, type SseBody, type SseEvent, type SseItem, type SseMessage, type SseOptions, type SseSource, type StandardSchemaV1, type StandardSchemaV1FailureResult, type StandardSchemaV1Issue, type StandardSchemaV1Options, type StandardSchemaV1PathSegment, type StandardSchemaV1Props, type StandardSchemaV1Result, type StandardSchemaV1SuccessResult, type StandardSchemaV1Types, type StreamResponseOptions, type StreamSource, TooManyRequestsException, type TrailingSlashPolicy, type TrustProxy, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, type UploadLimits, type UploadedFileOptions, type UploadedFilesOptions, type Uploads, ValidationException, type ValidationIssueDetail, formatByteSize, isHttpException, isStandardSchema, nodeAdapter, parseByteSize, parseCookieHeader, parseQuery, parseSetCookie, serializeClearCookie, serializeCookie, toIssueDetail, uploads };
+export { type AdapterCloseOptions, type AdapterHandler, type AdapterReply, type AdapterRequest, type AdapterRoute, BadGatewayException, BadRequestException, type ByteRange, type ByteSize, type CallHandler, type CanActivate, type ClearCookieOptions, type Coercer, type Coercers, ConflictException, type ContentDispositionType, type ControllerOptions, type CookieDefaults, type CookieOptions, type CorsOptions, type CorsOrigin, type EnforcementMode, type EventChannelOptions, type ExceptionMapper, type ExceptionMapperClass, type ExceptionMapperRef, type ExceptionMapperResult, type FallbackHandler, type FileBody, type FileResponseOptions, ForbiddenException, GatewayTimeoutException, GoneException, type GuardClass, type GuardEnforcement, type GuardRef, type HeaderValue, type HstsOptions, type HttpAdapter, type HttpContext, type HttpControllerDefinition, type HttpCookieOptions, type HttpErrorBody, HttpException, type HttpExceptionOptions, type HttpInterceptor, type HttpInterceptorClass, type HttpMetadata, type HttpMethod, type HttpParamDefinition, type HttpParamSource, type HttpPluginOptions, type HttpResponseInit, type HttpRouteDefinition, type HttpRouteGroupDefinition, type HttpRouteInfo, type HttpRouteSummary, type HttpServerAddress, type HttpSseDefinition, type HttpSseOptions, type HttpUploadDefinition, type InferSchemaInput, type InferSchemaOutput, type InjectRequest, type InjectResponse, type InjectSseResponse, type InjectSseWaitOptions, type InjectStreamOptions, type InjectStreamRequest, type InjectStreamResponse, type InterceptorRef, InternalServerErrorException, type MediaType, MethodNotAllowedException, type NodeAdapter, type NodeAdapterOptions, NotFoundException, NotImplementedException, type ParseSseOptions, PayloadTooLargeException, type PluginHttpRoutes, type PluginHttpRoutesContext, type PluginRoute, type QueryRecord, type RedirectStatus, type ReplyBody, type RequestAbortKind, RequestAbortedError, type RequestId, type ResponseCookie, type RouteDecorator, type RouteDecoratorArgs, type RouteDecoratorInfo, type RouteDecoratorOptions, type RouteMetaCarrier, type RouteMetaEntry, type SecurityHeadersOptions, ServiceUnavailableException, type SetCookieInfo, type SseBody, type SseEvent, type SseItem, type SseMessage, type SseOptions, type SseSource, type StandardSchemaV1, type StandardSchemaV1FailureResult, type StandardSchemaV1Issue, type StandardSchemaV1Options, type StandardSchemaV1PathSegment, type StandardSchemaV1Props, type StandardSchemaV1Result, type StandardSchemaV1SuccessResult, type StandardSchemaV1Types, type StreamResponseOptions, type StreamSource, TooManyRequestsException, type TrailingSlashPolicy, type TrustProxy, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, type UploadLimits, type UploadedFileOptions, type UploadedFilesOptions, type Uploads, ValidationException, type ValidationIssueDetail, formatByteSize, isHttpException, isStandardSchema, nodeAdapter, parseByteSize, parseCookieHeader, parseQuery, parseSetCookie, serializeClearCookie, serializeCookie, toIssueDetail, uploads };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -3884,25 +3884,29 @@ var Pipeline = class {
 			},
 			method: definition.method,
 			jsonStatus: definition.method === "HEAD" || isBodylessStatus(json) ? void 0 : json,
-			emptyStatus: definition.status ?? (post ? 201 : 204)
+			emptyStatus: definition.status ?? (post ? 201 : 204),
+			responses: definition.method !== "HEAD"
 		};
 	}
 	/**
 	* The fast lane: what {@link handle} does for a route of {@link #fastRoute}, decided once instead
-	* of per request, without promises while the route stays synchronous. A request takes it when no
-	* `http:request` wrapper nor listener is registered, the server is not draining and its method
-	* is the route's (not a `HEAD` served by a `GET` route); a plain object or array returned by the
-	* handler is serialised as JSON, and `undefined` answered without body, with the headers in their
-	* final order (a template precomputed at boot).
+	* of per request, without promises while the route stays synchronous. A request takes it when the
+	* server is not draining and its method is the route's (not a `HEAD` served by a `GET` route); a
+	* plain object or array returned by the handler is serialised as JSON, and `undefined` answered
+	* without body, with the headers in their final order (a template precomputed at boot).
 	* A thenable result is awaited in the lane (see {@link #fastAsync}). Anything else — a malformed
 	* path (before the request starts), a thrown error or a rejection, an `HttpResponse`, a `Response`
 	* or any other result, headers or cookies set through the context — continues in the general
 	* pipeline, in the same request scope, with the same outcome.
+	* With `http:request` wrappers, the handler runs inside them (see {@link #fastWrapped}); listeners
+	* get the event once the reply is ready, as in the general pipeline.
 	*/
 	#fast(route, request) {
 		const plan = route.plan;
+		if (this.draining || request.method !== route.method) return this.handle(plan, request);
 		const hooks = this.#hooks;
-		if (this.draining || request.method !== route.method || hooks.hasWrappers("http:request") || hooks.hasListeners("http:request")) return this.handle(plan, request);
+		const wrapped = hooks.hasWrappers("http:request");
+		const startTime = wrapped || hooks.hasListeners("http:request") ? performance.now() : void 0;
 		const url = request.url;
 		const mark = url.indexOf("?");
 		const path = mark === -1 ? url : url.slice(0, mark);
@@ -3918,13 +3922,13 @@ var Pipeline = class {
 			return Promise.reject(error);
 		}
 		const scope = this.#container.openScope([[HttpTokens.Context, ctx], [HttpTokens.RequestId, ctx.requestId]]);
-		const done = scope.run(this.#fastRun, route, request, ctx);
-		if (done instanceof Exchange) {
-			done.done.then(() => this.#end(done, scope, void 0), (error) => this.#end(done, scope, error));
-			if (!hooks.hasListeners("http:request")) return done.replied;
-			done.tracked = true;
-			return this.#emitted(done);
+		if (wrapped) {
+			const x = new Exchange(request, ctx, ctx.requestId, route.target, startTime);
+			x.done = scope.run(this.#fastWrapped, x, route);
+			return this.#fastExchange(x, scope);
 		}
+		const done = scope.run(this.#fastRun, route, request, ctx, startTime);
+		if (done instanceof Exchange) return this.#fastExchange(done, scope);
 		const closing = scope.close();
 		if (closing === void 0) {
 			ctx.complete();
@@ -3935,7 +3939,7 @@ var Pipeline = class {
 			closing.then(() => this.#over(x), (error) => this.#disposalFailed(x, error));
 		}
 		if (!hooks.hasListeners("http:request")) return Promise.resolve(done);
-		const event = requestEvent(request, ctx, performance.now());
+		const event = requestEvent(request, ctx, startTime ?? performance.now());
 		event.status = done.status;
 		return Promise.resolve(done).then((reply) => {
 			hooks.emit("http:request", event);
@@ -3943,20 +3947,31 @@ var Pipeline = class {
 		});
 	}
 	/**
+	* The reply of a fast-lane request whose asynchronous part runs in `x.done`: the request ends once
+	* it settled (see {@link #end}); listeners get the event once the reply is ready.
+	*/
+	#fastExchange(x, scope) {
+		x.done.then(() => this.#end(x, scope, void 0), (error) => this.#end(x, scope, error));
+		if (!this.#hooks.hasListeners("http:request")) return x.replied;
+		x.tracked = true;
+		return this.#emitted(x);
+	}
+	/**
 	* The fast lane in the request scope: the reply when the handler answered synchronously with a
 	* plain JSON value or `undefined`, otherwise the exchange finishing the request (see {@link #fast}).
+	* `startTime`: the request has `http:request` listeners, its event starts with the exchange.
 	*/
-	#fastRun = (route, request, ctx) => {
+	#fastRun = (route, request, ctx, startTime) => {
 		const plan = route.plan;
-		if (plan.parseBody) return this.#fastLater(route, request, ctx, NO_RESULT);
+		if (plan.parseBody) return this.#fastLater(route, request, ctx, NO_RESULT, startTime);
 		let result;
 		let reply;
 		try {
 			result = plan.definition.invoke(this.#resolve(plan.controller), ctx);
-			if (isThenable(result)) return this.#fastLater(route, request, ctx, result);
+			if (isThenable(result)) return this.#fastLater(route, request, ctx, result, startTime);
 			reply = this.#fastReply(route, ctx, result);
 		} catch (error) {
-			const x = new Exchange(request, ctx, ctx.requestId, route.target);
+			const x = new Exchange(request, ctx, ctx.requestId, route.target, startTime);
 			x.done = this.#respond(x, () => this.#failed(error, ctx, x.event));
 			return x;
 		}
@@ -3965,13 +3980,13 @@ var Pipeline = class {
 			ctx.releaseBody();
 			return reply;
 		}
-		const x = new Exchange(request, ctx, ctx.requestId, route.target);
+		const x = new Exchange(request, ctx, ctx.requestId, route.target, startTime);
 		x.done = this.#respond(x, () => this.#settle(ctx, plan, x.event, result));
 		return x;
 	};
 	/** The fast lane of a route with a body to read or a handler that returned a thenable. */
-	#fastLater(route, request, ctx, result) {
-		const x = new Exchange(request, ctx, ctx.requestId, route.target);
+	#fastLater(route, request, ctx, result, startTime) {
+		const x = new Exchange(request, ctx, ctx.requestId, route.target, startTime);
 		x.done = this.#fastAsync(x, route, result);
 		return x;
 	}
@@ -4007,17 +4022,39 @@ var Pipeline = class {
 		x.answer(reply);
 	}
 	/**
-	* The reply of a plain JSON value (see {@link isPlainJson}) or of `undefined`: what
-	* `serializeResult` and {@link #complete} produce for it, the headers in their final order.
-	* `undefined` when the result or the context needs the general pipeline. Throws like
-	* `JSON.stringify`.
+	* The reply of a plain JSON value (see {@link isPlainJson}), of an `HttpResponse` carrying one
+	* (see {@link fastResponseType}) or of `undefined`: what `serializeResult` and {@link #complete}
+	* produce for it, the headers in their final order. `undefined` when the result or the context
+	* needs the general pipeline. Throws like `JSON.stringify`.
 	*/
 	#fastReply(route, ctx, result) {
-		const status = result === void 0 ? route.emptyStatus : route.jsonStatus;
+		let payload = result;
+		let status = result === void 0 ? route.emptyStatus : route.jsonStatus;
+		let type = null;
+		if (route.responses && result instanceof HttpResponse) {
+			const own = fastResponseType(result);
+			if (own === void 0) return void 0;
+			type = own;
+			payload = result.body;
+			if (route.plan.definition.status === void 0 && result.status !== void 0) status = isBodylessStatus(result.status) ? void 0 : result.status;
+			if (payload === void 0) return void 0;
+		}
 		if (status === void 0 || ctx.hasResponseHeaders || ctx.hasCookies || this.draining) return void 0;
 		const requestId = ctx.requestId;
 		if (!this.#validIds && !isHeaderValue(requestId)) return void 0;
-		if (result === void 0) {
+		if (payload === void 0) return this.#templateReply(status, null, void 0, requestId, null);
+		if (!isPlainJson(payload)) return void 0;
+		const json = JSON.stringify(payload);
+		if (json === void 0) throw new TypeError(`Cannot serialise a ${typeof payload} as a response body`);
+		return this.#templateReply(status, utf8(json), json, requestId, type);
+	}
+	/**
+	* The reply of a JSON body (`text` set) or of no body, its headers copied from the template of
+	* the fast lane (see {@link #jsonHeaders}), completed with the length and the request id (one that
+	* can be sent). `type` replaces the JSON content type in place (the `HttpResponse`'s own).
+	*/
+	#templateReply(status, body, text, requestId, type) {
+		if (text === void 0) {
 			const headers = { ...this.#emptyHeaders };
 			const idHeader = this.#emptyIdHeader;
 			if (idHeader !== void 0) headers[idHeader] = requestId;
@@ -4027,11 +4064,8 @@ var Pipeline = class {
 				body: null
 			};
 		}
-		if (!isPlainJson(result)) return void 0;
-		const json = JSON.stringify(result);
-		if (json === void 0) throw new TypeError(`Cannot serialise a ${typeof result} as a response body`);
 		const headers = { ...this.#jsonHeaders };
-		const body = utf8(json);
+		if (type !== null) headers["content-type"] = type;
 		headers["content-length"] = String(body.byteLength);
 		const idHeader = this.#jsonIdHeader;
 		if (idHeader !== void 0) headers[idHeader] = requestId;
@@ -4039,8 +4073,128 @@ var Pipeline = class {
 			status,
 			headers,
 			body,
-			text: json
+			text
+		};
+	}
+	/**
+	* The fast lane through the `http:request` wrappers (registered when the request started), in the
+	* request scope: what {@link #respond} does for the route, the handler run inside `next()` like
+	* {@link #fastRun}. A JSON value or `undefined` is serialised there as `serializeResult` does, and
+	* the reply completed from the template of the fast lane when the wrappers added no response header
+	* (`event.responseHeaders`) nor cookie (see {@link #fastDeliver}). Never rejects.
+	*/
+	#fastWrapped = (x, route) => this.#hooks.run("http:request", x.event, () => this.#fastOperation(x, route)).then(() => this.#fastDeliver(x, false, void 0), (error) => this.#fastDeliver(x, true, error));
+	/** The operation wrapped by the `http:request` wrappers in the fast lane: the route run, its outcome checked. */
+	#fastOperation(x, route) {
+		const ctx = x.ctx;
+		const plan = route.plan;
+		if (plan.parseBody) return this.#fastOperationLater(x, route, NO_RESULT);
+		let result;
+		try {
+			result = plan.definition.invoke(this.#resolve(plan.controller), ctx);
+		} catch (error) {
+			return this.#fastChecked(x, this.#failed(error, ctx, x.event));
+		}
+		if (isThenable(result)) return this.#fastOperationLater(x, route, result);
+		return this.#fastChecked(x, this.#fastOutcome(x, route, result));
+	}
+	/** {@link #fastOperation} with a body to read (`pending` is {@link NO_RESULT}) or a thenable result. */
+	async #fastOperationLater(x, route, pending) {
+		const ctx = x.ctx;
+		const plan = route.plan;
+		let result = pending;
+		try {
+			if (result === NO_RESULT) {
+				const controller = this.#resolve(plan.controller);
+				await ctx.parseBody();
+				result = plan.definition.invoke(controller, ctx);
+			}
+			if (isThenable(result)) result = await result;
+		} catch (error) {
+			return await this.#fastChecked(x, this.#failed(error, ctx, x.event));
+		}
+		return await this.#fastChecked(x, this.#fastOutcome(x, route, result));
+	}
+	/**
+	* The outcome of a handler result in {@link #fastOperation}: for a plain JSON value or `undefined`,
+	* the reply of `serializeResult` built directly (`x.fast` set); anything else as in the general
+	* pipeline (see {@link #settle}). Never throws nor rejects (errors are mapped).
+	*/
+	#fastOutcome(x, route, result) {
+		const ctx = x.ctx;
+		const event = x.event;
+		const status = result === void 0 ? route.emptyStatus : route.jsonStatus;
+		if (status === void 0 || ctx.hasResponseHeaders || result !== void 0 && !isPlainJson(result)) return this.#settle(ctx, route.plan, event, result);
+		let reply;
+		if (result === void 0) reply = {
+			status,
+			headers: fastRecord(),
+			body: null
 		};
+		else {
+			let json;
+			try {
+				json = JSON.stringify(result);
+				if (json === void 0) throw new TypeError(`Cannot serialise a ${typeof result} as a response body`);
+			} catch (error) {
+				return this.#failed(error, ctx, event);
+			}
+			const headers = fastRecord();
+			headers["content-type"] = ContentType.json;
+			const body = utf8(json);
+			headers["content-length"] = String(body.byteLength);
+			reply = {
+				status,
+				headers,
+				body,
+				text: json,
+				ownHeaders: true
+			};
+		}
+		event.status = status;
+		x.fast = true;
+		return reply;
+	}
+	/**
+	* What the general pipeline does with an outcome inside the wrappers (see {@link #respond}): its
+	* headers and cookies checked, the async context of a streamed body captured; kept in `x.outcome`.
+	*/
+	#fastChecked(x, pending) {
+		if (pending instanceof Promise) return pending.then((outcome) => this.#fastKeep(x, outcome));
+		return Promise.resolve(this.#fastKeep(x, pending));
+	}
+	#fastKeep(x, outcome) {
+		const checked = x.fast ? outcome : this.#checked(outcome, x.ctx, x.event);
+		if (checked !== RAW && isStreamed(checked.body)) x.run = captureContext();
+		x.outcome = checked;
+		return checked;
+	}
+	/**
+	* Answers a fast-lane request once its wrappers settled: a reply of {@link #fastOutcome} gets the
+	* headers of the template when nothing was added to it (no response header from the wrappers, no
+	* cookie, not draining, a request id that can be sent), which is what {@link #complete} gives;
+	* anything else is completed by {@link #deliver}. Never rejects.
+	*/
+	#fastDeliver(x, failed, hookError) {
+		const outcome = x.outcome;
+		const ctx = x.ctx;
+		if (outcome === void 0) return this.#fastUnhandled(x, failed ? hookError : NOT_CALLED);
+		if (failed) this.#wrapperFailed(x, hookError);
+		else if (x.fast && outcome !== RAW && !hasOwnKeys(x.event.responseHeaders) && !ctx.hasCookies && !this.draining && (this.#validIds || isHeaderValue(x.requestId))) {
+			const reply = this.#templateReply(outcome.status, outcome.body, outcome.text, x.requestId, null);
+			ctx.commit();
+			ctx.releaseBody();
+			x.answer(reply);
+			return;
+		}
+		const streaming = this.#send(x, outcome, true, x.run);
+		if (streaming === void 0) return void 0;
+		return streaming.tracked.done.then((failure) => this.#streamed(x, streaming, failure));
+	}
+	/** {@link #fastDeliver} when a wrapper failed before the request was handled or did not call `next()`. */
+	async #fastUnhandled(x, failure) {
+		const streaming = this.#send(x, await this.#unhandled(x, failure), true, void 0);
+		if (streaming !== void 0) this.#streamed(x, streaming, await streaming.tracked.done);
 	}
 	/** Ends a fast-lane request once its asynchronous part settled: its scope is closed, then it is over. */
 	#end(x, scope, error) {
@@ -4225,16 +4379,41 @@ var Pipeline = class {
 			hookError = error;
 		}
 		if (outcome === void 0) {
-			const error = failed ? hookError : /* @__PURE__ */ new Error("An \"http:request\" hook wrapper did not call next()");
-			event.error ??= error;
-			const fallback = await this.#errorReply(error, ctx);
-			outcome = this.#checkCookies(this.#checkHeaders(fallback, ctx, event), ctx, event);
-			event.status = outcome.status;
+			outcome = await this.#unhandled(x, failed ? hookError : NOT_CALLED);
 			recheck = true;
-		} else if (failed) this.#logger.error("An \"http:request\" hook wrapper failed after the request was handled", {
-			err: hookError,
-			requestId
+		} else if (failed) this.#wrapperFailed(x, hookError);
+		const streaming = this.#send(x, outcome, recheck, run);
+		if (streaming !== void 0) this.#streamed(x, streaming, await streaming.tracked.done);
+	}
+	/**
+	* The reply of a request whose `http:request` wrapper failed before it was handled (`error`), or
+	* did not call `next()` ({@link NOT_CALLED}): the error mapped and checked like a handled reply (an
+	* exception mapper's `HttpResponse` may carry cookies). Never rejects.
+	*/
+	async #unhandled(x, failure) {
+		const ctx = x.ctx;
+		const event = x.event;
+		const error = failure === NOT_CALLED ? /* @__PURE__ */ new Error("An \"http:request\" hook wrapper did not call next()") : failure;
+		event.error ??= error;
+		const fallback = await this.#errorReply(error, ctx);
+		const reply = this.#checkCookies(this.#checkHeaders(fallback, ctx, event), ctx, event);
+		event.status = reply.status;
+		return reply;
+	}
+	#wrapperFailed(x, error) {
+		this.#logger.error("An \"http:request\" hook wrapper failed after the request was handled", {
+			err: error,
+			requestId: x.requestId
 		});
+	}
+	/**
+	* Completes the outcome of a request (`recheck`: wrappers ran) and hands its reply to the adapter.
+	* Returns the tracking of a streamed body (read in `run`, the context of the handler, when it was
+	* captured), whose end {@link #streamed} records.
+	*/
+	#send(x, outcome, recheck, run) {
+		const ctx = x.ctx;
+		const event = x.event;
 		if (outcome === RAW) {
 			ctx.commit();
 			const status = x.request.rawStatus?.() ?? 200;
@@ -4247,7 +4426,7 @@ var Pipeline = class {
 			});
 			return;
 		}
-		const serialized = this.#complete(outcome, ctx, event, requestId, x.cors, x.preflight, recheck);
+		const serialized = this.#complete(outcome, ctx, event, x.requestId, x.cors, x.preflight, recheck);
 		const body = serialized.body;
 		if (!isStreamed(body)) {
 			const reply = adapterReply(serialized, body);
@@ -4265,11 +4444,18 @@ var Pipeline = class {
 		}
 		ctx.commit();
 		x.answer(reply);
-		const failure = await tracked.done;
-		if (session !== void 0) this.#streams.delete(session);
+		return {
+			tracked,
+			session
+		};
+	}
+	/** A streamed body was sent or abandoned (`failure`: the stream failed). */
+	#streamed(x, streaming, failure) {
+		const ctx = x.ctx;
+		if (streaming.session !== void 0) this.#streams.delete(streaming.session);
 		if (failure !== void 0) this.#logger.error("The response stream failed", {
 			err: failure,
-			requestId,
+			requestId: x.requestId,
 			path: ctx.path
 		});
 		ctx.releaseBody();
@@ -4672,6 +4858,8 @@ var Pipeline = class {
 };
 /** `#fastAsync` reads the body and runs the handler. */
 const NO_RESULT = Symbol("no result");
+/** An `http:request` wrapper returned without calling `next()` (see `Pipeline.#unhandled`). */
+const NOT_CALLED = Symbol("next() not called");
 /** A request being answered (internal): its context, its target and the promise of its reply. */
 var Exchange = class {
 	request;
@@ -4686,6 +4874,12 @@ var Exchange = class {
 	tracked = false;
 	/** The asynchronous part of a fast-lane request (never rejects). */
 	done = void 0;
+	/** Fast lane with wrappers: the outcome of the route once checked (see `Pipeline.#fastKeep`). */
+	outcome = void 0;
+	/** Fast lane with wrappers: `outcome` is a JSON reply or a reply without body built by the lane. */
+	fast = false;
+	/** Fast lane with wrappers: the async context of the handler, for a streamed body. */
+	run = void 0;
 	#resolve;
 	#reject;
 	#event;
@@ -4735,6 +4929,11 @@ function requestEvent(request, ctx, startTime) {
 		responseHeaders: {}
 	};
 }
+/** Whether a record has an own enumerable property (`event.responseHeaders` was written to). */
+function hasOwnKeys(record) {
+	for (const key in record) if (Object.hasOwn(record, key)) return true;
+	return false;
+}
 /**
 * The decoded parameters of a raw request path matched against a route, in one pass: what
 * `matchRoutePath` then `decodePathValue` (see `Pipeline.#route`) give for a path they accept.
@@ -4787,6 +4986,22 @@ function isPlainJson(value) {
 	} else if (prototype !== Array.prototype || ctor !== Array) return false;
 	return typeof value.pipe !== "function";
 }
+/**
+* The content type of an `HttpResponse` the fast lane can serve: `null` without headers, its
+* `content-type` when that is its only header (lower-case name, a value every adapter can send);
+* `undefined` when it needs the general pipeline (other headers, cookies).
+*/
+function fastResponseType(response) {
+	if (response.cookies.length > 0) return void 0;
+	const headers = response.headers;
+	let type = null;
+	for (const name of Object.keys(headers)) {
+		const value = headers[name];
+		if (name !== "content-type" || typeof value !== "string" || !isHeaderValue(value)) return void 0;
+		type = value;
+	}
+	return type;
+}
 const ENCODER = new TextEncoder();
 /** UTF-8 encoding of a text body, like the serialiser (a pooled `Buffer` on Node.js, `TextEncoder` on Bun). */
 const utf8 = isBun() ? (text) => ENCODER.encode(text) : (text) => Buffer$1.from(text, "utf8");
@@ -4947,6 +5162,8 @@ function validateRoute(instance, plugin, value, prefix) {
 	}
 	const guards = route.guards ?? [];
 	if (!Array.isArray(guards)) throw invalid(plugin, `the guards of the route ${where} must be an array`);
+	const bodyLimit = route.bodyLimit === void 0 ? void 0 : parseByteSize(route.bodyLimit);
+	if (route.bodyLimit !== void 0 && bodyLimit === void 0) throw invalid(plugin, `invalid bodyLimit ${describe(route.bodyLimit)} of the route ${where}: expected a size in bytes (1048576, '100kb', Infinity)`);
 	return {
 		plugin,
 		instance,
@@ -4956,7 +5173,8 @@ function validateRoute(instance, plugin, value, prefix) {
 		name: route.name,
 		handler: route.handler,
 		meta: entries,
-		guards
+		guards,
+		bodyLimit
 	};
 }
 function metaEntry(plugin, where, value) {
@@ -5940,7 +6158,7 @@ function buildRegistrations(ctx, options, raw, pluginRoutes) {
 			invoke: (_plugin, http) => handler(http)
 		});
 		const instance = { instance: route.instance };
-		const body = bodyPlan({}, options.bodyLimit, options.uploads);
+		const body = bodyPlan(route.bodyLimit === void 0 ? {} : { bodyLimit: route.bodyLimit }, options.bodyLimit, options.uploads);
 		const chain = guards.map((guard) => guard.resolvable);
 		const path = route.path;
 		declared.push({