@harperfast/harper 5.3.0-alpha.1 → 5.3.0-beta.1

package/server/DESIGN.md

@@ -208,6 +208,17 @@ mirror because it only widens what an allowlist may _name_; enforcement stays on
 
 `REST.ts → http(request, nextHandler)` is the chief integration point: it takes a `Request`, asks the `Resources` registry for a match, builds a `RequestTarget`, and dispatches into the Resource class's static method. Cache headers are translated to `request.expiresAt` / `onlyIfCached` / `noCache` flags within the same function.
 
+### Streaming startup errors
+
+SSE and NDJSON serializers eagerly take and hold their first iterator step for GET requests. `REST.ts` waits through the next event-loop turn for that step: an immediate rejection remains an HTTP error rendered as Problem Details, while a first item or the cutoff commits the stream. Mutating requests do not use the startup-status gate because their transaction has already committed by this point; all of their stream failures use the in-band form. Later GET failures are terminal, format-valid records (`event: harper-error` for SSE and a reserved control record for NDJSON). Keep the decision in the serializer/REST boundary so Node, uWS, Bun, compression, and injection share one contract; transports must not independently prefetch the iterator.
+
+SSE terminal event data uses `{ error: <code-or-class>, message: <message>, status?: <status> }`; NDJSON wraps the same object as `{ "$harperStreamError": { ... } }` so it cannot be mistaken for an ordinary row with an `error` field.
+Sources with `mapError` remain unmapped for these two formats so their failures reach this single contract instead of becoming legacy data records.
+generic JSON-array streaming retains its older `{ error: "<name>: <message>" }` element shape.
+The `error` value is the stable programmatic discriminator; `message` is diagnostic and follows the same thrown-message exposure policy as pre-commit Problem Details.
+
+Clean stream completion does not prove completeness; clients must inspect SSE for the `harper-error` event and NDJSON for the `$harperStreamError` control record.
+
 ### Deferred credential rejection (#2418)
 
 `authentication` runs before route matching, so when it meets an `Authorization` header it cannot

package/server/REST.ts

@@ -1,6 +1,12 @@
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { serialize, serializeMessage, getDeserializer } from '../server/serverHelpers/contentTypes.ts';
+import {
+	serialize,
+	serializeMessage,
+	getDeserializer,
+	waitForStreamStartup,
+	discardSerializedStream,
+} from '../server/serverHelpers/contentTypes.ts';
 import { addAnalyticsListener, recordAction, recordActionBinary } from '../resources/analytics/write.ts';
 import * as harperLogger from '../utility/logging/harper_logger.ts';
 import { ServerError, ClientError } from '../utility/errors/hdbError.ts';
@@ -348,7 +354,15 @@ async function http(request: Request, nextHandler, resources: Resources, httpOpt
 				headers.setIfNone('Last-Modified', new Date(lastModification).toUTCString());
 		} else if (responseData.headers) {
 			// if response is a Response object (or response-like envelope with headers), use it as the response
-			return finalizeResponse(responseData, headers, status, request);
+			const response = finalizeResponse(responseData, headers, status, request);
+			if (request.method === 'HEAD') {
+				discardSerializedStream(response.body);
+				if (!(response instanceof Response)) response.body = undefined;
+			} else if (request.method === 'GET') {
+				const startup = waitForStreamStartup(response.body);
+				if (startup) await startup;
+			}
+			return response;
 		} else if (isFinite(lastModification)) {
 			etagFloat[0] = lastModification;
 			// base64 encoding of the 64-bit float encoding of the date in ms (with quotes)
@@ -422,7 +436,13 @@ async function http(request: Request, nextHandler, resources: Resources, httpOpt
 				setCountHeaders(headers, (target as any).offset || 0, (target as any).count, responseData);
 			}
 			responseObject.body = serialize(responseData, request, responseObject);
-			if (method === 'HEAD') responseObject.body = undefined; // we want everything else to be the same as GET, but then omit the body
+			if (request.method === 'HEAD') {
+				discardSerializedStream(responseObject.body);
+				responseObject.body = undefined; // we want everything else to be the same as GET, but then omit the body
+			} else if (request.method === 'GET') {
+				const startup = waitForStreamStartup(responseObject.body);
+				if (startup) await startup;
+			}
 		}
 		// A collection read's count headers vary by the request's `Prefer` value; serialize() just reset
 		// `Vary`, so declare it here (after serialization) — otherwise a shared cache could serve count
