@orkestrel/middleware 0.0.5 → 0.0.6

package/dist/src/server/index.js

@@ -1,13 +1,13 @@
 import { createReadStream } from "node:fs";
 import { chmod, copyFile, mkdtemp, open, readFile, realpath, rename, stat, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { extname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+import { deflate, gzip } from "node:zlib";
 import { isFiniteNumber, isFunction, isRecord, isString } from "@orkestrel/contract";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
 import { HTTPError, isDangerousKey, matchesETag, parseRange } from "@orkestrel/server";
 import { DEFAULT_COMPRESSION_THRESHOLD, compressResponse } from "../core/index.js";
-import { deflate, gzip } from "node:zlib";
-import { promisify } from "node:util";
 //#region src/server/constants.ts
 /** The HTTP status `createMultipart` renders for each {@link MultipartReason}. */
 var MULTIPART_REASON_STATUS = Object.freeze({
@@ -114,7 +114,7 @@ var MultipartError = class extends Error {
 		super(message);
 		this.status = MULTIPART_REASON_STATUS[reason];
 		this.reason = reason;
-		this.context = context;
+		if (context !== void 0) this.context = context;
 		Object.defineProperty(this, Symbol.for("@orkestrel/middleware.MultipartError"), { value: true });
 	}
 };
@@ -150,6 +150,210 @@ function isMultipartError(value) {
 	return true;
 }
 //#endregion
+//#region src/server/MultipartParser.ts
+var MultipartParser = class MultipartParser {
+	static #defaultDirectory;
+	#reader;
+	#signal;
+	#abort;
+	#boundary;
+	#limits;
+	#allowed;
+	#directory;
+	#staged = [];
+	#files = Object.create(null);
+	#fields = Object.create(null);
+	#buffer = Buffer.alloc(0);
+	#ended = false;
+	#fileCount = 0;
+	#fieldCount = 0;
+	#totalBytes = 0;
+	constructor(stream, signal, boundary, limits, allowed, directory) {
+		this.#reader = stream.getReader();
+		this.#signal = signal;
+		this.#abort = this.#wakeReader.bind(this);
+		this.#boundary = boundary;
+		this.#limits = limits;
+		this.#allowed = allowed;
+		this.#directory = directory;
+	}
+	static directory() {
+		if (MultipartParser.#defaultDirectory === void 0) MultipartParser.#defaultDirectory = MultipartParser.#createDirectory();
+		return MultipartParser.#defaultDirectory;
+	}
+	async parse() {
+		this.#signal.addEventListener("abort", this.#abort, { once: true });
+		try {
+			const openMarker = Buffer.from(`--${this.#boundary}`);
+			let preambleScanned = 0;
+			let index = this.#buffer.indexOf(openMarker);
+			while (index === -1) {
+				const carry = openMarker.length - 1;
+				if (this.#buffer.length > carry) {
+					const drop = this.#buffer.length - carry;
+					preambleScanned += drop;
+					if (preambleScanned > 65536) throw new MultipartError("malformed", "multipart preamble too large");
+					this.#buffer = this.#buffer.subarray(drop);
+				}
+				if (!await this.#pull()) throw new MultipartError("malformed", "missing multipart boundary");
+				index = this.#buffer.indexOf(openMarker);
+			}
+			if (preambleScanned + index > 65536) throw new MultipartError("malformed", "multipart preamble too large");
+			this.#buffer = this.#buffer.subarray(index + openMarker.length);
+			for (;;) {
+				while (this.#buffer.length < 2) if (!await this.#pull()) throw new MultipartError("malformed", "unterminated multipart boundary");
+				if (this.#buffer[0] === 45 && this.#buffer[1] === 45) break;
+				if (this.#buffer[0] !== 13 || this.#buffer[1] !== 10) throw new MultipartError("malformed", "malformed multipart boundary");
+				this.#buffer = this.#buffer.subarray(2);
+				let headerEnd = this.#buffer.indexOf("\r\n\r\n");
+				while (headerEnd === -1) {
+					if (this.#buffer.length > 16384) throw new MultipartError("malformed", "multipart header block too large");
+					if (!await this.#pull()) throw new MultipartError("malformed", "unterminated multipart part headers");
+					headerEnd = this.#buffer.indexOf("\r\n\r\n");
+				}
+				if (headerEnd > 16384) throw new MultipartError("malformed", "multipart header block too large");
+				const headerBlock = this.#buffer.subarray(0, headerEnd).toString("utf8");
+				this.#buffer = this.#buffer.subarray(headerEnd + 4);
+				const { name, filename, contentType } = parsePartHeaders(headerBlock);
+				if (name === void 0) throw new MultipartError("malformed", "multipart part missing name");
+				const partDelimiter = Buffer.from(`\r\n--${this.#boundary}`);
+				if (filename !== void 0) {
+					if (filename !== "") {
+						this.#fileCount += 1;
+						if (this.#fileCount > this.#limits.files) throw new MultipartError("limit", "too many multipart files");
+					}
+					const path = join(this.#directory, randomUUID());
+					this.#staged.push(path);
+					const handle = await open(path, "w", 384);
+					let size = 0;
+					let head = Buffer.alloc(0);
+					try {
+						for (;;) {
+							const boundaryIndex = this.#buffer.indexOf(partDelimiter);
+							if (boundaryIndex === -1) {
+								const safeLength = Math.max(0, this.#buffer.length - (partDelimiter.length - 1));
+								if (safeLength > 0) {
+									const chunk = this.#buffer.subarray(0, safeLength);
+									size += chunk.length;
+									if (size > this.#limits.file) throw new MultipartError("limit", "multipart file exceeds size limit");
+									if (head.length < 16) head = Buffer.concat([head, chunk.subarray(0, 16 - head.length)]);
+									await handle.write(chunk);
+									this.#buffer = this.#buffer.subarray(safeLength);
+								}
+								if (!await this.#pull()) throw new MultipartError("malformed", "unterminated multipart file part");
+								continue;
+							}
+							const chunk = this.#buffer.subarray(0, boundaryIndex);
+							size += chunk.length;
+							if (size > this.#limits.file) throw new MultipartError("limit", "multipart file exceeds size limit");
+							if (head.length < 16) head = Buffer.concat([head, chunk.subarray(0, 16 - head.length)]);
+							await handle.write(chunk);
+							this.#buffer = this.#buffer.subarray(boundaryIndex + 2);
+							break;
+						}
+					} finally {
+						await handle.close();
+					}
+					if (filename === "" && size === 0) {
+						await unlink(path);
+						this.#staged.splice(this.#staged.indexOf(path), 1);
+					} else {
+						if (filename === "") {
+							this.#fileCount += 1;
+							if (this.#fileCount > this.#limits.files) throw new MultipartError("limit", "too many multipart files");
+						}
+						const detected = detectMIME(head);
+						const declared = contentType ?? "application/octet-stream";
+						const validated = detected !== void 0 && detected === declared;
+						if (this.#allowed !== void 0) {
+							if (!(detected !== void 0 && this.#allowed.includes(detected))) throw new MultipartError("rejected", "multipart file failed type validation");
+						}
+						if (isDangerousKey(name)) {
+							await unlink(path);
+							this.#staged.splice(this.#staged.indexOf(path), 1);
+						} else {
+							const record = createUploadedFile({
+								field: name,
+								name: filename,
+								size,
+								mime: detected ?? declared,
+								validated,
+								status: "staged",
+								path
+							});
+							const existing = this.#files[name];
+							if (existing === void 0) this.#files[name] = [record];
+							else existing.push(record);
+						}
+					}
+				} else {
+					this.#fieldCount += 1;
+					if (this.#fieldCount > this.#limits.fields) throw new MultipartError("limit", "too many multipart fields");
+					let value = Buffer.alloc(0);
+					for (;;) {
+						const boundaryIndex = this.#buffer.indexOf(partDelimiter);
+						if (boundaryIndex === -1) {
+							const safeLength = Math.max(0, this.#buffer.length - (partDelimiter.length - 1));
+							if (safeLength > 0) {
+								value = Buffer.concat([value, this.#buffer.subarray(0, safeLength)]);
+								if (value.length > this.#limits.field) throw new MultipartError("limit", "multipart field exceeds size limit");
+								this.#buffer = this.#buffer.subarray(safeLength);
+							}
+							if (!await this.#pull()) throw new MultipartError("malformed", "unterminated multipart field part");
+							continue;
+						}
+						value = Buffer.concat([value, this.#buffer.subarray(0, boundaryIndex)]);
+						if (value.length > this.#limits.field) throw new MultipartError("limit", "multipart field exceeds size limit");
+						this.#buffer = this.#buffer.subarray(boundaryIndex + 2);
+						break;
+					}
+					if (!isDangerousKey(name)) this.#fields[name] = value.toString("utf8");
+				}
+				while (this.#buffer.length < openMarker.length) if (!await this.#pull()) throw new MultipartError("malformed", "unterminated multipart boundary");
+				this.#buffer = this.#buffer.subarray(openMarker.length);
+			}
+		} catch (error) {
+			await this.#cleanup();
+			await this.#reader.cancel().catch(() => {});
+			throw error;
+		} finally {
+			this.#signal.removeEventListener("abort", this.#abort);
+			if (!this.#ended) await this.#reader.cancel().catch(() => {});
+		}
+		return {
+			files: Object.freeze(this.#files),
+			fields: Object.freeze(this.#fields)
+		};
+	}
+	static async #createDirectory() {
+		const path = await mkdtemp(join(tmpdir(), "orkestrel-multipart-"));
+		await chmod(path, 448);
+		return path;
+	}
+	async #cleanup() {
+		for (const path of this.#staged) try {
+			await unlink(path);
+		} catch {}
+	}
+	async #pull() {
+		if (this.#signal.aborted) throw new MultipartError("malformed", "request aborted mid-upload");
+		if (this.#ended) return false;
+		const { done, value } = await this.#reader.read();
+		if (this.#signal.aborted) throw new MultipartError("malformed", "request aborted mid-upload");
+		if (done) {
+			this.#ended = true;
+			return false;
+		}
+		this.#totalBytes += value.byteLength;
+		if (this.#totalBytes > this.#limits.total) throw new MultipartError("limit", "multipart body exceeds total limit");
+		this.#buffer = Buffer.concat([this.#buffer, Buffer.from(value.buffer, value.byteOffset, value.byteLength)]);
+		return true;
+	}
+	#wakeReader() {
+		this.#reader.cancel().catch(() => {});
+	}
+};
+//#endregion
 //#region src/server/helpers.ts
 /**
 * Whether `pathname` is `prefix` itself or lies under it on a SEGMENT
@@ -173,6 +377,31 @@ function isUnderPath(pathname, prefix) {
 	return pathname.startsWith(boundary);
 }
 /**
+* Resolve the fixed SPA shell path when a static-file miss is eligible for
+* fallback.
+*
+* @param root - The configured static root
+* @param index - The configured shell filename
+* @param exclude - The URL prefix excluded from fallback
+* @param method - The request method
+* @param pathname - The request pathname
+* @param accept - The request's `Accept` header value
+* @returns The fixed shell path, or `undefined` when fallback is ineligible
+*
+* @example
+* ```ts
+* resolveStaticFallbackPath('/srv/public', 'index.html', '/api', 'GET', '/dashboard', 'text/html')
+* // '/srv/public/index.html'
+* ```
+*/
+function resolveStaticFallbackPath(root, index, exclude, method, pathname, accept) {
+	if (method !== "GET") return void 0;
+	if (extname(pathname) !== "") return void 0;
+	if (!accept.includes("text/html") && !accept.includes("*/*")) return void 0;
+	if (isUnderPath(pathname, exclude)) return void 0;
+	return join(root, index);
+}
+/**
 * Whether `child` is `parent` itself or lies inside it on-disk — the
 * FILESYSTEM containment predicate `createStatic` applies to `fs.realpath`
 * output (never to a URL pathname — that is {@link isUnderPath}'s job).
@@ -312,6 +541,23 @@ function computeFileETag(size, mtimeMs) {
 	return `W/"${size}-${Math.floor(mtimeMs)}"`;
 }
 /**
+* Compress response bytes with Node's guaranteed zlib gzip/deflate codecs.
+*
+* @param bytes - The uncompressed response bytes
+* @param encoding - The negotiated actionable coding
+* @returns The compressed bytes
+*
+* @example
+* ```ts
+* const bytes = new TextEncoder().encode('compress me')
+* const compressed = await compressNodeBytes(bytes, 'deflate')
+* ```
+*/
+async function compressNodeBytes(bytes, encoding) {
+	const compressed = encoding === "gzip" ? await promisify(gzip)(bytes) : await promisify(deflate)(bytes);
+	return Uint8Array.from(compressed);
+}
+/**
 * Sniff a MIME type from a file's leading bytes against a small magic-byte
 * table (jpeg, png, gif87a/89a, webp, pdf, zip) — the SNIFF-AUTHORITATIVE
 * signal `createMultipart`'s type validation rests on, never the declared
@@ -326,17 +572,12 @@ function computeFileETag(size, mtimeMs) {
 * ```
 */
 function detectMIME(head) {
-	function matches(signature, offset = 0) {
-		if (head.length < offset + signature.length) return false;
-		for (let index = 0; index < signature.length; index += 1) if (head[offset + index] !== signature[index]) return false;
-		return true;
-	}
-	if (matches([
+	if (matchesBytes(head, [
 		255,
 		216,
 		255
 	])) return "image/jpeg";
-	if (matches([
+	if (matchesBytes(head, [
 		137,
 		80,
 		78,
@@ -346,7 +587,7 @@ function detectMIME(head) {
 		26,
 		10
 	])) return "image/png";
-	if (matches([
+	if (matchesBytes(head, [
 		71,
 		73,
 		70,
@@ -354,7 +595,7 @@ function detectMIME(head) {
 		55,
 		97
 	])) return "image/gif";
-	if (matches([
+	if (matchesBytes(head, [
 		71,
 		73,
 		70,
@@ -362,35 +603,35 @@ function detectMIME(head) {
 		57,
 		97
 	])) return "image/gif";
-	if (matches([
+	if (matchesBytes(head, [
 		82,
 		73,
 		70,
 		70
-	]) && matches([
+	]) && matchesBytes(head, [
 		87,
 		69,
 		66,
 		80
 	], 8)) return "image/webp";
-	if (matches([
+	if (matchesBytes(head, [
 		37,
 		80,
 		68,
 		70,
 		45
 	])) return "application/pdf";
-	if (matches([
+	if (matchesBytes(head, [
 		80,
 		75,
 		3,
 		4
-	]) || matches([
+	]) || matchesBytes(head, [
 		80,
 		75,
 		5,
 		6
-	]) || matches([
+	]) || matchesBytes(head, [
 		80,
 		75,
 		7,
@@ -398,6 +639,24 @@ function detectMIME(head) {
 	])) return "application/zip";
 }
 /**
+* Whether `bytes` contains `signature` at the requested offset.
+*
+* @param bytes - The bytes to inspect
+* @param signature - The exact byte sequence to match
+* @param offset - The starting byte offset, defaulting to zero
+* @returns `true` when the complete signature matches
+*
+* @example
+* ```ts
+* matchesBytes(Uint8Array.from([0, 0x50, 0x4b]), [0x50, 0x4b], 1) // true
+* ```
+*/
+function matchesBytes(bytes, signature, offset = 0) {
+	if (bytes.length < offset + signature.length) return false;
+	for (let index = 0; index < signature.length; index += 1) if (bytes[offset + index] !== signature[index]) return false;
+	return true;
+}
+/**
 * Extract the `boundary` parameter from a `Content-Type` header, or
 * `undefined` when the request is not `multipart/form-data`.
 *
@@ -441,11 +700,6 @@ function resolveMultipartLimits(limits) {
 	};
 }
 /**
-* Memoized `Promise` for `parseMultipartRequest`'s lazily-created default
-* staging directory — created once per process via {@link resolveDefaultDirectory}.
-*/
-var defaultDirectory;
-/**
 * Resolve `parseMultipartRequest`'s default staging directory when the
 * caller did not configure one — a process-owned directory created ONCE
 * (lazily, memoized across calls) via `mkdtemp` under `os.tmpdir()` and
@@ -459,12 +713,7 @@ var defaultDirectory;
 * ```
 */
 function resolveDefaultDirectory() {
-	if (defaultDirectory === void 0) defaultDirectory = (async () => {
-		const path = await mkdtemp(join(tmpdir(), "orkestrel-multipart-"));
-		await chmod(path, 448);
-		return path;
-	})();
-	return defaultDirectory;
+	return MultipartParser.directory();
 }
 /**
 * Parse one multipart part's raw header block into its `name` (from
@@ -551,177 +800,7 @@ async function parseMultipartRequest(request, options = {}) {
 	const limits = resolveMultipartLimits(options.limits);
 	const allowed = options.allowed;
 	const directory = options.directory ?? await resolveDefaultDirectory();
-	const staged = [];
-	const files = Object.create(null);
-	const fields = Object.create(null);
-	let fileCount = 0;
-	let fieldCount = 0;
-	let totalBytes = 0;
-	let aborted = false;
-	async function cleanup() {
-		for (const path of staged) try {
-			await unlink(path);
-		} catch {}
-	}
-	const reader = request.body.getReader();
-	let buffer = Buffer.alloc(0);
-	let ended = false;
-	const onAbort = () => {
-		aborted = true;
-	};
-	request.signal.addEventListener("abort", onAbort);
-	async function pull() {
-		if (aborted || request.signal.aborted) throw new MultipartError("malformed", "request aborted mid-upload");
-		if (ended) return false;
-		const { done, value } = await reader.read();
-		if (done) {
-			ended = true;
-			return false;
-		}
-		totalBytes += value.byteLength;
-		if (totalBytes > limits.total) throw new MultipartError("limit", "multipart body exceeds total limit");
-		buffer = Buffer.concat([buffer, Buffer.from(value.buffer, value.byteOffset, value.byteLength)]);
-		return true;
-	}
-	try {
-		const openMarker = Buffer.from(`--${boundary}`);
-		let preambleScanned = 0;
-		let index = buffer.indexOf(openMarker);
-		while (index === -1) {
-			const carry = openMarker.length - 1;
-			if (buffer.length > carry) {
-				const drop = buffer.length - carry;
-				preambleScanned += drop;
-				if (preambleScanned > 65536) throw new MultipartError("malformed", "multipart preamble too large");
-				buffer = buffer.subarray(drop);
-			}
-			if (!await pull()) throw new MultipartError("malformed", "missing multipart boundary");
-			index = buffer.indexOf(openMarker);
-		}
-		buffer = buffer.subarray(index + openMarker.length);
-		for (;;) {
-			while (buffer.length < 2) if (!await pull()) throw new MultipartError("malformed", "unterminated multipart boundary");
-			if (buffer[0] === 45 && buffer[1] === 45) break;
-			if (buffer[0] !== 13 || buffer[1] !== 10) throw new MultipartError("malformed", "malformed multipart boundary");
-			buffer = buffer.subarray(2);
-			let headerEnd = buffer.indexOf("\r\n\r\n");
-			while (headerEnd === -1) {
-				if (buffer.length > 16384) throw new MultipartError("malformed", "multipart header block too large");
-				if (!await pull()) throw new MultipartError("malformed", "unterminated multipart part headers");
-				headerEnd = buffer.indexOf("\r\n\r\n");
-			}
-			const headerBlock = buffer.subarray(0, headerEnd).toString("utf8");
-			buffer = buffer.subarray(headerEnd + 4);
-			const { name, filename, contentType } = parsePartHeaders(headerBlock);
-			if (name === void 0) throw new MultipartError("malformed", "multipart part missing name");
-			const partDelimiter = Buffer.from(`\r\n--${boundary}`);
-			if (filename !== void 0) {
-				if (filename !== "") {
-					fileCount += 1;
-					if (fileCount > limits.files) throw new MultipartError("limit", "too many multipart files");
-				}
-				const path = join(directory, randomUUID());
-				staged.push(path);
-				const handle = await open(path, "w", 384);
-				let size = 0;
-				let head = Buffer.alloc(0);
-				try {
-					for (;;) {
-						const boundaryIndex = buffer.indexOf(partDelimiter);
-						if (boundaryIndex === -1) {
-							const safeLength = Math.max(0, buffer.length - (partDelimiter.length - 1));
-							if (safeLength > 0) {
-								const chunk = buffer.subarray(0, safeLength);
-								size += chunk.length;
-								if (size > limits.file) throw new MultipartError("limit", "multipart file exceeds size limit");
-								if (head.length < 16) head = Buffer.concat([head, chunk.subarray(0, 16 - head.length)]);
-								await handle.write(chunk);
-								buffer = buffer.subarray(safeLength);
-							}
-							if (!await pull()) throw new MultipartError("malformed", "unterminated multipart file part");
-							continue;
-						}
-						const chunk = buffer.subarray(0, boundaryIndex);
-						size += chunk.length;
-						if (size > limits.file) throw new MultipartError("limit", "multipart file exceeds size limit");
-						if (head.length < 16) head = Buffer.concat([head, chunk.subarray(0, 16 - head.length)]);
-						await handle.write(chunk);
-						buffer = buffer.subarray(boundaryIndex + 2);
-						break;
-					}
-				} finally {
-					await handle.close();
-				}
-				if (filename === "" && size === 0) {
-					await unlink(path);
-					staged.splice(staged.indexOf(path), 1);
-				} else {
-					if (filename === "") {
-						fileCount += 1;
-						if (fileCount > limits.files) throw new MultipartError("limit", "too many multipart files");
-					}
-					const detected = detectMIME(head);
-					const declared = contentType ?? "application/octet-stream";
-					const validated = detected !== void 0 && detected === declared;
-					if (allowed !== void 0) {
-						if (!(detected !== void 0 && allowed.includes(detected))) throw new MultipartError("rejected", "multipart file failed type validation");
-					}
-					if (isDangerousKey(name)) {
-						await unlink(path);
-						staged.splice(staged.indexOf(path), 1);
-					} else {
-						const record = createUploadedFile({
-							field: name,
-							name: filename,
-							size,
-							mime: detected ?? declared,
-							validated,
-							status: "staged",
-							path
-						});
-						const existing = files[name];
-						if (existing === void 0) files[name] = [record];
-						else existing.push(record);
-					}
-				}
-			} else {
-				fieldCount += 1;
-				if (fieldCount > limits.fields) throw new MultipartError("limit", "too many multipart fields");
-				let value = Buffer.alloc(0);
-				for (;;) {
-					const boundaryIndex = buffer.indexOf(partDelimiter);
-					if (boundaryIndex === -1) {
-						const safeLength = Math.max(0, buffer.length - (partDelimiter.length - 1));
-						if (safeLength > 0) {
-							value = Buffer.concat([value, buffer.subarray(0, safeLength)]);
-							if (value.length > limits.field) throw new MultipartError("limit", "multipart field exceeds size limit");
-							buffer = buffer.subarray(safeLength);
-						}
-						if (!await pull()) throw new MultipartError("malformed", "unterminated multipart field part");
-						continue;
-					}
-					value = Buffer.concat([value, buffer.subarray(0, boundaryIndex)]);
-					if (value.length > limits.field) throw new MultipartError("limit", "multipart field exceeds size limit");
-					buffer = buffer.subarray(boundaryIndex + 2);
-					break;
-				}
-				if (!isDangerousKey(name)) fields[name] = value.toString("utf8");
-			}
-			while (buffer.length < openMarker.length) if (!await pull()) throw new MultipartError("malformed", "unterminated multipart boundary");
-			buffer = buffer.subarray(openMarker.length);
-		}
-	} catch (error) {
-		await cleanup();
-		await reader.cancel().catch(() => {});
-		throw error;
-	} finally {
-		request.signal.removeEventListener("abort", onAbort);
-		if (!ended) await reader.cancel().catch(() => {});
-	}
-	return {
-		files: Object.freeze(files),
-		fields: Object.freeze(fields)
-	};
+	return new MultipartParser(request.body, request.signal, boundary, limits, allowed, directory).parse();
 }
 /**
 * Build a frozen {@link UploadedFileInterface} record.
@@ -934,10 +1013,6 @@ function createStatic(options) {
 	const useETag = options.etag ?? true;
 	const fallback = options.fallback === true ? { exclude: DEFAULT_STATIC_FALLBACK_EXCLUDE } : options.fallback === false || options.fallback === void 0 ? void 0 : { exclude: options.fallback.exclude ?? "/api" };
 	let canonicalRootPromise;
-	function canonicalRoot() {
-		if (canonicalRootPromise === void 0) canonicalRootPromise = realpath(root);
-		return canonicalRootPromise;
-	}
 	return async (request, context, next) => {
 		if (context.method !== "GET" && context.method !== "HEAD") return next();
 		const target = resolveStaticPath(root, options.prefix, context.url.pathname);
@@ -947,47 +1022,83 @@ function createStatic(options) {
 			if (dotfiles === "deny") throw new HTTPError(403, "forbidden");
 			if (dotfiles === "ignore") return next();
 		}
-		let resolvedPath;
+		let resolvedPath = target;
+		let fallbackNeeded = false;
 		try {
-			const [rootReal, targetReal] = await Promise.all([canonicalRoot(), realpath(target)]);
+			if (canonicalRootPromise === void 0) canonicalRootPromise = realpath(root);
+			const [rootReal, targetReal] = await Promise.all([canonicalRootPromise, realpath(target)]);
 			if (!isContainedPath(targetReal, rootReal)) return next();
 			resolvedPath = targetReal;
 		} catch {
-			return trySpaFallback();
+			fallbackNeeded = true;
 		}
 		let directoryInfo;
-		try {
+		if (!fallbackNeeded) try {
 			directoryInfo = await stat(resolvedPath);
 		} catch {
-			return trySpaFallback();
+			fallbackNeeded = true;
 		}
-		if (directoryInfo.isDirectory()) {
+		if (directoryInfo?.isDirectory()) {
 			resolvedPath = join(resolvedPath, index);
 			try {
-				const [rootReal, indexReal] = await Promise.all([canonicalRoot(), realpath(resolvedPath)]);
-				if (!isContainedPath(indexReal, rootReal)) return trySpaFallback();
-				resolvedPath = indexReal;
+				if (canonicalRootPromise === void 0) canonicalRootPromise = realpath(root);
+				const [rootReal, indexReal] = await Promise.all([canonicalRootPromise, realpath(resolvedPath)]);
+				if (isContainedPath(indexReal, rootReal)) resolvedPath = indexReal;
+				else fallbackNeeded = true;
 			} catch {
-				return trySpaFallback();
+				fallbackNeeded = true;
 			}
 		}
 		let handle;
-		try {
+		let info;
+		if (!fallbackNeeded) try {
 			handle = await open(resolvedPath, "r");
 		} catch {
-			return trySpaFallback();
+			fallbackNeeded = true;
 		}
-		let info;
-		try {
+		if (handle !== void 0) try {
 			info = await handle.stat();
 		} catch {
 			await handle.close();
-			return trySpaFallback();
+			handle = void 0;
+			fallbackNeeded = true;
 		}
-		if (!info.isFile()) {
+		if (handle !== void 0 && info !== void 0 && !info.isFile()) {
 			await handle.close();
-			return trySpaFallback();
+			handle = void 0;
+			info = void 0;
+			fallbackNeeded = true;
+		}
+		if (fallbackNeeded) {
+			const shellPath = resolveStaticFallbackPath(root, index, fallback?.exclude ?? "/api", context.method, context.url.pathname, request.headers.get("accept") ?? "");
+			if (fallback === void 0 || shellPath === void 0) return next();
+			let shellReal;
+			try {
+				if (canonicalRootPromise === void 0) canonicalRootPromise = realpath(root);
+				const [rootReal, candidate] = await Promise.all([canonicalRootPromise, realpath(shellPath)]);
+				if (!isContainedPath(candidate, rootReal)) return next();
+				shellReal = candidate;
+			} catch {
+				return next();
+			}
+			let shellHandle;
+			try {
+				shellHandle = await open(shellReal, "r");
+			} catch {
+				return next();
+			}
+			try {
+				const body = streamFile(shellHandle);
+				return new Response(body, {
+					status: 200,
+					headers: new Headers({ "content-type": lookupContentType(shellReal) })
+				});
+			} catch (error) {
+				await shellHandle.close().catch(() => {});
+				throw error;
+			}
 		}
+		if (handle === void 0 || info === void 0) return next();
 		let streaming = false;
 		try {
 			const headers = new Headers({
@@ -1049,32 +1160,6 @@ function createStatic(options) {
 			if (!streaming) await handle.close().catch(() => {});
 			throw error;
 		}
-		function trySpaFallback() {
-			if (fallback === void 0) return next();
-			if (context.method !== "GET") return next();
-			if (extname(context.url.pathname) !== "") return next();
-			const accept = request.headers.get("accept") ?? "";
-			if (!accept.includes("text/html") && !accept.includes("*/*")) return next();
-			if (isUnderPath(context.url.pathname, fallback.exclude)) return next();
-			const shellPath = join(root, index);
-			return Promise.all([canonicalRoot(), realpath(shellPath)]).then(([rootReal, shellReal]) => {
-				if (!isContainedPath(shellReal, rootReal)) return next();
-				return open(shellReal, "r").then((shellHandle) => {
-					let shellStreaming = false;
-					try {
-						const body = streamFile(shellHandle);
-						shellStreaming = true;
-						return new Response(body, {
-							status: 200,
-							headers: new Headers({ "content-type": lookupContentType(shellReal) })
-						});
-					} catch (error) {
-						if (!shellStreaming) shellHandle.close().catch(() => {});
-						throw error;
-					}
-				});
-			}).catch(() => next());
-		}
 	};
 }
 /**
@@ -1118,7 +1203,7 @@ function createMultipart(options = {}) {
 			throw error;
 		}
 		if (body === void 0) return next();
-		context.state.multipart = body;
+		Object.assign(context.state, { multipart: body });
 		try {
 			return await next();
 		} catch (error) {
@@ -1163,18 +1248,16 @@ function createCompression(options) {
 	const threshold = options?.threshold ?? DEFAULT_COMPRESSION_THRESHOLD;
 	const filter = options?.filter;
 	const encodings = ["gzip", "deflate"];
-	const gzipAsync = promisify(gzip);
-	const deflateAsync = promisify(deflate);
 	return async (request, context, next) => {
 		return compressResponse(request, context, await next(), {
 			threshold,
-			filter,
+			...filter !== void 0 ? { filter } : {},
 			encodings,
-			compress: async (bytes, encoding) => encoding === "gzip" ? gzipAsync(bytes) : deflateAsync(bytes)
+			compress: compressNodeBytes
 		});
 	};
 }
 //#endregion
-export { DEFAULT_CONTENT_TYPE, DEFAULT_MULTIPART_FIELD, DEFAULT_MULTIPART_FIELDS, DEFAULT_MULTIPART_FILE, DEFAULT_MULTIPART_FILES, DEFAULT_MULTIPART_TOTAL, DEFAULT_STATIC_FALLBACK_EXCLUDE, DEFAULT_STATIC_INDEX, EXTENSION_TYPES, MULTIPART_MAX_HEADER_BLOCK, MULTIPART_MAX_PREAMBLE, MULTIPART_REASON_STATUS, MultipartError, RESERVED_DEVICE_NAMES, computeFileETag, createCompression, createMultipart, createStatic, createUploadedFile, detectMIME, isContainedPath, isDotfilePath, isMultipartError, isReservedDeviceName, isUnderPath, lookupContentType, moveUploadedFile, multipartBoundary, parseMultipartRequest, parsePartHeaders, readUploadedFile, resolveDefaultDirectory, resolveMultipartLimits, resolveStaticPath, streamFile, streamUploadedFile, unlinkStagedFiles };
+export { DEFAULT_CONTENT_TYPE, DEFAULT_MULTIPART_FIELD, DEFAULT_MULTIPART_FIELDS, DEFAULT_MULTIPART_FILE, DEFAULT_MULTIPART_FILES, DEFAULT_MULTIPART_TOTAL, DEFAULT_STATIC_FALLBACK_EXCLUDE, DEFAULT_STATIC_INDEX, EXTENSION_TYPES, MULTIPART_MAX_HEADER_BLOCK, MULTIPART_MAX_PREAMBLE, MULTIPART_REASON_STATUS, MultipartError, RESERVED_DEVICE_NAMES, compressNodeBytes, computeFileETag, createCompression, createMultipart, createStatic, createUploadedFile, detectMIME, isContainedPath, isDotfilePath, isMultipartError, isReservedDeviceName, isUnderPath, lookupContentType, matchesBytes, moveUploadedFile, multipartBoundary, parseMultipartRequest, parsePartHeaders, readUploadedFile, resolveDefaultDirectory, resolveMultipartLimits, resolveStaticFallbackPath, resolveStaticPath, streamFile, streamUploadedFile, unlinkStagedFiles };
 
 //# sourceMappingURL=index.js.map