vinext 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/server/middleware-path-to-regexp.js

@@ -0,0 +1,228 @@
+//#region src/server/middleware-path-to-regexp.ts
+function lexer(value) {
+	const tokens = [];
+	let index = 0;
+	while (index < value.length) {
+		const character = value[index];
+		if (character === "*" || character === "+" || character === "?") {
+			tokens.push({
+				type: "MODIFIER",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "\\") {
+			tokens.push({
+				type: "ESCAPED_CHAR",
+				index: index++,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "{") {
+			tokens.push({
+				type: "OPEN",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === "}") {
+			tokens.push({
+				type: "CLOSE",
+				index,
+				value: value[index++]
+			});
+			continue;
+		}
+		if (character === ":") {
+			let name = "";
+			let nameEnd = index + 1;
+			while (nameEnd < value.length) {
+				const code = value.charCodeAt(nameEnd);
+				if (code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95) {
+					name += value[nameEnd++];
+					continue;
+				}
+				break;
+			}
+			if (!name) throw new TypeError(`Missing parameter name at ${index}`);
+			tokens.push({
+				type: "NAME",
+				index,
+				value: name
+			});
+			index = nameEnd;
+			continue;
+		}
+		if (character === "(") {
+			let depth = 1;
+			let pattern = "";
+			let patternEnd = index + 1;
+			if (value[patternEnd] === "?") throw new TypeError(`Pattern cannot start with "?" at ${patternEnd}`);
+			while (patternEnd < value.length) {
+				if (value[patternEnd] === "\\") {
+					pattern += value[patternEnd++] + value[patternEnd++];
+					continue;
+				}
+				if (value[patternEnd] === ")") {
+					depth--;
+					if (depth === 0) {
+						patternEnd++;
+						break;
+					}
+				} else if (value[patternEnd] === "(") {
+					depth++;
+					if (value[patternEnd + 1] !== "?") throw new TypeError(`Capturing groups are not allowed at ${patternEnd}`);
+				}
+				pattern += value[patternEnd++];
+			}
+			if (depth) throw new TypeError(`Unbalanced pattern at ${index}`);
+			if (!pattern) throw new TypeError(`Missing pattern at ${index}`);
+			tokens.push({
+				type: "PATTERN",
+				index,
+				value: pattern
+			});
+			index = patternEnd;
+			continue;
+		}
+		tokens.push({
+			type: "CHAR",
+			index,
+			value: value[index++]
+		});
+	}
+	tokens.push({
+		type: "END",
+		index,
+		value: ""
+	});
+	return tokens;
+}
+function parseMiddlewarePath(value) {
+	const tokens = lexer(value);
+	const result = [];
+	const prefixes = "./";
+	const delimiter = "/#?";
+	let key = 0;
+	let index = 0;
+	let path = "";
+	const tryConsume = (type) => {
+		if (index < tokens.length && tokens[index].type === type) return tokens[index++].value;
+	};
+	const mustConsume = (type) => {
+		const consumed = tryConsume(type);
+		if (consumed !== void 0) return consumed;
+		const next = tokens[index];
+		throw new TypeError(`Unexpected ${next.type} at ${next.index}, expected ${type}`);
+	};
+	const consumeText = () => {
+		let text = "";
+		let consumed;
+		while ((consumed = tryConsume("CHAR") ?? tryConsume("ESCAPED_CHAR")) !== void 0) text += consumed;
+		return text;
+	};
+	const containsDelimiter = (text) => {
+		for (const character of delimiter) if (text.includes(character)) return true;
+		return false;
+	};
+	const defaultPattern = (prefix) => {
+		const previous = result[result.length - 1];
+		const previousText = prefix || (typeof previous === "string" ? previous : "");
+		if (previous && !previousText) {
+			const name = typeof previous === "string" ? previous : previous.name;
+			throw new TypeError(`Must have text between two parameters, missing text after "${name}"`);
+		}
+		if (!previousText || containsDelimiter(previousText)) return "[^\\/#\\?]+?";
+		return `(?:(?!${escapeRegex(previousText)})[^\\/#\\?])+?`;
+	};
+	while (index < tokens.length) {
+		const character = tryConsume("CHAR");
+		const name = tryConsume("NAME");
+		const pattern = tryConsume("PATTERN");
+		if (name !== void 0 || pattern !== void 0) {
+			let prefix = character ?? "";
+			if (!prefixes.includes(prefix)) {
+				path += prefix;
+				prefix = "";
+			}
+			if (path) {
+				result.push(path);
+				path = "";
+			}
+			result.push({
+				name: name ?? key++,
+				prefix,
+				suffix: "",
+				pattern: pattern ?? defaultPattern(prefix),
+				modifier: tryConsume("MODIFIER") ?? ""
+			});
+			continue;
+		}
+		const text = character ?? tryConsume("ESCAPED_CHAR");
+		if (text !== void 0) {
+			path += text;
+			continue;
+		}
+		if (path) {
+			result.push(path);
+			path = "";
+		}
+		if (tryConsume("OPEN") !== void 0) {
+			const prefix = consumeText();
+			const groupName = tryConsume("NAME") ?? "";
+			const groupPattern = tryConsume("PATTERN") ?? "";
+			const suffix = consumeText();
+			mustConsume("CLOSE");
+			result.push({
+				name: groupName || (groupPattern ? key++ : ""),
+				pattern: groupName && !groupPattern ? defaultPattern(prefix) : groupPattern,
+				prefix,
+				suffix,
+				modifier: tryConsume("MODIFIER") ?? ""
+			});
+			continue;
+		}
+		mustConsume("END");
+	}
+	return result;
+}
+function escapeRegex(value) {
+	return value.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+}
+function normalizeMiddlewarePathTokens(tokens) {
+	return tokens.map((token) => {
+		if (typeof token === "object" && (token.modifier === "*" || token.modifier === "+") && token.prefix === "" && token.suffix === "") return {
+			...token,
+			prefix: "/"
+		};
+		return token;
+	});
+}
+function middlewarePathTokensToRegExp(tokens) {
+	const delimiterRegex = `[${escapeRegex("/#?")}]`;
+	let route = "^";
+	for (const token of tokens) {
+		if (typeof token === "string") {
+			route += escapeRegex(token);
+			continue;
+		}
+		const prefix = escapeRegex(token.prefix);
+		const suffix = escapeRegex(token.suffix);
+		if (token.pattern) if (prefix || suffix) if (token.modifier === "+" || token.modifier === "*") {
+			const optional = token.modifier === "*" ? "?" : "";
+			route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${optional}`;
+		} else route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+		else {
+			if (token.modifier === "+" || token.modifier === "*") throw new TypeError(`Can not repeat "${token.name}" without a prefix and suffix`);
+			route += `(${token.pattern})${token.modifier}`;
+		}
+		else route += `(?:${prefix}${suffix})${token.modifier}`;
+	}
+	route += `${delimiterRegex}?$`;
+	return new RegExp(route, "i");
+}
+//#endregion
+export { middlewarePathTokensToRegExp, normalizeMiddlewarePathTokens, parseMiddlewarePath };

package/dist/server/middleware-runtime.js

@@ -112,10 +112,11 @@ function resolveMiddlewarePathname(request) {
 		return badRequestResponse();
 	}
 }
-function createNextRequest(request, normalizedPathname, i18nConfig, basePath, trailingSlash, hadBasePath) {
+function createNextRequest(request, i18nConfig, basePath, trailingSlash, hadBasePath) {
 	const url = new URL(request.url);
 	let mwRequest = request.body && !request.bodyUsed ? request.clone() : request;
-	const mwPathname = basePath && hadBasePath ? addBasePathToPathname(normalizedPathname, basePath) : normalizedPathname;
+	const requestPathname = url.pathname;
+	const mwPathname = basePath && hadBasePath && !hasBasePath(requestPathname, basePath) ? addBasePathToPathname(requestPathname, basePath) : requestPathname;
 	if (mwPathname !== url.pathname) {
 		const mwUrl = new URL(url);
 		mwUrl.pathname = mwPathname;
@@ -141,7 +142,7 @@ async function executeMiddleware(options) {
 	const hadBasePath = options.hadBasePath ?? (!options.basePath || hasBasePath(new URL(options.request.url).pathname, options.basePath));
 	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
 	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
-	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
+	const nextRequest = createNextRequest(options.request, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
 	if (options.isDataRequest) Object.defineProperty(nextRequest, "__isData", {
 		enumerable: false,
 		value: true

package/dist/server/middleware.d.ts

@@ -58,6 +58,6 @@ declare function findMiddlewareFile(root: string, fileMatcher: ValidFileMatcher,
  * @param request - The incoming Request object
  * @returns Middleware result describing what action to take
  */
-declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean): Promise<MiddlewareResult>;
+declare function runMiddleware(runner: ModuleRunner, middlewarePath: string, request: Request, i18nConfig?: NextI18nConfig | null, basePath?: string, trailingSlash?: boolean, isDataRequest?: boolean, normalizedPathname?: string): Promise<MiddlewareResult>;
 //#endregion
 export { findMiddlewareFile, isProxyFile, matchPattern, matchesMiddleware, resolveMiddlewareHandler, runMiddleware };

package/dist/server/middleware.js

@@ -94,7 +94,7 @@ function isMiddlewareModule(value) {
 * @param request - The incoming Request object
 * @returns Middleware result describing what action to take
 */
-async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest) {
+async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePath, trailingSlash, isDataRequest, normalizedPathname) {
 	const mod = await runner.import(middlewarePath);
 	if (!isMiddlewareModule(mod)) throw new Error(`Middleware module "${middlewarePath}" did not evaluate to an object.`);
 	return runGeneratedMiddleware({
@@ -106,6 +106,7 @@ async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePa
 		isDataRequest,
 		isProxy: isProxyFile(middlewarePath),
 		module: mod,
+		normalizedPathname,
 		request,
 		trailingSlash
 	});

package/dist/server/pages-api-route.d.ts

@@ -74,9 +74,11 @@ type HandlePagesApiRouteOptions = {
   url: string;
   nextConfig?: {
     basePath?: string;
+    allowedRevalidateHeaderKeys?: readonly string[];
     i18n?: NextI18nConfig | null;
     trailingSlash?: boolean;
   };
+  trustedRevalidateOrigin?: string;
 };
 declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
 //#endregion

package/dist/server/pages-api-route.js

@@ -48,10 +48,13 @@ async function _handlePagesApiRoute(options) {
 		if (!isNodeApiRouteModule(route.module)) return new Response("API route does not export a default function", { status: 500 });
 		const query = buildPagesApiQuery(options.url, params);
 		const bodyParserConfig = resolveBodyParserConfig(route.module.config);
+		const body = bodyParserConfig.enabled ? await parsePagesApiBody(options.request, bodyParserConfig.sizeLimit) : void 0;
 		const { req, res, responsePromise } = createPagesReqRes({
-			body: bodyParserConfig.enabled ? await parsePagesApiBody(options.request, bodyParserConfig.sizeLimit) : void 0,
+			allowedRevalidateHeaderKeys: options.nextConfig?.allowedRevalidateHeaderKeys,
+			body,
 			query,
 			request: options.request,
+			trustedRevalidateOrigin: options.trustedRevalidateOrigin,
 			url: options.url
 		});
 		let resWasPiped = false;

package/dist/server/pages-data-route.d.ts

@@ -34,6 +34,16 @@ type NextDataMatch = {
  * even when the buildId is wrong (so we can still return a 404 JSON response).
  */
 declare function isNextDataPathname(pathname: string): boolean;
+/**
+ * WHATWG URL parsing removes TAB, LF, and CR characters. Reject paths where
+ * that normalization would manufacture the internal Pages data namespace.
+ */
+declare function urlParserCreatesPagesDataPath(pathname: string): boolean;
+/**
+ * Keep URL-parser-ignored characters encoded until route matching decodes the
+ * captured parameter. Passing them literally to `new URL()` would remove them.
+ */
+declare function encodeUrlParserIgnoredCharacters(pathname: string): string;
 /**
  * Parse `/_next/data/<buildId>/<...page>.json` and return the normalized page
  * pathname. Returns `null` if the pathname does not match the pattern or if
@@ -120,4 +130,4 @@ type NormalizePagesDataRequestResult = {
  */
 declare function normalizePagesDataRequest(request: Request, buildId: string | null, basePath?: string, trailingSlash?: boolean): NormalizePagesDataRequestResult;
 //#endregion
-export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname, urlParserCreatesPagesDataPath };

package/dist/server/pages-data-route.js

@@ -32,6 +32,21 @@ function isNextDataPathname(pathname) {
 	return pathname.startsWith(NEXT_DATA_PREFIX) && pathname.endsWith(NEXT_DATA_SUFFIX);
 }
 /**
+* WHATWG URL parsing removes TAB, LF, and CR characters. Reject paths where
+* that normalization would manufacture the internal Pages data namespace.
+*/
+function urlParserCreatesPagesDataPath(pathname) {
+	const parsedPathname = pathname.replaceAll("	", "").replaceAll("\n", "").replaceAll("\r", "");
+	return pathname !== parsedPathname && !isNextDataPathname(pathname) && isNextDataPathname(parsedPathname);
+}
+/**
+* Keep URL-parser-ignored characters encoded until route matching decodes the
+* captured parameter. Passing them literally to `new URL()` would remove them.
+*/
+function encodeUrlParserIgnoredCharacters(pathname) {
+	return pathname.replaceAll("	", "%09").replaceAll("\n", "%0A").replaceAll("\r", "%0D");
+}
+/**
 * Parse `/_next/data/<buildId>/<...page>.json` and return the normalized page
 * pathname. Returns `null` if the pathname does not match the pattern or if
 * the buildId segment does not match the server's buildId.
@@ -168,4 +183,4 @@ function normalizePagesDataRequest(request, buildId, basePath = "", trailingSlas
 	};
 }
 //#endregion
-export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname };
+export { buildMiddlewarePrefetchSkipResponse, buildNextDataJsonResponse, buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, normalizePagesDataRequest, parseNextDataPathname, urlParserCreatesPagesDataPath };

package/dist/server/pages-dev-hydration.js

@@ -17,7 +17,6 @@ function createPagesDevHydrationScript(options) {
   element = React.createElement(AppComponent, {
     ...props,
     Component: PageComponent,
-    pageProps: rawPageProps,
     router: appRouter,
   });
   ` : `

package/dist/server/pages-get-initial-props.d.ts

@@ -1,3 +1,5 @@
+import { NextRouter } from "../shims/router.js";
+
 //#region src/server/pages-get-initial-props.d.ts
 type PagesGetInitialPropsContext = {
   req?: unknown;
@@ -10,6 +12,16 @@ type PagesGetInitialPropsContext = {
   locales?: string[];
   defaultLocale?: string;
 } & Record<string, unknown>;
+type PagesGetInitialPropsRouter = Omit<Pick<NextRouter, "route" | "pathname" | "query" | "asPath">, "query"> & {
+  query: Record<string, unknown>;
+};
+/**
+ * Build the URL-state subset of Next.js's ServerRouter used by isolated
+ * initial-props helpers. Real request handlers pass their full `next/router`
+ * instance; this fallback keeps direct helper callers and tests aligned with
+ * the same required fields.
+ */
+declare function createPagesGetInitialPropsRouter(pathname: string, query: Record<string, unknown>, asPath: string): PagesGetInitialPropsRouter;
 declare function hasPagesGetInitialProps(component: unknown): boolean;
 declare function isResponseSent(res: unknown): boolean;
 declare function loadPagesGetInitialProps(component: unknown, context: PagesGetInitialPropsContext): Promise<Record<string, unknown> | null>;
@@ -31,7 +43,7 @@ type DevAppInitialPropsResult = {
   kind: "render";
   pageProps: Record<string, unknown>;
   renderProps: Record<string, unknown> & {
-    pageProps: unknown;
+    pageProps?: unknown;
   };
 };
 type DevAppInitialPropsContext = {
@@ -47,7 +59,8 @@ type DevAppInitialPropsContext = {
   res: unknown;
   pathname: string;
   query: Record<string, unknown>;
-  asPath: string;
+  asPath: string; /** The request-scoped `next/router` server instance when available. */
+  router?: PagesGetInitialPropsRouter;
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
@@ -64,4 +77,4 @@ type DevAppInitialPropsContext = {
  */
 declare function loadDevAppInitialProps(ctx: DevAppInitialPropsContext): Promise<DevAppInitialPropsResult>;
 //#endregion
-export { DevAppInitialPropsContext, DevAppInitialPropsResult, hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };
+export { DevAppInitialPropsContext, DevAppInitialPropsResult, PagesGetInitialPropsRouter, createPagesGetInitialPropsRouter, hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };

package/dist/server/pages-get-initial-props.js

@@ -1,4 +1,18 @@
 //#region src/server/pages-get-initial-props.ts
+/**
+* Build the URL-state subset of Next.js's ServerRouter used by isolated
+* initial-props helpers. Real request handlers pass their full `next/router`
+* instance; this fallback keeps direct helper callers and tests aligned with
+* the same required fields.
+*/
+function createPagesGetInitialPropsRouter(pathname, query, asPath) {
+	return {
+		route: pathname.replace(/\/$/, "") || "/",
+		pathname,
+		query,
+		asPath
+	};
+}
 function isObjectLike(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
 }
@@ -61,11 +75,7 @@ async function loadDevAppInitialProps(ctx) {
 	const initialProps = await loadPagesGetInitialProps(ctx.appComponent, {
 		AppTree: ctx.appTree,
 		Component: ctx.component,
-		router: {
-			pathname: ctx.pathname,
-			query: ctx.query,
-			asPath: ctx.asPath
-		},
+		router: ctx.router ?? createPagesGetInitialPropsRouter(ctx.pathname, ctx.query, ctx.asPath),
 		ctx: {
 			req: ctx.req,
 			res: ctx.res,
@@ -82,11 +92,8 @@ async function loadDevAppInitialProps(ctx) {
 	return {
 		kind: "render",
 		pageProps: isPropsObject(initialPageProps) ? initialPageProps : {},
-		renderProps: isPropsObject(initialProps) ? {
-			...initialProps,
-			pageProps: initialPageProps
-		} : { pageProps: initialPageProps }
+		renderProps: isPropsObject(initialProps) ? initialProps : {}
 	};
 }
 //#endregion
-export { hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };
+export { createPagesGetInitialPropsRouter, hasPagesGetInitialProps, isResponseSent, loadDevAppInitialProps, loadPagesGetInitialProps };

package/dist/server/pages-i18n.js

@@ -93,23 +93,71 @@ function stripI18nLocaleForApiRoute(url, i18nConfig) {
 */
 function detectLocaleFromAcceptLanguage(acceptLang, i18nConfig) {
 	if (!acceptLang) return null;
-	const langs = acceptLang.split(",").map((part) => {
-		const [lang, qPart] = part.trim().split(";");
-		const q = qPart ? parseFloat(qPart.replace("q=", "")) : 1;
-		return {
-			lang: lang.trim().toLowerCase(),
-			q
-		};
-	}).sort((a, b) => b.q - a.q);
-	for (const { lang } of langs) {
-		const exactMatch = i18nConfig.locales.find((locale) => locale.toLowerCase() === lang);
-		if (exactMatch) return exactMatch;
-		const prefix = lang.split("-")[0];
-		const prefixMatch = i18nConfig.locales.find((locale) => {
-			const lowered = locale.toLowerCase();
-			return lowered === prefix || lowered.startsWith(prefix + "-");
+	const configured = /* @__PURE__ */ new Map();
+	let position = 0;
+	for (const locale of i18nConfig.locales) {
+		const lower = locale.toLowerCase();
+		configured.set(lower, {
+			locale,
+			position: position++
 		});
-		if (prefixMatch) return prefixMatch;
+		const parts = lower.split("-");
+		while (parts.length > 1) {
+			parts.pop();
+			const prefix = parts.join("-");
+			if (!configured.has(prefix)) configured.set(prefix, {
+				locale,
+				position: position++
+			});
+		}
+	}
+	const selections = [];
+	const listedTokens = /* @__PURE__ */ new Set();
+	try {
+		const parts = acceptLang.replace(/[ \t]/g, "").split(",");
+		for (let headerPosition = 0; headerPosition < parts.length; headerPosition++) {
+			const part = parts[headerPosition];
+			if (!part) continue;
+			const params = part.split(";");
+			if (params.length > 2) throw new Error("Invalid Accept-Language header");
+			const token = params[0].toLowerCase();
+			if (!token) throw new Error("Invalid Accept-Language header");
+			const selection = {
+				token,
+				headerPosition,
+				quality: 1
+			};
+			const configuredMatch = configured.get(token);
+			if (configuredMatch) selection.preference = configuredMatch.position;
+			listedTokens.add(token);
+			if (params.length === 2) {
+				const [key, value] = params[1].split("=");
+				if (!value || key !== "q" && key !== "Q") throw new Error("Invalid Accept-Language header");
+				const quality = parseFloat(value);
+				if (quality === 0) continue;
+				if (Number.isFinite(quality) && quality >= .001 && quality <= 1) selection.quality = quality;
+			}
+			selections.push(selection);
+		}
+	} catch {
+		return null;
+	}
+	selections.sort((a, b) => {
+		if (b.quality !== a.quality) return b.quality - a.quality;
+		if (a.preference !== b.preference) {
+			if (a.preference === void 0) return 1;
+			if (b.preference === void 0) return -1;
+			return a.preference - b.preference;
+		}
+		return a.headerPosition - b.headerPosition;
+	});
+	for (const { token } of selections) {
+		if (token === "*") {
+			for (const [preference, { locale }] of configured) if (!listedTokens.has(preference)) return locale;
+			continue;
+		}
+		const match = configured.get(token);
+		if (match) return match.locale;
 	}
 	return null;
 }

package/dist/server/pages-node-compat.d.ts

@@ -49,9 +49,11 @@ type PagesRequestCookiesCarrier = {
   cookies?: unknown;
 };
 type CreatePagesReqResOptions = {
+  allowedRevalidateHeaderKeys?: readonly string[];
   body: unknown;
   query: PagesRequestQuery;
   request: Request;
+  trustedRevalidateOrigin?: string;
   url: string;
 };
 type CreatePagesReqResResult = {

package/dist/server/pages-node-compat.js

@@ -121,6 +121,8 @@ var PagesResponseStream = class extends Writable {
 	resolveResponse;
 	rejectResponse;
 	requestHeaders;
+	trustedRevalidateOrigin;
+	allowedRevalidateHeaderKeys;
 	resStatusCode = 200;
 	resHeaders = {};
 	setCookieHeaders = [];
@@ -128,11 +130,13 @@ var PagesResponseStream = class extends Writable {
 	controller = null;
 	bufferedChunks = [];
 	streamEnded = false;
-	constructor(resolveResponse, rejectResponse, requestHeaders) {
+	constructor(resolveResponse, rejectResponse, requestHeaders, trustedRevalidateOrigin, allowedRevalidateHeaderKeys = []) {
 		super();
 		this.resolveResponse = resolveResponse;
 		this.rejectResponse = rejectResponse;
 		this.requestHeaders = requestHeaders;
+		this.trustedRevalidateOrigin = trustedRevalidateOrigin;
+		this.allowedRevalidateHeaderKeys = allowedRevalidateHeaderKeys;
 		this.once("error", (err) => {
 			if (!this.resolved) {
 				this.resolved = true;
@@ -202,7 +206,7 @@ var PagesResponseStream = class extends Writable {
 		return headers;
 	}
 	async revalidate(urlPath, opts) {
-		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts);
+		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts, this.trustedRevalidateOrigin, this.allowedRevalidateHeaderKeys);
 	}
 	setPreviewData(data, options = {}) {
 		setPagesPreviewData(this, data, options);
@@ -299,7 +303,7 @@ function createPagesReqRes(options) {
 		resolveResponse = resolve;
 		rejectResponse = reject;
 	});
-	const res = new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers);
+	const res = new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers, options.trustedRevalidateOrigin ?? new URL(options.request.url).origin, options.allowedRevalidateHeaderKeys);
 	attachPagesPreviewApi(req, res);
 	return {
 		req,