@@ -466,6 +486,19 @@ async function http(request: Request, nextHandler, resources: Resources, httpOpt
 			headers,
 			body: undefined,
 		};
+		// The error body is a different representation, so success representation and caching headers
+		// accumulated before the startup failure must not survive its serialization.
+		for (const header of [
+			'Content-Encoding',
+			'Cache-Control',
+			'ETag',
+			'Last-Modified',
+			'Content-Range',
+			'Range-Unit',
+			'Preference-Applied',
+			'Age',
+		])
+			headers.delete(header);
 		responseObject.body = serialize(problemDetail, request, responseObject);
 		return responseObject;
 	}

package/server/http.ts

@@ -12,6 +12,11 @@ import * as env from '../utility/environment/environmentManager.ts';
 import * as terms from '../utility/hdbTerms.ts';
 import { getConfigPath } from '../config/configUtils.ts';
 import { getTicketKeys, getWorkerIndex } from './threads/manageThreads.js';
+import {
+	applicationSocketName,
+	isolatedApplicationRoute,
+	thisThreadsIsolatedApplication,
+} from './threads/isolatedApplications.ts';
 import { createTLSSelector, getEffectiveTlsCiphers } from '../security/keys.ts';
 import { createSecureServer, createServer as createH2CServer } from 'node:http2';
 import { createServer as createSecureServerHttp1 } from 'node:https';
@@ -196,10 +201,21 @@ export function writeUdsMetadata(
 	port: number | string,
 	secureServer: any,
 	protocol?: string,
-	mtlsForwarding = true
+	mtlsForwarding = true,
+	route: { application: string; hosts: string[] } | undefined = isolatedApplicationRoute()
 ) {
 	const contexts = secureServer.secureContexts;
 	let yaml = `pid: ${process.pid}\ntid: ${currentThreadId()}\nport: ${port}\n`;
+	// Routing identity, separate from certificate coverage: a proxy sends this application's hosts to
+	// this socket alone, whatever hostnames the (shared, possibly wildcard) certificates carry.
+	if (route) {
+		yaml += `application: ${JSON.stringify(route.application)}\n`;
+		if (route.hosts.length === 0) yaml += `applicationHosts: []\n`;
+		else {
+			yaml += `applicationHosts:\n`;
+			for (const host of route.hosts) yaml += `  - ${JSON.stringify(host)}\n`;
+		}
+	}
 	// Which application protocol this socket speaks (absent = http/1.1, the historical
 	// default) — lets a fronting proxy route by negotiated ALPN.
 	if (protocol) yaml += `protocol: ${protocol}\n`;
@@ -267,6 +283,19 @@ export function cleanupSocketsDirectory() {
 	} catch {}
 }
 
+export function cleanupApplicationSockets(application: string) {
+	const socketsDir = join(env.getHdbBasePath(), 'sockets');
+	const prefix = applicationSocketName(application, '');
+	try {
+		for (const file of readdirSync(socketsDir)) {
+			if (!file.startsWith(prefix) || (!file.endsWith('.sock') && !file.endsWith('.yaml'))) continue;
+			try {
+				unlinkSync(join(socketsDir, file));
+			} catch {}
+		}
+	} catch {}
+}
+
 // Entries in `universalHeaders` that were pushed by `applySecurityHeaders`, so a config
 // hot-reload can remove exactly the entries it owns without clobbering entries pushed by
 // other components.
