@qzsy/vinext 0.1.7

package/dist/routing/utils.js

@@ -0,0 +1,242 @@
+//#region src/routing/utils.ts
+/**
+* Route precedence — lower score is higher priority.
+* Matches Next.js specificity rules:
+* 1. Static routes first (scored by segment count, more = more specific)
+* 2. Dynamic segments penalized by position
+* 3. Catch-all comes after dynamic
+* 4. Optional catch-all last
+* 5. Lexicographic tiebreaker for determinism
+*
+* Key insight: routes with a static prefix before a dynamic/catch-all segment
+* should have higher priority than bare dynamic/catch-all routes at the same
+* depth. E.g., /_sites/:subdomain should match before /:subdomain, and
+* /_sites/:subdomain/:slug* should match before /:slug*.
+*
+* The static-prefix reduction uses a small value (-50 per segment) so that:
+*   - It beats the per-dynamic-segment penalty (100), placing prefix routes
+*     above their no-prefix equivalents.
+*   - It is small enough that infix-static bonuses (-500) and catch-all
+*     penalties (1000+) are not swamped, preserving their relative ordering.
+*     E.g. /:locale/blog/:path+ (with infix "blog") correctly beats /:locale/:path+
+*     even when both share the same "locale-test" static prefix.
+*   - Note: dynamic routes CAN score negative (e.g. /a/:b/c/:d = -346), but
+*     this is harmless because the trie matcher (route-trie.ts) checks static
+*     children before dynamic children at each node, so purely-static routes
+*     still win at request time regardless of sort-order score.
+*/
+function routePrecedence(pattern) {
+	const parts = pattern.split("/").filter(Boolean);
+	let score = 0;
+	let staticPrefixCount = 0;
+	for (const p of parts) {
+		if (p.startsWith(":") || p.endsWith("+") || p.endsWith("*")) break;
+		staticPrefixCount++;
+	}
+	for (let i = 0; i < parts.length; i++) {
+		const p = parts[i];
+		if (p.endsWith("+")) score += 1e3 + i;
+		else if (p.endsWith("*")) score += 2e3 + i;
+		else if (p.startsWith(":")) score += 100 + i;
+		else if (i >= staticPrefixCount) score -= 500;
+	}
+	if (parts.some((p) => p.startsWith(":") || p.endsWith("+") || p.endsWith("*")) && staticPrefixCount > 0) score -= staticPrefixCount * 50;
+	return score;
+}
+/**
+* Sort routes by precedence — lower score sorts first (higher priority), with a
+* lexicographic tiebreaker on the pattern for determinism. Sorts in place and
+* returns the same array (mirrors `Array.prototype.sort`).
+*
+* `routePrecedence` is a pure function of the pattern, so each pattern's score
+* is computed exactly once up front (decorate-sort) instead of ~2·log n times
+* by a comparator that re-parses on every comparison. The `localeCompare`
+* tiebreaker already guarantees a total order, so the result is byte-identical
+* to comparing precedence inline.
+*
+* Usage: sortRoutes(routes)
+*/
+function sortRoutes(routes) {
+	const scores = /* @__PURE__ */ new Map();
+	for (const route of routes) if (!scores.has(route.pattern)) scores.set(route.pattern, routePrecedence(route.pattern));
+	return routes.sort((a, b) => {
+		const diff = (scores.get(a.pattern) ?? 0) - (scores.get(b.pattern) ?? 0);
+		return diff !== 0 ? diff : a.pattern.localeCompare(b.pattern);
+	});
+}
+/**
+* Single source of truth for hybrid App/Pages route ownership.
+*
+* Mirrors Next.js's DefaultRouteMatcherManager ordering: Pages providers
+* are registered before App providers, then merged dynamic matchers sort
+* together. Returns the router that should own a request/navigation to
+* a URL that matched BOTH routers.
+*
+* Centralised so the server's request handling and the client's link /
+* prefetch / programmatic-navigation paths all reach the same owner for
+* the same (pages pattern, app pattern) pair. This intentionally implements
+* Next.js's segment-tree ordering directly instead of vinext's broader
+* `sortRoutes()` score heuristic. It only arbitrates two routes that already
+* matched the same URL; each router's own trie ordering remains unchanged.
+*
+* Usage:
+*   compareHybridRoutePatterns("/:slug", true, "/:slug", true)  // → "pages"
+*   compareHybridRoutePatterns("/_sites/:slug*", true, "/:slug*", true)  // → "pages"
+*   compareHybridRoutePatterns("/:path+", true, "/dashboard", false)  // → "app"
+*   compareHybridRoutePatterns("/", false, "/", false)  // → "app"
+*/
+function compareHybridRoutePatterns(pagesPattern, pagesIsDynamic, appPattern, appIsDynamic) {
+	if (pagesPattern === appPattern) throw new Error(`Conflicting app and page routes found for "${pagesPattern}"`);
+	if (!pagesIsDynamic) return appIsDynamic ? "pages" : "app";
+	if (!appIsDynamic) return "app";
+	const pagesSegments = pagesPattern.split("/").filter(Boolean);
+	const appSegments = appPattern.split("/").filter(Boolean);
+	const segmentRank = (segment) => {
+		if (!segment.startsWith(":")) return 0;
+		if (segment.endsWith("*")) return 3;
+		if (segment.endsWith("+")) return 2;
+		return 1;
+	};
+	for (let index = 0; index < Math.min(pagesSegments.length, appSegments.length); index++) {
+		const pagesRank = segmentRank(pagesSegments[index]);
+		const appRank = segmentRank(appSegments[index]);
+		if (pagesRank !== appRank) return pagesRank < appRank ? "pages" : "app";
+	}
+	if (pagesSegments.length !== appSegments.length) return pagesSegments.length < appSegments.length ? "pages" : "app";
+	return "pages";
+}
+const PATH_DELIMITER_REGEX = /([/#?\\]|%(2f|23|3f|5c))/gi;
+function encodePathDelimiters(segment) {
+	return segment.replace(PATH_DELIMITER_REGEX, (char) => encodeURIComponent(char));
+}
+/**
+* Decode a filesystem or URL path segment while preserving encoded path delimiters.
+* Mirrors Next.js segment-wise decoding so "%5F" becomes "_" but "%2F" stays "%2F".
+*/
+function decodeRouteSegment(segment) {
+	try {
+		return encodePathDelimiters(decodeURIComponent(segment));
+	} catch {
+		return segment;
+	}
+}
+/**
+* Strict variant for request pipelines that should reject malformed percent-encoding.
+*/
+function decodeRouteSegmentStrict(segment) {
+	return encodePathDelimiters(decodeURIComponent(segment));
+}
+/**
+* Normalize a pathname for route matching by decoding each segment independently.
+* This prevents encoded slashes from turning into real path separators.
+*/
+function normalizePathnameForRouteMatch(pathname) {
+	return pathname.split("/").map((segment) => decodeRouteSegment(segment)).join("/");
+}
+function splitPathnameForRouteMatch(pathname) {
+	return normalizePathnameForRouteMatch(pathname).split("/").filter(Boolean);
+}
+/**
+* Strict pathname normalization for live request handling.
+* Throws on malformed percent-encoding so callers can return 400.
+*/
+function normalizePathnameForRouteMatchStrict(pathname) {
+	return pathname.split("/").map((segment) => decodeRouteSegmentStrict(segment)).join("/");
+}
+function decodeMatchedParam(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Build a params object from ordered entries, preserving insertion order.
+*
+* Used by trie matchers to reconstruct the params Record after collecting
+* entries in declaration order via DFS backtracking. Object.create(null)
+* avoids prototype pollution.
+*
+* @param entries - Ordered [paramName, value] tuples from forward traversal
+*/
+function buildParams(entries) {
+	const params = Object.create(null);
+	for (const [key, value] of entries) params[key] = value;
+	return params;
+}
+/**
+* Decode captured route params with `decodeURIComponent`, mirroring Next.js
+* route-matcher.ts:25-27. Mutates the params object in place. Catch-all
+* arrays are decoded element-wise. Malformed escapes are preserved (the
+* strict normalization layer rejects them at the request boundary).
+*/
+function decodeMatchedParams(params) {
+	for (const key of Object.keys(params)) {
+		const value = params[key];
+		if (Array.isArray(value)) params[key] = value.map(decodeMatchedParam);
+		else params[key] = decodeMatchedParam(value);
+	}
+}
+/**
+* Check whether a path segment is invisible in the URL (route groups, parallel
+* slots, "."). Single source of truth shared by the route graph (Node) and
+* browser-side bfcache identity logic. Lives in this browser-safe utils module
+* so importing it does not drag node:path/node:fs into the client bundle.
+*/
+function isInvisibleSegment(segment) {
+	if (segment === ".") return true;
+	if (segment.startsWith("(") && segment.endsWith(")")) return true;
+	if (segment.startsWith("@")) return true;
+	return false;
+}
+/** Split a pathname into its non-empty segments without decoding. */
+function splitPathSegments(pathname) {
+	return pathname.split("/").filter(Boolean);
+}
+/**
+* Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
+* with the route graph's segment parsing (dynamicParamNameFromSegment) so the
+* bracket conventions live in one place. The length guard rejects empty names
+* (`[...]`).
+*/
+function isCatchAllSegment(segment) {
+	return segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
+}
+/**
+* Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
+* this matches zero or more URL segments.
+*/
+function isOptionalCatchAllSegment(segment) {
+	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
+}
+/**
+* Count how many pathname segments a tree path's *visible* segments consume,
+* given the total number of pathname segments available.
+*
+* This is the minimal pure slice of the canonical filesystem-segment →
+* URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
+* extracted here so browser-side bfcache identity logic can share it without
+* importing the Node-bound route graph module. `convertSegmentsToRouteParts`
+* remains the source of truth for how each segment kind maps to a URL part.
+*
+* Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
+* segment. A catch-all (`[...x]`) is terminal and consumes every remaining
+* pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
+* match zero segments, so it consumes only the remaining pathname segments
+* (which is zero once preceding segments have already consumed the pathname) —
+* never more than are actually present.
+*
+* @param visibleTreePathSegments URL-visible tree-path segments (callers must
+*   pre-filter invisible segments via `isInvisibleSegment`).
+* @param pathnameSegmentCount Total number of pathname segments available.
+*/
+function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentCount) {
+	let consumed = 0;
+	for (const segment of visibleTreePathSegments) {
+		if (isCatchAllSegment(segment) || isOptionalCatchAllSegment(segment)) return Math.max(consumed, pathnameSegmentCount);
+		consumed += 1;
+	}
+	return consumed;
+}
+//#endregion
+export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };

package/dist/server/accept-encoding.d.ts

@@ -0,0 +1,29 @@
+import { IncomingMessage } from "node:http";
+
+//#region src/server/accept-encoding.d.ts
+type ContentEncoding = "zstd" | "br" | "gzip" | "deflate";
+type NegotiatedEncoding = ContentEncoding | "identity";
+/** Parsed explicit coding qualities plus the wildcard quality, when present. */
+type ParsedAcceptEncoding = {
+  qualities: Map<string, number>;
+  orders: Map<string, number>;
+  wildcardQuality: number | null;
+};
+/** Parse an Accept-Encoding header into exact-token numeric qualities. */
+declare function parseAcceptedEncodings(accept: string): ParsedAcceptEncoding;
+/** Return the effective quality for a coding, including wildcard/identity rules. */
+declare function getEncodingQuality(parsed: ParsedAcceptEncoding, encoding: string): number;
+declare function isEncodingAccepted(parsed: ParsedAcceptEncoding, encoding: string): boolean;
+/** Choose the highest-quality available coding, using array order as the tie-breaker. */
+declare function selectAcceptedEncoding<T extends string>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | null;
+/**
+ * Select a content coding while matching Next.js's compression middleware:
+ * an explicit identity preference can win, but implicit identity remains a
+ * fallback rather than suppressing an otherwise acceptable encoding.
+ */
+declare function selectContentEncoding<T extends ContentEncoding>(parsed: ParsedAcceptEncoding, available: readonly T[]): T | "identity";
+declare const HAS_ZSTD: boolean;
+/** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
+declare function negotiateEncoding(req: IncomingMessage): NegotiatedEncoding;
+//#endregion
+export { HAS_ZSTD, NegotiatedEncoding, ParsedAcceptEncoding, getEncodingQuality, isEncodingAccepted, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };

package/dist/server/accept-encoding.js

@@ -0,0 +1,95 @@
+import zlib from "node:zlib";
+//#region src/server/accept-encoding.ts
+/** Parse an Accept-Encoding header into exact-token numeric qualities. */
+function parseAcceptedEncodings(accept) {
+	const qualities = /* @__PURE__ */ new Map();
+	const orders = /* @__PURE__ */ new Map();
+	let wildcardQuality = null;
+	for (const [order, part] of accept.split(",").entries()) {
+		const trimmed = part.trim();
+		if (trimmed.length === 0) continue;
+		const semi = trimmed.indexOf(";");
+		const token = (semi === -1 ? trimmed : trimmed.slice(0, semi)).trim().toLowerCase();
+		if (token.length === 0) continue;
+		let quality = 1;
+		if (semi !== -1) {
+			let qStr;
+			for (const param of trimmed.slice(semi + 1).split(";")) {
+				const [name, value] = param.trim().split("=");
+				if (name !== "q") continue;
+				qStr = value ?? "";
+				break;
+			}
+			if (qStr !== void 0) quality = Number.parseFloat(qStr);
+		}
+		if (token === "*") {
+			if (wildcardQuality === null || Number.isNaN(quality) || Number.isNaN(wildcardQuality) || quality >= wildcardQuality) wildcardQuality = quality;
+		} else {
+			const currentQuality = qualities.get(token);
+			if (currentQuality === void 0 || Number.isNaN(quality) || Number.isNaN(currentQuality) || quality >= currentQuality) {
+				qualities.set(token, quality);
+				orders.set(token, order);
+			}
+		}
+	}
+	return {
+		qualities,
+		orders,
+		wildcardQuality
+	};
+}
+/** Return the effective quality for a coding, including wildcard/identity rules. */
+function getEncodingQuality(parsed, encoding) {
+	const normalized = encoding.toLowerCase();
+	const explicit = parsed.qualities.get(normalized);
+	if (explicit !== void 0) return Number.isNaN(explicit) ? 0 : explicit;
+	if (normalized === "identity") return parsed.wildcardQuality === 0 ? 0 : 1;
+	if (parsed.wildcardQuality !== null) return Number.isNaN(parsed.wildcardQuality) ? 0 : parsed.wildcardQuality;
+	return 0;
+}
+function isEncodingAccepted(parsed, encoding) {
+	return getEncodingQuality(parsed, encoding) > 0;
+}
+/** Choose the highest-quality available coding, using array order as the tie-breaker. */
+function selectAcceptedEncoding(parsed, available) {
+	let selected = null;
+	let selectedQuality = 0;
+	for (const encoding of available) {
+		const quality = getEncodingQuality(parsed, encoding);
+		if (quality > selectedQuality) {
+			selected = encoding;
+			selectedQuality = quality;
+		}
+	}
+	return selected;
+}
+/**
+* Select a content coding while matching Next.js's compression middleware:
+* an explicit identity preference can win, but implicit identity remains a
+* fallback rather than suppressing an otherwise acceptable encoding.
+*/
+function selectContentEncoding(parsed, available) {
+	const selected = selectAcceptedEncoding(parsed, available);
+	if (selected === null) return "identity";
+	const identityQuality = parsed.qualities.get("identity");
+	if (identityQuality === void 0 || Number.isNaN(identityQuality)) return selected;
+	const selectedQuality = getEncodingQuality(parsed, selected);
+	if (identityQuality > selectedQuality) return "identity";
+	if (identityQuality < selectedQuality) return selected;
+	if (!parsed.qualities.has(selected)) return "identity";
+	return (parsed.orders.get("identity") ?? Number.POSITIVE_INFINITY) < (parsed.orders.get(selected) ?? Number.POSITIVE_INFINITY) ? "identity" : selected;
+}
+const HAS_ZSTD = typeof zlib.createZstdCompress === "function";
+/** Select by client q-value first, then zstd > br > gzip > deflate > identity. */
+function negotiateEncoding(req) {
+	const accept = req.headers["accept-encoding"];
+	if (typeof accept !== "string") return "identity";
+	return selectContentEncoding(parseAcceptedEncodings(accept), [
+		...HAS_ZSTD ? ["zstd"] : [],
+		"br",
+		"gzip",
+		"deflate"
+	]);
+}
+//#endregion
+export { HAS_ZSTD, getEncodingQuality, isEncodingAccepted, negotiateEncoding, parseAcceptedEncodings, selectAcceptedEncoding, selectContentEncoding };

package/dist/server/api-handler.d.ts

@@ -0,0 +1,17 @@
+import { NextI18nConfig } from "../config/next-config.js";
+import { Route } from "../routing/pages-router.js";
+import { ModuleImporter } from "./instrumentation.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/server/api-handler.d.ts
+/**
+ * Handle an API route request.
+ * Returns true if the request was handled, false if no API route matched.
+ */
+declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
+  basePath?: string;
+  i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
+}): Promise<boolean>;
+//#endregion
+export { handleApiRoute };

