@hono/node-server 2.0.6 → 2.0.9

package/README.md

@@ -41,16 +41,11 @@ It works on Node.js versions greater than 20.x.
 
 ## Installation
 
-You can install it from the npm registry with `npm` command:
+You can install it from the npm registry:
 
 ```sh
 npm install @hono/node-server
-```
-
-Or use `yarn`:
-
-```sh
-yarn add @hono/node-server
+pnpm add @hono/node-server
 ```
 
 ## Usage

package/dist/index.cjs

@@ -60,6 +60,54 @@ const newHeadersFromIncoming = (incoming) => {
 	return new Headers(headerRecord);
 };
 const wrapBodyStream = Symbol("wrapBodyStream");
+const byteExactEncodings = new Set([
+	"latin1",
+	"binary",
+	"hex",
+	"base64",
+	"base64url"
+]);
+const isByteExactEncoding = (encoding) => encoding === null || byteExactEncodings.has(encoding);
+const bodyBufferedBeforeDisconnectKey = Symbol("bodyBufferedBeforeDisconnect");
+const bodyBufferedLengthBeforeDisconnectKey = Symbol("bodyBufferedLengthBeforeDisconnect");
+const toBufferChunk = (chunk, encoding) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding ?? "utf8");
+const isRecoverableDisconnectedIncoming = (incoming) => !(incoming instanceof node_http2.Http2ServerRequest) && !!incoming.complete && !!incoming.readableAborted && typeof incoming.read === "function" && isByteExactEncoding(incoming.readableEncoding);
+const recordBodyBufferedBeforeDisconnect = (incoming) => {
+	if (incoming.readableDidRead || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] ??= incoming.readableLength;
+};
+const readBodyBufferedBeforeDisconnect = (incoming, chunks) => {
+	if (incoming.readableDidRead && !chunks || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	if (incomingWithRecovery[bodyBufferedBeforeDisconnectKey] !== void 0) return incomingWithRecovery[bodyBufferedBeforeDisconnectKey];
+	let result;
+	const errored = incoming.errored;
+	if (errored && errored.code !== "ECONNRESET") result = errored;
+	else if (incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] !== void 0 && incoming.readableLength !== incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey]) result = newBodyUnusableError();
+	else {
+		const bodyChunks = chunks ?? [];
+		const chunk = incoming.read();
+		if (chunk !== null) bodyChunks.push(toBufferChunk(chunk, incoming.readableEncoding));
+		const buffer = bodyChunks.length === 1 ? bodyChunks[0] : Buffer.concat(bodyChunks);
+		result = buffer;
+		const contentLength = incoming.headers["content-length"];
+		if (typeof contentLength === "string" && /^\d+$/.test(contentLength)) {
+			const expectedLength = Number(contentLength);
+			if (Number.isSafeInteger(expectedLength) && buffer.length !== expectedLength) result = newBodyUnusableError();
+		}
+	}
+	incomingWithRecovery[bodyBufferedBeforeDisconnectKey] = result;
+	return result;
+};
+const enqueueBufferedBody = (controller, buffered) => {
+	if (buffered instanceof Error) {
+		controller.error(buffered);
+		return;
+	}
+	if (buffered.length > 0) controller.enqueue(buffered);
+	controller.close();
+};
 const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
 	const init = {
 		method,
@@ -82,6 +130,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 		let reader;
 		init.body = new ReadableStream({ async pull(controller) {
 			try {
+				if (!reader) {
+					const buffered = readBodyBufferedBeforeDisconnect(incoming);
+					if (buffered !== void 0) {
+						enqueueBufferedBody(controller, buffered);
+						return;
+					}
+				}
 				reader ||= node_stream.Readable.toWeb(incoming).getReader();
 				const { done, value } = await reader.read();
 				if (done) controller.close();
@@ -90,7 +145,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 				controller.error(error);
 			}
 		} });
-	} else init.body = node_stream.Readable.toWeb(incoming);
+	} else {
+		const buffered = readBodyBufferedBeforeDisconnect(incoming);
+		if (buffered !== void 0) init.body = new ReadableStream({ start(controller) {
+			enqueueBufferedBody(controller, buffered);
+		} });
+		else init.body = node_stream.Readable.toWeb(incoming);
+	}
 	return new Request$1(url, init);
 };
 const getRequestCache = Symbol("getRequestCache");
