@hono/node-server 2.0.8 → 2.0.10

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");
@@ -890,10 +1001,18 @@ const setupWebSocket = (options) => {
 			waiterMap.delete(request);
 		}
 	});
+	const rejectWaiter = (request) => {
+		const waiter = waiterMap.get(request);
+		if (waiter) {
+			waiterMap.delete(request);
+			waiter.reject(/* @__PURE__ */ new Error("WebSocket handshake aborted"));
+		}
+	};
 	const waitForWebSocket = (request, connectionSymbol) => {
-		return new Promise((resolve) => {
+		return new Promise((resolve, reject) => {
 			waiterMap.set(request, {
 				resolve,
+				reject,
 				connectionSymbol
 			});
 		});
@@ -920,16 +1039,19 @@ const setupWebSocket = (options) => {
 		}
 		const waiter = waiterMap.get(request);
 		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
-			waiterMap.delete(request);
+			rejectWaiter(request);
 			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status, responseHeaders);
 			return;
 		}
 		const addResponseHeaders = (headers) => {
 			appendResponseHeaders(headers, responseHeaders);
 		};
+		const reclaimWaiterOnClose = () => rejectWaiter(request);
+		socket.once("close", reclaimWaiterOnClose);
 		wss.on("headers", addResponseHeaders);
 		try {
 			wss.handleUpgrade(request, socket, head, (ws) => {
+				socket.off("close", reclaimWaiterOnClose);
 				wss.emit("connection", ws, request);
 			});
 		} finally {
@@ -948,7 +1070,12 @@ const upgradeWebSocket = (0, hono_ws.defineWebSocketHelper)(async (c, events, op
 	const connectionSymbol = generateConnectionSymbol();
 	env[CONNECTION_SYMBOL_KEY] = connectionSymbol;
 	(async () => {
-		const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		let ws;
+		try {
+			ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		} catch {
+			return;
+		}
 		const messagesReceivedInStarting = [];
 		const bufferMessage = (data, isBinary) => {
 			messagesReceivedInStarting.push([data, isBinary]);

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");
@@ -889,10 +1000,18 @@ const setupWebSocket = (options) => {
 			waiterMap.delete(request);
 		}
 	});
+	const rejectWaiter = (request) => {
+		const waiter = waiterMap.get(request);
+		if (waiter) {
+			waiterMap.delete(request);
+			waiter.reject(/* @__PURE__ */ new Error("WebSocket handshake aborted"));
+		}
+	};
 	const waitForWebSocket = (request, connectionSymbol) => {
-		return new Promise((resolve) => {
+		return new Promise((resolve, reject) => {
 			waiterMap.set(request, {
 				resolve,
+				reject,
 				connectionSymbol
 			});
 		});
@@ -919,16 +1038,19 @@ const setupWebSocket = (options) => {
 		}
 		const waiter = waiterMap.get(request);
 		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
-			waiterMap.delete(request);
+			rejectWaiter(request);
 			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status, responseHeaders);
 			return;
 		}
 		const addResponseHeaders = (headers) => {
 			appendResponseHeaders(headers, responseHeaders);
 		};
+		const reclaimWaiterOnClose = () => rejectWaiter(request);
+		socket.once("close", reclaimWaiterOnClose);
 		wss.on("headers", addResponseHeaders);
 		try {
 			wss.handleUpgrade(request, socket, head, (ws) => {
+				socket.off("close", reclaimWaiterOnClose);
 				wss.emit("connection", ws, request);
 			});
 		} finally {
@@ -947,7 +1069,12 @@ const upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
 	const connectionSymbol = generateConnectionSymbol();
 	env[CONNECTION_SYMBOL_KEY] = connectionSymbol;
 	(async () => {
-		const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		let ws;
+		try {
+			ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		} catch {
+			return;
+		}
 		const messagesReceivedInStarting = [];
 		const bufferMessage = (data, isBinary) => {
 			messagesReceivedInStarting.push([data, isBinary]);

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);
@@ -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);
@@ -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.8",
+  "version": "2.0.10",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.mjs",
   "type": "module",