package/dist/server/api-handler.js

@@ -0,0 +1,276 @@
+import { hasBasePath } from "../utils/base-path.js";
+import { matchRoute } from "../routing/pages-router.js";
+import "./server-globals.js";
+import { parseCookieHeader } from "../utils/parse-cookie.js";
+import { NextRequest } from "../shims/server.js";
+import { importModule, reportRequestError } from "./instrumentation.js";
+import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
+import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
+import { isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
+import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
+import { performOnDemandRevalidate } from "./pages-revalidate.js";
+import { decode } from "node:querystring";
+import { Buffer } from "node:buffer";
+//#region src/server/api-handler.ts
+/**
+* Default request body size (1 MB). Matches Next.js default bodyParser sizeLimit.
+* @see https://nextjs.org/docs/pages/building-your-application/routing/api-routes#custom-config
+* Prevents denial-of-service via unbounded request body buffering.
+*/
+const MAX_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
+/**
+* Parse the request body based on content-type.
+* Enforces a size limit to prevent memory exhaustion attacks.
+*
+* The `sizeLimit` argument honours `export const config = { api: { bodyParser:
+* { sizeLimit: '4mb' } } }` on the route module. To opt out of parsing
+* entirely (`bodyParser: false`), callers must skip this function so the
+* underlying readable stream stays intact on `req` (critical for webhook
+* HMAC signature verification).
+*/
+async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let totalSize = 0;
+		let settled = false;
+		req.on("data", (chunk) => {
+			totalSize += chunk.length;
+			if (totalSize > sizeLimit) {
+				settled = true;
+				req.destroy();
+				reject(new PagesBodyParseError("Request body too large", 413));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("error", (err) => {
+			if (!settled) {
+				settled = true;
+				reject(err);
+			}
+		});
+		req.on("end", () => {
+			if (settled) return;
+			settled = true;
+			const raw = Buffer.concat(chunks).toString("utf-8");
+			const mediaType = getMediaType(req.headers["content-type"]);
+			if (!raw) {
+				resolve(isJsonMediaType(mediaType) ? {} : mediaType === "application/x-www-form-urlencoded" ? decode(raw) : void 0);
+				return;
+			}
+			if (isJsonMediaType(mediaType)) try {
+				resolve(JSON.parse(raw));
+			} catch {
+				reject(new PagesBodyParseError("Invalid JSON", 400));
+			}
+			else if (mediaType === "application/x-www-form-urlencoded") resolve(decode(raw));
+			else resolve(raw);
+		});
+	});
+}
+/**
+* Parse cookies from the Cookie header.
+*/
+function parseCookies(req) {
+	return parseCookieHeader(req.headers.cookie);
+}
+function isEdgeApiRouteModule(module) {
+	if (typeof module.default !== "function") return false;
+	const bare = module.runtime;
+	if (typeof bare === "string") return isEdgeApiRuntime(bare);
+	const config = module.config;
+	if (!config || typeof config !== "object") return false;
+	const runtime = "runtime" in config ? config.runtime : void 0;
+	return typeof runtime === "string" && isEdgeApiRuntime(runtime);
+}
+function readEdgeRequestBody(req) {
+	if (req.method === "GET" || req.method === "HEAD") return void 0;
+	return new ReadableStream({ start(controller) {
+		req.on("data", (chunk) => {
+			controller.enqueue(typeof chunk === "string" ? Buffer.from(chunk) : new Uint8Array(chunk));
+		});
+		req.on("end", () => controller.close());
+		req.on("error", (error) => controller.error(error));
+	} });
+}
+function createEdgeApiRequest(req, url, params, nextConfig) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else if (value !== void 0) headers.set(name, value);
+	}
+	const proto = resolveRequestProtocol(req);
+	const host = resolveRequestHost(req, "localhost");
+	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
+	const basePath = nextConfig?.basePath;
+	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
+	requestUrl.search = urlQueryToSearchParams(mergeRouteParamsIntoQuery(parseQueryString(url), params)).toString();
+	const body = readEdgeRequestBody(req);
+	const init = {
+		headers,
+		method: req.method
+	};
+	if (body) {
+		init.body = body;
+		init.duplex = "half";
+	}
+	return new Request(requestUrl, init);
+}
+function waitForWritableDrain(res) {
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			res.off("drain", onDrain);
+			res.off("error", onError);
+			res.off("close", onClose);
+		};
+		const onDrain = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("Response closed before writable drain"));
+		};
+		res.once("drain", onDrain);
+		res.once("error", onError);
+		res.once("close", onClose);
+	});
+}
+async function writeEdgeApiResponseBody(res, body) {
+	if (!body) {
+		res.end();
+		return;
+	}
+	const reader = body.getReader();
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			if (result.value.byteLength === 0) continue;
+			if (!res.write(Buffer.from(result.value))) await waitForWritableDrain(res);
+		}
+		res.end();
+	} catch (error) {
+		res.destroy(error instanceof Error ? error : new Error(String(error)));
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+}
+/**
+* Enhance a Node.js req/res pair with Next.js API route helpers.
+*/
+function enhanceApiObjects(req, res, query, body) {
+	return {
+		apiReq: Object.assign(req, {
+			body,
+			cookies: parseCookies(req),
+			query
+		}),
+		apiRes: Object.assign(res, {
+			status(code) {
+				this.statusCode = code;
+				return this;
+			},
+			json(data) {
+				this.setHeader("Content-Type", "application/json");
+				this.end(JSON.stringify(data));
+			},
+			send(data) {
+				if (Buffer.isBuffer(data)) {
+					if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
+					this.setHeader("Content-Length", String(data.length));
+					this.end(data);
+					return;
+				}
+				if (typeof data === "object" && data !== null) {
+					this.setHeader("Content-Type", "application/json");
+					this.end(JSON.stringify(data));
+				} else {
+					if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "text/plain");
+					this.end(String(data));
+				}
+			},
+			redirect(statusOrUrl, url) {
+				if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
+				else this.writeHead(statusOrUrl, { Location: url ?? "" });
+				this.end();
+			},
+			async revalidate(urlPath, opts) {
+				await performOnDemandRevalidate(req, urlPath, opts);
+			}
+		})
+	};
+}
+/**
+* Handle an API route request.
+* Returns true if the request was handled, false if no API route matched.
+*/
+async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
+	const match = matchRoute(url, apiRoutes);
+	if (!match) return false;
+	const { route, params } = match;
+	try {
+		const apiModule = await importModule(runner, route.filePath);
+		if (isEdgeApiRouteModule(apiModule)) {
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, url, params, nextConfig), nextConfig ? { nextConfig: {
+				basePath: nextConfig.basePath,
+				i18n: nextConfig.i18n ?? void 0,
+				trailingSlash: nextConfig.trailingSlash
+			} } : void 0);
+			const response = await apiModule.default(nextRequest);
+			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
+			res.statusCode = response.status;
+			res.statusMessage = response.statusText;
+			const setCookieHeaders = response.headers.getSetCookie();
+			response.headers.forEach((value, name) => {
+				if (name !== "set-cookie") res.setHeader(name, value);
+			});
+			if (setCookieHeaders.length) res.setHeader("set-cookie", setCookieHeaders);
+			await writeEdgeApiResponseBody(res, response.body);
+			return true;
+		}
+		const handler = apiModule.default;
+		if (typeof handler !== "function") {
+			console.error(`[vinext] API route ${route.filePath} does not export a default function`);
+			res.statusCode = 500;
+			res.end("API route does not export a default function");
+			return true;
+		}
+		const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
+		const bodyParserConfig = resolveBodyParserConfig(apiModule.config);
+		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0);
+		await handler(apiReq, apiRes);
+		return true;
+	} catch (e) {
+		if (e instanceof PagesBodyParseError) {
+			res.statusCode = e.statusCode;
+			res.statusMessage = e.message;
+			res.end(e.message);
+			return true;
+		}
+		console.error(e);
+		reportRequestError(e instanceof Error ? e : new Error(String(e)), {
+			path: url,
+			method: req.method ?? "GET",
+			headers: Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.startsWith(":")).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
+		}, {
+			routerKind: "Pages Router",
+			routePath: match.route.pattern,
+			routeType: "route"
+		});
+		if (!res.headersSent) {
+			res.statusCode = 500;
+			res.end("Internal Server Error");
+		} else if (!res.writableEnded) res.end();
+		return true;
+	}
+}
+//#endregion
+export { handleApiRoute };

package/dist/server/app-action-request.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/app-action-request.d.ts
+declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
+//#endregion
+export { isPossibleAppRouteActionRequest };

package/dist/server/app-action-request.js

@@ -0,0 +1,9 @@
+import "./headers.js";
+//#region src/server/app-action-request.ts
+function isPossibleAppRouteActionRequest(request) {
+	if (request.method.toUpperCase() !== "POST") return false;
+	const contentType = request.headers.get("content-type");
+	return request.headers.has("x-rsc-action") || request.headers.has("next-action") || contentType === "application/x-www-form-urlencoded" || contentType?.startsWith("multipart/form-data") === true;
+}
+//#endregion
+export { isPossibleAppRouteActionRequest };

package/dist/server/app-bfcache-id.d.ts

@@ -0,0 +1,5 @@
+//#region src/server/app-bfcache-id.d.ts
+declare const INITIAL_BFCACHE_ID = "0";
+declare const PUBLIC_INITIAL_BFCACHE_ID = "_b_0_";
+//#endregion
+export { INITIAL_BFCACHE_ID, PUBLIC_INITIAL_BFCACHE_ID };