@@ -178,11 +239,23 @@ const readRawBodyIfAvailable = (request) => {
 	const incoming = request[incomingKey];
 	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
 };
+const normalizeAbortError = (request, incoming) => {
+	if (incoming.errored) return incoming.errored;
+	const reason = request[abortReasonKey];
+	if (reason !== void 0) return reason instanceof Error ? reason : new Error(String(reason));
+	return /* @__PURE__ */ new Error("Client connection prematurely closed.");
+};
 const readBodyDirect = (request) => {
 	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
 	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
 	const incoming = request[incomingKey];
-	if (node_stream.Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	if (incoming.readableDidRead) return rejectBodyUnusable();
+	const buffered = readBodyBufferedBeforeDisconnect(incoming);
+	if (buffered !== void 0) {
+		if (buffered instanceof Error) return Promise.reject(buffered);
+		request[bodyBufferKey] = buffered;
+		return Promise.resolve(buffered);
+	}
 	const promise = new Promise((resolve, reject) => {
 		const chunks = [];
 		let settled = false;
@@ -192,8 +265,22 @@ const readBodyDirect = (request) => {
 			cleanup();
 			callback();
 		};
+		const recoverCompleteBodyAfterDisconnect = (error) => {
+			const streamError = incoming.errored ?? error;
+			if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
+			finish(() => {
+				const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
+				if (recovered instanceof Error) reject(recovered);
+				else if (recovered === void 0) reject(error ?? normalizeAbortError(request, incoming));
+				else {
+					request[bodyBufferKey] = recovered;
+					resolve(recovered);
+				}
+			});
+			return true;
+		};
 		const onData = (chunk) => {
-			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
 		};
 		const onEnd = () => {
 			finish(() => {
@@ -203,6 +290,7 @@ const readBodyDirect = (request) => {
 			});
 		};
 		const onError = (error) => {
+			if (recoverCompleteBodyAfterDisconnect(error)) return;
 			finish(() => {
 				reject(error);
 			});
@@ -212,17 +300,9 @@ const readBodyDirect = (request) => {
 				onEnd();
 				return;
 			}
+			if (recoverCompleteBodyAfterDisconnect()) return;
 			finish(() => {
-				if (incoming.errored) {
-					reject(incoming.errored);
-					return;
-				}
-				const reason = request[abortReasonKey];
-				if (reason !== void 0) {
-					reject(reason instanceof Error ? reason : new Error(String(reason)));
-					return;
-				}
-				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+				reject(normalizeAbortError(request, incoming));
 			});
 		};
 		const cleanup = () => {
@@ -617,8 +697,13 @@ const drainIncoming = (incoming) => {
 	incoming.resume();
 };
 const makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
-	if (incoming.errored) req[abortRequest](incoming.errored.toString());
-	else if (!outgoing.writableFinished) req[abortRequest]("Client connection prematurely closed.");
+	if (incoming.errored) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest](incoming.errored.toString());
+	} else if (!outgoing.writableFinished) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest]("Client connection prematurely closed.");
+	}
 	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
 		if (!incoming.readableEnded) setTimeout(() => {
 			drainIncoming(incoming);
@@ -839,6 +924,32 @@ const CloseEvent = globalThis.CloseEvent ?? class extends Event {
 		return this.#eventInitDict.reason ?? "";
 	}
 };
+/**
+* Node.js has no global `ErrorEvent`, unlike `Event`/`MessageEvent`/`CloseEvent`.
+* @link https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+*/
+const ErrorEvent = globalThis.ErrorEvent ?? class extends Event {
+	#eventInitDict;
+	constructor(type, eventInitDict = {}) {
+		super(type, eventInitDict);
+		this.#eventInitDict = eventInitDict;
+	}
+	get message() {
+		return this.#eventInitDict.message ?? "";
+	}
+	get filename() {
+		return this.#eventInitDict.filename ?? "";
+	}
+	get lineno() {
+		return this.#eventInitDict.lineno ?? 0;
+	}
+	get colno() {
+		return this.#eventInitDict.colno ?? 0;
+	}
+	get error() {
+		return this.#eventInitDict.error ?? null;
+	}
+};
 const generateConnectionSymbol = () => Symbol("connection");
 const CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
 const WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");

package/dist/index.mjs

@@ -59,6 +59,54 @@ const newHeadersFromIncoming = (incoming) => {
 	return new Headers(headerRecord);
 };
 const wrapBodyStream = Symbol("wrapBodyStream");
+const byteExactEncodings = new Set([
+	"latin1",
+	"binary",
+	"hex",
+	"base64",
+	"base64url"
+]);
+const isByteExactEncoding = (encoding) => encoding === null || byteExactEncodings.has(encoding);
+const bodyBufferedBeforeDisconnectKey = Symbol("bodyBufferedBeforeDisconnect");
+const bodyBufferedLengthBeforeDisconnectKey = Symbol("bodyBufferedLengthBeforeDisconnect");
+const toBufferChunk = (chunk, encoding) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding ?? "utf8");
+const isRecoverableDisconnectedIncoming = (incoming) => !(incoming instanceof Http2ServerRequest) && !!incoming.complete && !!incoming.readableAborted && typeof incoming.read === "function" && isByteExactEncoding(incoming.readableEncoding);
+const recordBodyBufferedBeforeDisconnect = (incoming) => {
+	if (incoming.readableDidRead || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] ??= incoming.readableLength;
+};
+const readBodyBufferedBeforeDisconnect = (incoming, chunks) => {
+	if (incoming.readableDidRead && !chunks || !isRecoverableDisconnectedIncoming(incoming)) return;
+	const incomingWithRecovery = incoming;
+	if (incomingWithRecovery[bodyBufferedBeforeDisconnectKey] !== void 0) return incomingWithRecovery[bodyBufferedBeforeDisconnectKey];
+	let result;
+	const errored = incoming.errored;
+	if (errored && errored.code !== "ECONNRESET") result = errored;
+	else if (incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey] !== void 0 && incoming.readableLength !== incomingWithRecovery[bodyBufferedLengthBeforeDisconnectKey]) result = newBodyUnusableError();
+	else {
+		const bodyChunks = chunks ?? [];
+		const chunk = incoming.read();
+		if (chunk !== null) bodyChunks.push(toBufferChunk(chunk, incoming.readableEncoding));
+		const buffer = bodyChunks.length === 1 ? bodyChunks[0] : Buffer.concat(bodyChunks);
+		result = buffer;
+		const contentLength = incoming.headers["content-length"];
+		if (typeof contentLength === "string" && /^\d+$/.test(contentLength)) {
+			const expectedLength = Number(contentLength);
+			if (Number.isSafeInteger(expectedLength) && buffer.length !== expectedLength) result = newBodyUnusableError();
+		}
+	}
+	incomingWithRecovery[bodyBufferedBeforeDisconnectKey] = result;
+	return result;
+};
+const enqueueBufferedBody = (controller, buffered) => {
+	if (buffered instanceof Error) {
+		controller.error(buffered);
+		return;
+	}
+	if (buffered.length > 0) controller.enqueue(buffered);
+	controller.close();
+};
 const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
 	const init = {
 		method,
@@ -81,6 +129,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 		let reader;
 		init.body = new ReadableStream({ async pull(controller) {
 			try {
+				if (!reader) {
+					const buffered = readBodyBufferedBeforeDisconnect(incoming);
+					if (buffered !== void 0) {
+						enqueueBufferedBody(controller, buffered);
+						return;
+					}
+				}
 				reader ||= Readable.toWeb(incoming).getReader();
 				const { done, value } = await reader.read();
 				if (done) controller.close();
@@ -89,7 +144,13 @@ const newRequestFromIncoming = (method, url, headers, incoming, abortController)
 				controller.error(error);
 			}
 		} });
-	} else init.body = Readable.toWeb(incoming);
+	} else {
+		const buffered = readBodyBufferedBeforeDisconnect(incoming);
+		if (buffered !== void 0) init.body = new ReadableStream({ start(controller) {
+			enqueueBufferedBody(controller, buffered);
+		} });
+		else init.body = Readable.toWeb(incoming);
+	}
 	return new Request$1(url, init);
 };
 const getRequestCache = Symbol("getRequestCache");