@@ -875,7 +904,10 @@ function getHTTPServer(port: number, secure: boolean, options: ServerOptions) {
 		if (secure && env.get(terms.CONFIG_PARAMS.TLS_UNIXDOMAINSOCKETS)) {
 			const socketsDir = join(env.getHdbBasePath(), 'sockets');
 			mkdirSync(socketsDir, { recursive: true });
-			const socketName = `${getWorkerIndex()}-${port}`;
+			const isolatedApplication = thisThreadsIsolatedApplication();
+			const socketName = isolatedApplication
+				? applicationSocketName(isolatedApplication, port)
+				: `${getWorkerIndex()}-${port}`;
 			const udsPath = join(socketsDir, `${socketName}.sock`);
 			const yamlPath = join(socketsDir, `${socketName}.yaml`);
 

package/server/serverHelpers/Headers.ts

@@ -31,6 +31,10 @@ export class Headers extends Map<string, [string, string | string[]]> {
 		if (typeof name !== 'string') name = '' + name;
 		return super.has(name.toLowerCase());
 	}
+	delete(name) {
+		if (typeof name !== 'string') name = '' + name;
+		return super.delete(name.toLowerCase());
+	}
 	setIfNone(name, value) {
 		if (typeof name !== 'string') name = '' + name;
 		if (typeof value !== 'string') value = '' + value;
@@ -239,7 +243,7 @@ function nodeResponseHeaders(nodeResponse: any) {
 	};
 }
 
-function applyWriteHeadHeaders(nodeResponse: any, headers: any): void {
+export function applyWriteHeadHeaders(nodeResponse: any, headers: any): void {
 	const suppliedHeaders = new Map<string, { name: string; value: any }>();
 	const addHeader = (name: string, value: any) => {
 		const key = String(name).toLowerCase();

package/server/serverHelpers/NodeAdapterResponse.ts

@@ -0,0 +1,221 @@
+import { STATUS_CODES } from 'node:http';
+import type {
+	IncomingMessage as NodeIncomingMessage,
+	OutgoingHttpHeader,
+	OutgoingHttpHeaders,
+	ServerResponse as NodeServerResponse,
+} from 'node:http';
+import type { Socket } from 'node:net';
+import { PassThrough } from 'node:stream';
+import { Headers as ResponseHeaders, applyWriteHeadHeaders } from './Headers.ts';
+
+export interface AdaptedResponse {
+	status: number;
+	headers: ResponseHeaders;
+	body: PassThrough;
+}
+
+class HeadersSentError extends Error {
+	code = 'ERR_HTTP_HEADERS_SENT';
+	constructor(action: string) {
+		super(`Cannot ${action} headers after they are sent to the client`);
+	}
+}
+
+class UnsupportedResponseMethodError extends Error {
+	constructor(method: string) {
+		super(`${method}() is not supported on a withNodeAdapter() response`);
+	}
+}
+
+const ignoreError = () => {};
+
+export class NodeAdapterResponse extends PassThrough implements NodeServerResponse {
+	statusCode = 200;
+	statusMessage = '';
+	strictContentLength = false;
+	chunkedEncoding = false;
+	shouldKeepAlive = true;
+	useChunkedEncodingByDefault = true;
+	sendDate = true;
+	readonly req: NodeIncomingMessage;
+	readonly socket: Socket | null;
+	#headers = new ResponseHeaders();
+	#committedStatus: number | undefined;
+	#headerText: string | undefined;
+	#nodeResponse: NodeServerResponse | undefined;
+	#resolve: (response: AdaptedResponse) => void;
+	#reject: (reason: unknown) => void;
+
+	constructor(
+		req: NodeIncomingMessage,
+		nodeResponse: NodeServerResponse | undefined,
+		resolve: (response: AdaptedResponse) => void,
+		reject: (reason: unknown) => void
+	) {
+		super();
+		this.req = req;
+		this.socket = req.socket ?? null;
+		this.#nodeResponse = nodeResponse;
+		this.#resolve = resolve;
+		this.#reject = reject;
+		this.on('error', ignoreError);
+		if (typeof nodeResponse?.on === 'function') {
+			const forward = (...args: any[]) => this.emit('timeout', ...args);
+			let forwarding = false;
+			const syncForwarding = (wanted: boolean) => {
+				if (wanted === forwarding) return;
+				forwarding = wanted;
+				if (wanted) nodeResponse.on('timeout', forward);
+				else nodeResponse.removeListener('timeout', forward);
+			};
+			const onNewListener = (event: string | symbol) => event === 'timeout' && syncForwarding(true);
+			const onRemoveListener = (event: string | symbol) =>
+				event === 'timeout' && syncForwarding(this.listenerCount('timeout') > 0);
+			this.on('newListener', onNewListener);
+			this.on('removeListener', onRemoveListener);
+			this.once('close', () => {
+				syncForwarding(false);
+				this.removeListener('newListener', onNewListener);
+				this.removeListener('removeListener', onRemoveListener);
+			});
+		}
+	}
+
+	get headersSent() {
+		return this.#committedStatus !== undefined;
+	}
+	get finished() {
+		return this.writableEnded;
+	}
+	get connection() {
+		return this.socket;
+	}
+	get _header(): string | null {
+		if (this.#committedStatus === undefined) return null;
+		if (this.#headerText === undefined) {
+			let text = `HTTP/1.1 ${this.#committedStatus} ${this.statusMessage}\r\n`;
+			for (const [name, value] of this.#headers) {
+				if (Array.isArray(value)) for (const entry of value) text += `${name}: ${entry}\r\n`;
+				else text += `${name}: ${value}\r\n`;
+			}
+			this.#headerText = text + '\r\n';
+		}
+		return this.#headerText;
+	}
+
+	setHeader(name: string, value: number | string | readonly string[]) {
+		if (this.headersSent) throw new HeadersSentError('set');
+		this.#headers.set(name, value);
+		return this;
+	}
+	setHeaders(headers: Headers | Map<string, number | string | readonly string[]> | ResponseHeaders) {
+		let cookies: string[] | undefined;
+		for (const [name, value] of headers) {
+			if (name.toLowerCase() !== 'set-cookie') this.setHeader(name, value);
+			else if (Array.isArray(value)) (cookies ??= []).push(...value);
+			else (cookies ??= []).push(String(value));
+		}
+		if (cookies) this.setHeader('set-cookie', cookies);
+		return this;
+	}
+	appendHeader(name: string, value: string | readonly string[]) {
+		if (this.headersSent) throw new HeadersSentError('append');
+		if (Array.isArray(value)) for (const entry of value) this.#headers.append(name, entry);
+		else this.#headers.append(name, value);
+		return this;
+	}
+	getHeader(name: string) {
+		return this.#headers.get(name);
+	}
+	getHeaders() {
+		const headers: OutgoingHttpHeaders = Object.create(null);
+		for (const [name, value] of this.#headers) headers[name.toLowerCase()] = value;
+		return headers;
+	}
+	getHeaderNames() {
+		return [...this.#headers.keys()];
+	}
+	hasHeader(name: string) {
+		return this.#headers.has(name);
+	}
+	removeHeader(name: string) {
+		if (this.headersSent) throw new HeadersSentError('remove');
+		this.#headers.delete(name);
+	}
+
+	writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+	writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+	writeHead(
+		statusCode: number,
+		statusMessageOrHeaders?: string | OutgoingHttpHeaders | OutgoingHttpHeader[],
+		headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]
+	) {
+		if (this.headersSent) throw new HeadersSentError('write');
+		this.statusCode = statusCode;
+		if (typeof statusMessageOrHeaders === 'string') this.statusMessage = statusMessageOrHeaders;
+		else {
+			this.statusMessage ||= STATUS_CODES[statusCode] || 'unknown';
+			// writeHead(302, undefined, headers) is the three-argument form with the status message
+			// omitted; the hole must not erase the headers the third argument carries.
+			headers ??= statusMessageOrHeaders;
+		}
+		if (headers) applyWriteHeadHeaders(this, headers);
+		this.#committedStatus = statusCode;
+		this.#resolve({ status: statusCode, headers: this.#headers, body: this });
+		return this;
+	}
+	_implicitHeader() {
+		this.writeHead(this.statusCode);
+	}
+	flushHeaders() {
+		if (!this.headersSent) this._implicitHeader();
+	}
+
+	write(
+		chunk: unknown,
+		encoding?: BufferEncoding | ((error?: Error | null) => void),
+		callback?: (error?: Error | null) => void
+	) {
+		if (!this.headersSent) this._implicitHeader();
+		return super.write(chunk, encoding as BufferEncoding, callback);
+	}
+	end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void) {
+		if (!this.headersSent) this._implicitHeader();
+		return super.end(chunk, encoding as BufferEncoding, callback);
+	}
+	_destroy(error: Error | null, callback: (error?: Error | null) => void) {
+		if (!this.headersSent) this.#reject(error ?? new Error('Response destroyed before headers were sent'));
+		callback(error);
+	}
+
+	setTimeout(msecs: number, callback?: () => void) {
+		if (callback) this.on('timeout', callback);
+		const nodeResponse = this.#nodeResponse;
+		if (typeof nodeResponse?.setTimeout !== 'function') return this;
+		nodeResponse.setTimeout(msecs);
+		return this;
+	}
+	writeContinue(callback?: () => void) {
+		if (typeof this.#nodeResponse?.writeContinue === 'function') this.#nodeResponse.writeContinue(callback);
+		else callback?.();
+	}
+	writeProcessing(callback?: () => void) {
+		if (typeof this.#nodeResponse?.writeProcessing === 'function') this.#nodeResponse.writeProcessing(callback);
+		else callback?.();
+	}
+	writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void) {
+		if (typeof this.#nodeResponse?.writeEarlyHints === 'function') this.#nodeResponse.writeEarlyHints(hints, callback);
+		else callback?.();
+	}
+	// Trailers need chunked encoding on the wire, which Harper's response layer owns; dropping one silently (a Digest, say) is worse than failing.
+	addTrailers(): never {
+		throw new UnsupportedResponseMethodError('addTrailers');
+	}
+	assignSocket(): never {
+		throw new UnsupportedResponseMethodError('assignSocket');
+	}
+	detachSocket(): never {
+		throw new UnsupportedResponseMethodError('detachSocket');
+	}
+}

package/server/serverHelpers/Request.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage as NodeIncomingMessage, ServerResponse as NodeServerResponse } from 'node:http';
 import type { Socket } from 'node:net';
 import { TLSSocket } from 'node:tls';
-import { EventEmitter } from 'node:events';
-import { Readable, PassThrough } from 'node:stream';
+import { Readable } from 'node:stream';
 import { Headers as ResponseHeaders } from './Headers.ts';
+import { NodeAdapterResponse, type AdaptedResponse } from './NodeAdapterResponse.ts';
 import type { ConnectionInfo } from './proxyProtocol.ts';
+import harperLogger from '../../utility/logging/harper_logger.ts';
 
 export const isBun = typeof globalThis.Bun !== 'undefined';
 
@@ -178,10 +179,8 @@ export class Request {
 	 * status, headers, and body, resolving the returned promise as soon as headers are available with a
 	 * streaming body that can be piped back through the Harper middleware chain.
 	 *
-	 * **Important:** The resolved `body` PassThrough must have an `error` listener attached (or be piped
-	 * to a destination that handles errors) before it is consumed. If the underlying connection is reset
-	 * after headers are sent, the body stream is destroyed with an error — without a listener, Node.js
-	 * will throw an uncaught exception.
+	 * Consume the returned body with `pipeline()`, `finished()` or async iteration so stored stream errors
+	 * and premature closes are reported.
 	 *
 	 * Example:
 	 *   server.http((request, next) =>
@@ -190,11 +189,13 @@ export class Request {
 	 */
 	withNodeAdapter(
 		handler: (request: NodeIncomingMessage, response: NodeServerResponse) => void | Promise<void>
-	): Promise<{ status: number; headers: ResponseHeaders; body: PassThrough }> {
-		// Flat headers object matching IncomingMessage.headers format (lowercase keys)
-		const reqHeaders: Record<string, string | string[]> = Object.create(null);
+	): Promise<AdaptedResponse> {
+		const reqHeaders: Record<string, string | string[]> = {};
 		for (const [key, value] of this.headers) {
-			reqHeaders[key.toLowerCase()] = value;
+			const lowerKey = key.toLowerCase();
+			if (lowerKey === '__proto__')
+				Object.defineProperty(reqHeaders, lowerKey, { value, configurable: true, enumerable: true, writable: true });
+			else reqHeaders[lowerKey] = value;
 		}
 
 		// Proxy the underlying IncomingMessage so body streaming works, but expose
@@ -209,131 +210,32 @@ export class Request {
 			},
 		}) as NodeIncomingMessage;
 
-		let resolveResponse!: (value: { status: number; headers: ResponseHeaders; body: PassThrough }) => void;
-		let rejectResponse!: (reason: unknown) => void;
-		const response = new Promise<{ status: number; headers: ResponseHeaders; body: PassThrough }>((resolve, reject) => {
-			resolveResponse = resolve;
-			rejectResponse = reject;
+		let nodeRes!: NodeAdapterResponse;
+		const response = new Promise<AdaptedResponse>((resolve, reject) => {
+			nodeRes = new NodeAdapterResponse(nodeReq, this._nodeResponse, resolve, reject);
 		});
 
-		const responseBody = new PassThrough();
-		const capturedHeaders = new ResponseHeaders();
-		let headersFlushed = false;
-		let nodeRes: ReturnType<typeof Object.assign> & NodeServerResponse;
+		const signal = this.signal;
+		const onAbort = () => nodeRes.destroy(nodeRes.headersSent ? undefined : signal.reason);
+		if (signal.aborted) onAbort();
+		else {
+			signal.addEventListener('abort', onAbort, { once: true });
+			nodeRes.once('close', () => signal.removeEventListener('abort', onAbort));
+		}
 
-		const flushHeaders = () => {
-			if (!headersFlushed) {
-				headersFlushed = true;
-				nodeRes.headersSent = true;
-				resolveResponse({ status: nodeRes.statusCode as number, headers: capturedHeaders, body: responseBody });
-			}
+		const onHandlerFailure = (error: Error) => {
+			if (!nodeRes.writableEnded) nodeRes.destroy(error);
+			else harperLogger.warn('withNodeAdapter handler failed after ending its response', error);
 		};
-
-		const applyHeaders = (hdrs: object | unknown[]) => {
-			if (Array.isArray(hdrs)) {
-				if (hdrs.length > 0 && Array.isArray(hdrs[0])) {
-					for (const [name, value] of hdrs as [string, string][]) capturedHeaders.set(name, value);
-				} else {
-					for (let i = 0; i < hdrs.length; i += 2) capturedHeaders.set(hdrs[i] as string, hdrs[i + 1] as string);
-				}
-			} else {
-				for (const [k, v] of Object.entries(hdrs)) capturedHeaders.set(k, v as string);
-			}
-		};
-
-		nodeRes = Object.assign(new EventEmitter(), {
-			statusCode: 200 as number,
-			statusMessage: '',
-			headersSent: false,
-			writable: true,
-			writableEnded: false,
-			writableFinished: false,
-			socket: this._nodeRequest.socket,
-
-			setHeader(name: string, value: string | number | string[]) {
-				if (Array.isArray(value)) {
-					// Use set() for first value (overwrites any existing entry) then append() for
-					// the rest so multiple values — critical for Set-Cookie — are preserved as an
-					// array rather than collapsed into a single comma-joined string.
-					if (value.length > 0) {
-						capturedHeaders.set(name, String(value[0]));
-						for (let i = 1; i < value.length; i++) capturedHeaders.append(name, String(value[i]));
-					}
-				} else {
-					capturedHeaders.set(name, String(value));
-				}
-				return nodeRes;
-			},
-			getHeader(name: string) {
-				return capturedHeaders.get(name);
-			},
-			getHeaders() {
-				return Object.fromEntries(capturedHeaders);
-			},
-			hasHeader(name: string) {
-				return capturedHeaders.has(name);
-			},
-			removeHeader(name: string) {
-				capturedHeaders.delete(name);
-			},
-			flushHeaders() {
-				flushHeaders();
-			},
-			writeHead(statusCode: number, statusMessageOrHeaders?: string | object, maybeHeaders?: object) {
-				if (headersFlushed) return nodeRes;
-				nodeRes.statusCode = statusCode;
-				const hdrs = typeof statusMessageOrHeaders === 'string' ? maybeHeaders : statusMessageOrHeaders;
-				if (hdrs) applyHeaders(hdrs as object | unknown[]);
-				flushHeaders();
-				return nodeRes;
-			},
-			write(
-				chunk: unknown,
-				encoding?: BufferEncoding | ((error?: Error | null) => void),
-				callback?: (error?: Error | null) => void
-			) {
-				flushHeaders();
-				if (typeof encoding === 'function') return responseBody.write(chunk as any, encoding);
-				return responseBody.write(chunk as any, encoding, callback);
-			},
-			end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void) {
-				flushHeaders();
-				nodeRes.writableEnded = true;
-				if (typeof chunk === 'function') responseBody.end(chunk as () => void);
-				else if (typeof encoding === 'function') responseBody.end(chunk as any, encoding);
-				else responseBody.end(chunk as any, encoding, callback);
-				return nodeRes;
-			},
-			destroy(error?: Error) {
-				if (!headersFlushed) {
-					if (error) rejectResponse(error);
-					else rejectResponse(new Error('Response destroyed before headers were sent'));
-					// The error has been forwarded to the response promise; suppress the
-					// PassThrough 'error' event for this one destroy call so Node doesn't
-					// throw due to having no other listeners.
-					responseBody.once('error', () => {});
-				}
-				responseBody.destroy(error);
-				return nodeRes;
-			},
-		}) as unknown as NodeServerResponse;
-
-		responseBody.on('finish', () => {
-			nodeRes.writableFinished = true;
-			(nodeRes as unknown as EventEmitter).emit('finish');
-		});
-		responseBody.on('drain', () => {
-			(nodeRes as unknown as EventEmitter).emit('drain');
-		});
-		responseBody.on('close', () => {
-			(nodeRes as unknown as EventEmitter).emit('close');
-		});
-
-		const handlerResult = handler(nodeReq, nodeRes);
-		if (handlerResult != null && typeof (handlerResult as unknown as Promise<void>).then === 'function') {
-			(handlerResult as unknown as Promise<void>).catch((err: unknown) => {
-				if (!headersFlushed) rejectResponse(err);
-			});
+		let handlerResult: void | Promise<void>;
+		try {
+			handlerResult = handler(nodeReq, nodeRes);
+		} catch (error) {
+			onHandlerFailure(error as Error);
+			return response;
+		}
+		if (typeof (handlerResult as Promise<void>)?.then === 'function') {
+			Promise.resolve(handlerResult).catch(onHandlerFailure);
 		}
 		return response;
 	}