@@ -177,11 +238,23 @@ const readRawBodyIfAvailable = (request) => {
 	const incoming = request[incomingKey];
 	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
 };
+const normalizeAbortError = (request, incoming) => {
+	if (incoming.errored) return incoming.errored;
+	const reason = request[abortReasonKey];
+	if (reason !== void 0) return reason instanceof Error ? reason : new Error(String(reason));
+	return /* @__PURE__ */ new Error("Client connection prematurely closed.");
+};
 const readBodyDirect = (request) => {
 	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
 	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
 	const incoming = request[incomingKey];
-	if (Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	if (incoming.readableDidRead) return rejectBodyUnusable();
+	const buffered = readBodyBufferedBeforeDisconnect(incoming);
+	if (buffered !== void 0) {
+		if (buffered instanceof Error) return Promise.reject(buffered);
+		request[bodyBufferKey] = buffered;
+		return Promise.resolve(buffered);
+	}
 	const promise = new Promise((resolve, reject) => {
 		const chunks = [];
 		let settled = false;
@@ -191,8 +264,22 @@ const readBodyDirect = (request) => {
 			cleanup();
 			callback();
 		};
+		const recoverCompleteBodyAfterDisconnect = (error) => {
+			const streamError = incoming.errored ?? error;
+			if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
+			finish(() => {
+				const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
+				if (recovered instanceof Error) reject(recovered);
+				else if (recovered === void 0) reject(error ?? normalizeAbortError(request, incoming));
+				else {
+					request[bodyBufferKey] = recovered;
+					resolve(recovered);
+				}
+			});
+			return true;
+		};
 		const onData = (chunk) => {
-			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
 		};
 		const onEnd = () => {
 			finish(() => {
@@ -202,6 +289,7 @@ const readBodyDirect = (request) => {
 			});
 		};
 		const onError = (error) => {
+			if (recoverCompleteBodyAfterDisconnect(error)) return;
 			finish(() => {
 				reject(error);
 			});
@@ -211,17 +299,9 @@ const readBodyDirect = (request) => {
 				onEnd();
 				return;
 			}
+			if (recoverCompleteBodyAfterDisconnect()) return;
 			finish(() => {
-				if (incoming.errored) {
-					reject(incoming.errored);
-					return;
-				}
-				const reason = request[abortReasonKey];
-				if (reason !== void 0) {
-					reject(reason instanceof Error ? reason : new Error(String(reason)));
-					return;
-				}
-				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+				reject(normalizeAbortError(request, incoming));
 			});
 		};
 		const cleanup = () => {
@@ -616,8 +696,13 @@ const drainIncoming = (incoming) => {
 	incoming.resume();
 };
 const makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
-	if (incoming.errored) req[abortRequest](incoming.errored.toString());
-	else if (!outgoing.writableFinished) req[abortRequest]("Client connection prematurely closed.");
+	if (incoming.errored) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest](incoming.errored.toString());
+	} else if (!outgoing.writableFinished) {
+		recordBodyBufferedBeforeDisconnect(incoming);
+		req[abortRequest]("Client connection prematurely closed.");
+	}
 	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
 		if (!incoming.readableEnded) setTimeout(() => {
 			drainIncoming(incoming);
@@ -838,6 +923,32 @@ const CloseEvent = globalThis.CloseEvent ?? class extends Event {
 		return this.#eventInitDict.reason ?? "";
 	}
 };
+/**
+* Node.js has no global `ErrorEvent`, unlike `Event`/`MessageEvent`/`CloseEvent`.
+* @link https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+*/
+const ErrorEvent = globalThis.ErrorEvent ?? class extends Event {
+	#eventInitDict;
+	constructor(type, eventInitDict = {}) {
+		super(type, eventInitDict);
+		this.#eventInitDict = eventInitDict;
+	}
+	get message() {
+		return this.#eventInitDict.message ?? "";
+	}
+	get filename() {
+		return this.#eventInitDict.filename ?? "";
+	}
+	get lineno() {
+		return this.#eventInitDict.lineno ?? 0;
+	}
+	get colno() {
+		return this.#eventInitDict.colno ?? 0;
+	}
+	get error() {
+		return this.#eventInitDict.error ?? null;
+	}
+};
 const generateConnectionSymbol = () => Symbol("connection");
 const CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
 const WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");

package/dist/serve-static.cjs

@@ -19,6 +19,41 @@ const getStats = (path) => {
 	} catch {}
 	return stats;
 };
+const BYTE_RANGE_PATTERN = /^(?:bytes=)?(?!-$)(\d*)-(\d*)$/;
+const parseByteRange = (range) => {
+	const match = range.match(BYTE_RANGE_PATTERN);
+	if (!match) return;
+	const [, start, end] = match;
+	if (start === "") return {
+		type: "suffix",
+		length: Number(end)
+	};
+	if (end === "") return {
+		type: "open-ended",
+		start: Number(start)
+	};
+	return {
+		type: "bounded",
+		start: Number(start),
+		end: Number(end)
+	};
+};
+const resolveByteRange = (spec, size) => {
+	if (size === 0) return;
+	if (spec.type === "suffix") {
+		if (spec.length === 0) return;
+		return {
+			start: Math.max(size - spec.length, 0),
+			end: size - 1
+		};
+	}
+	const end = spec.type === "bounded" ? Math.min(spec.end, size - 1) : size - 1;
+	if (spec.start >= size || spec.start > end) return;
+	return {
+		start: spec.start,
+		end
+	};
+};
 const tryDecode = (str, decoder) => {
 	try {
 		return decoder(str);
@@ -61,7 +96,7 @@ const serveStatic = (options = { root: "" }) => {
 		}
 		const mimeType = (0, hono_utils_mime.getMimeType)(path);
 		c.header("Content-Type", mimeType || "application/octet-stream");
-		if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+		if (options.precompressed && (!mimeType || mimeType === "application/octet-stream" || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
 			const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
 			for (const encoding of ENCODINGS_ORDERED_KEYS) {
 				if (!acceptEncodingSet.has(encoding)) continue;
@@ -88,18 +123,24 @@ const serveStatic = (options = { root: "" }) => {
 			result = c.body(require_utils_stream.createStreamBody((0, node_fs.createReadStream)(path)), 200);
 		} else {
 			c.header("Accept-Ranges", "bytes");
-			const parts = range.replace(/bytes=/, "").split("-", 2);
-			const start = parseInt(parts[0], 10) || 0;
-			let end = parseInt(parts[1], 10) || size - 1;
-			if (size < end - start + 1) end = size - 1;
-			const chunksize = end - start + 1;
-			const stream = (0, node_fs.createReadStream)(path, {
-				start,
-				end
-			});
-			c.header("Content-Length", chunksize.toString());
-			c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-			result = c.body(require_utils_stream.createStreamBody(stream), 206);
+			const resolvedRange = resolveByteRange(parseByteRange(range) ?? {
+				type: "open-ended",
+				start: 0
+			}, size);
+			if (!resolvedRange) {
+				c.header("Content-Range", `bytes */${size}`);
+				result = c.body(null, 416);
+			} else {
+				const { start, end } = resolvedRange;
+				const chunkSize = end - start + 1;
+				const stream = (0, node_fs.createReadStream)(path, {
+					start,
+					end
+				});
+				c.header("Content-Length", chunkSize.toString());
+				c.header("Content-Range", `bytes ${start}-${end}/${size}`);
+				result = c.body(require_utils_stream.createStreamBody(stream), 206);
+			}
 		}
 		await options.onFound?.(path, c);
 		return result;

package/dist/serve-static.mjs

@@ -18,6 +18,41 @@ const getStats = (path) => {
 	} catch {}
 	return stats;
 };
+const BYTE_RANGE_PATTERN = /^(?:bytes=)?(?!-$)(\d*)-(\d*)$/;
+const parseByteRange = (range) => {
+	const match = range.match(BYTE_RANGE_PATTERN);
+	if (!match) return;
+	const [, start, end] = match;
+	if (start === "") return {
+		type: "suffix",
+		length: Number(end)
+	};
+	if (end === "") return {
+		type: "open-ended",
+		start: Number(start)
+	};
+	return {
+		type: "bounded",
+		start: Number(start),
+		end: Number(end)
+	};
+};
+const resolveByteRange = (spec, size) => {
+	if (size === 0) return;
+	if (spec.type === "suffix") {
+		if (spec.length === 0) return;
+		return {
+			start: Math.max(size - spec.length, 0),
+			end: size - 1
+		};
+	}
+	const end = spec.type === "bounded" ? Math.min(spec.end, size - 1) : size - 1;
+	if (spec.start >= size || spec.start > end) return;
+	return {
+		start: spec.start,
+		end
+	};
+};
 const tryDecode = (str, decoder) => {
 	try {
 		return decoder(str);
@@ -60,7 +95,7 @@ const serveStatic = (options = { root: "" }) => {
 		}
 		const mimeType = getMimeType(path);
 		c.header("Content-Type", mimeType || "application/octet-stream");
-		if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+		if (options.precompressed && (!mimeType || mimeType === "application/octet-stream" || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
 			const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
 			for (const encoding of ENCODINGS_ORDERED_KEYS) {
 				if (!acceptEncodingSet.has(encoding)) continue;
@@ -87,18 +122,24 @@ const serveStatic = (options = { root: "" }) => {
 			result = c.body(createStreamBody(createReadStream(path)), 200);
 		} else {
 			c.header("Accept-Ranges", "bytes");
-			const parts = range.replace(/bytes=/, "").split("-", 2);
-			const start = parseInt(parts[0], 10) || 0;
-			let end = parseInt(parts[1], 10) || size - 1;
-			if (size < end - start + 1) end = size - 1;
-			const chunksize = end - start + 1;
-			const stream = createReadStream(path, {
-				start,
-				end
-			});
-			c.header("Content-Length", chunksize.toString());
-			c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-			result = c.body(createStreamBody(stream), 206);
+			const resolvedRange = resolveByteRange(parseByteRange(range) ?? {
+				type: "open-ended",
+				start: 0
+			}, size);
+			if (!resolvedRange) {
+				c.header("Content-Range", `bytes */${size}`);
+				result = c.body(null, 416);
+			} else {
+				const { start, end } = resolvedRange;
+				const chunkSize = end - start + 1;
+				const stream = createReadStream(path, {
+					start,
+					end
+				});
+				c.header("Content-Length", chunkSize.toString());
+				c.header("Content-Range", `bytes ${start}-${end}/${size}`);
+				result = c.body(createStreamBody(stream), 206);
+			}
 		}
 		await options.onFound?.(path, c);
 		return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "2.0.6",
+  "version": "2.0.9",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.mjs",
   "type": "module",
@@ -66,18 +66,6 @@
       ]
     }
   },
-  "scripts": {
-    "test": "vitest",
-    "build": "tsdown --external hono",
-    "watch": "tsdown --watch",
-    "postbuild": "publint",
-    "prerelease": "bun run build && bun run test --run",
-    "release": "np --no-publish",
-    "lint": "eslint src test",
-    "lint:fix": "eslint src test --fix",
-    "format": "prettier --check \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
-    "format:fix": "prettier --write \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\""
-  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -87,7 +75,8 @@
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "engines": {
     "node": ">=20"
@@ -103,7 +92,7 @@
     "np": "^11.2.1",
     "prettier": "^3.2.4",
     "publint": "^0.3.18",
-    "supertest": "^6.3.3",
+    "supertest": "^7.2.2",
     "tsdown": "^0.20.3",
     "typescript": "^5.3.2",
     "vitest": "^4.0.18",
@@ -112,5 +101,16 @@
   "peerDependencies": {
     "hono": "^4"
   },
-  "packageManager": "bun@1.2.20"
-}
+  "scripts": {
+    "test": "vitest",
+    "build": "tsdown --external hono",
+    "watch": "tsdown --watch",
+    "postbuild": "publint",
+    "prerelease": "pnpm run build && pnpm run test --run",
+    "release": "np --no-publish",
+    "lint": "eslint src test",
+    "lint:fix": "eslint src test --fix",
+    "format": "prettier --check \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
+    "format:fix": "prettier --write \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\""
+  }
+}