vinext 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/shims/navigation.js

@@ -9,9 +9,9 @@ import { AppRouterContext } from "./internal/app-router-context.js";
 import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-route-owner-direct.js";
 import { toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";

package/dist/shims/request-context.d.ts

@@ -33,7 +33,10 @@ type ExecutionContextLike = {
    * execution context. Typed as `unknown` to keep this module runtime-agnostic;
    * CDN cache adapters that know the concrete shape narrow it themselves.
    */
-  cache?: unknown;
+  cache?: unknown; /** Server-owned origin for credential-bearing Pages revalidation loopbacks. */
+  trustedRevalidateOrigin?: string; /** Worker-owned in-process dispatcher for authenticated Pages revalidation. */
+  dispatchPagesRevalidate?: (request: Request) => Promise<Response>; /** Marks a request currently executing through the internal revalidation dispatcher. */
+  isInternalPagesRevalidation?: boolean;
 };
 /**
  * Run `fn` with the given `ExecutionContext` available via

package/dist/shims/router.js

@@ -1159,13 +1159,12 @@ async function renderPagesNavigationTarget(url, target, props, options, assertSt
 	assertStillCurrent();
 	const React = (await import("react")).default;
 	assertStillCurrent();
-	const rawPageProps = props.pageProps;
-	const pageProps = isUnknownRecord(rawPageProps) ? rawPageProps : {};
+	const pageProps = Object.assign({}, props.pageProps);
+	props.pageProps = pageProps;
 	let element;
 	if (AppComponent) element = React.createElement(AppComponent, {
 		...props,
 		Component: PageComponent,
-		pageProps: rawPageProps,
 		router: singletonRouter
 	});
 	else element = React.createElement(PageComponent, pageProps);
@@ -1312,8 +1311,8 @@ async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillC
 	if (!nextDataJson) scheduleHardNavigationAndThrow(url, "Navigation failed: missing __NEXT_DATA__ in response");
 	const nextData = parseVinextNextDataJson(nextDataJson);
 	const props = nextData.props && typeof nextData.props === "object" ? nextData.props : {};
-	const rawPageProps = props.pageProps;
-	const pageProps = isUnknownRecord(rawPageProps) ? rawPageProps : {};
+	const pageProps = Object.assign({}, props.pageProps);
+	props.pageProps = pageProps;
 	let pageModuleUrl = nextData.__vinext?.pageModuleUrl;
 	if (!pageModuleUrl) {
 		const moduleMatch = html.match(/import\("([^"]+)"\);\s*\n\s*const PageComponent/);
@@ -1355,7 +1354,6 @@ async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillC
 	if (AppComponent) element = React.createElement(AppComponent, {
 		...props,
 		Component: PageComponent,
-		pageProps: rawPageProps,
 		router: singletonRouter
 	});
 	else element = React.createElement(PageComponent, pageProps);
@@ -1647,7 +1645,20 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 				const hashStr = extractHash(resolved);
 				resolved = normalizePathTrailingSlash(`${projection.href.split(/[?#]/, 1)[0]}${searchStr ? `?${searchStr}` : ""}${hashStr}`, __trailingSlash);
 			}
-		} else interpolatedRoute = resolved;
+		} else {
+			const missingParams = projection ? routePatternParts(projection.routePathname).filter((part) => part.startsWith(":") && !part.endsWith("*")).map((part) => part.slice(1, part.endsWith("+") ? -1 : void 0)).filter((paramName) => {
+				const value = projection.query[paramName];
+				return value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
+			}) : [];
+			const hasExplicitHrefPathname = typeof url === "string" || url.pathname !== void 0;
+			const isMiddlewareMatch = options?.shallow !== true && getPagesMiddlewareDataHref(resolved, __basePath) !== null;
+			if (missingParams.length > 0 && hasExplicitHrefPathname && !isMiddlewareMatch) {
+				const asPathname = stripHash(resolved).split("?", 1)[0];
+				const routePathname = projection?.routePathname ?? stripHash(resolvedRoute).split("?", 1)[0];
+				throw new HrefInterpolationError(asPathname === routePathname ? `The provided \`href\` (${resolvedRoute}) value is missing query values (${missingParams.join(", ")}) to be interpolated properly. Read more: https://nextjs.org/docs/messages/href-interpolation-failed` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${routePathname}). Read more: https://nextjs.org/docs/messages/incompatible-href-as`);
+			}
+			interpolatedRoute = resolved;
+		}
 	}
 	const full = normalizePathTrailingSlash(toBrowserNavigationHref(resolved, window.location.href, __basePath), __trailingSlash);
 	const fullRouteUrl = interpolatedRoute !== resolved ? normalizePathTrailingSlash(toBrowserNavigationHref(interpolatedRoute, window.location.href, __basePath), __trailingSlash) : full;

package/dist/shims/script.js

@@ -1,8 +1,8 @@
 "use client";
-import { escapeInlineContent } from "./head.js";
 import { useScriptNonce } from "./script-nonce-context.js";
 import { hasAppNavigationRuntimeBootstrap } from "../client/navigation-runtime.js";
 import { useBeforeInteractiveRegister } from "./before-interactive-context.js";
+import { escapeInlineContent } from "./head.js";
 import React, { useEffect, useRef } from "react";
 import * as ReactDOM from "react-dom";
 //#region src/shims/script.tsx

package/dist/shims/server.d.ts

@@ -230,15 +230,16 @@ declare class ResponseCookies {
   }]): this;
   get(...args: [name: string] | [options: {
     name: string;
-  }]): CookieEntry | undefined;
+  }]): ResponseCookieEntry | undefined;
   has(name: string): boolean;
   getAll(...args: [name: string] | [options: {
     name: string;
-  }] | []): CookieEntry[];
+  }] | []): ResponseCookieEntry[];
   delete(...args: [name: string] | [options: Omit<CookieOptions & {
     name: string;
   }, "maxAge" | "expires">]): this;
-  [Symbol.iterator](): MapIterator<[string, CookieEntry]>;
+  [Symbol.iterator](): MapIterator<[string, ResponseCookieEntry]>;
+  toString(): string;
   /** Delete all Set-Cookie headers and re-append from the internal map. */
   private _syncHeaders;
 }
@@ -249,10 +250,11 @@ type CookieOptions = {
   expires?: Date | number;
   httpOnly?: boolean;
   secure?: boolean;
-  sameSite?: true | false | "strict" | "lax" | "none" | "Strict" | "Lax" | "None";
+  sameSite?: true | false | "strict" | "lax" | "none";
   partitioned?: boolean;
   priority?: "low" | "medium" | "high";
 };
+type ResponseCookieEntry = CookieEntry & CookieOptions;
 type MiddlewareResponseInit = {
   request?: {
     headers?: Headers;
@@ -323,8 +325,7 @@ type UserAgent = {
  *
  * Uses the platform's `waitUntil` (via the per-request ExecutionContext) when
  * available so the task survives past the response on Cloudflare Workers.
- * Falls back to a fire-and-forget microtask on runtimes without an execution
- * context (e.g. Node.js dev server).
+ * Node.js dev drains callbacks from its response finish/close lifecycle.
  *
  * Throws when called inside a cached scope — request-specific
  * side-effects must not leak into cached results.

package/dist/shims/server.js

@@ -1,9 +1,10 @@
+import { bindRequestContextSnapshot, getRequestContext, isInsideUnifiedScope, queueAfterCallback } from "./unified-request-context.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER } from "../server/headers.js";
 import { encodeMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
-import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
+import { validateCookieAttributeValue, validateCookieName } from "./internal/cookie-serialize.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 //#region src/shims/server.ts
@@ -158,12 +159,8 @@ var NextResponse = class NextResponse extends Response {
 	* Create a JSON response.
 	*/
 	static json(body, init) {
-		const headers = new Headers(init?.headers);
-		if (!headers.has("content-type")) headers.set("content-type", "application/json");
-		return new NextResponse(JSON.stringify(body), {
-			...init,
-			headers
-		});
+		const response = Response.json(body, init);
+		return new NextResponse(response.body, response);
 	}
 	/**
 	* Create a redirect response.
@@ -417,7 +414,7 @@ var NextURL = class NextURL {
 		};
 		if (this._trailingSlash) nextConfig.trailingSlash = true;
 		const config = {
-			basePath: this._basePath,
+			basePath: this._configBasePath,
 			nextConfig: Object.keys(nextConfig).length > 0 ? nextConfig : void 0
 		};
 		return new NextURL(this.href, void 0, config);
@@ -554,79 +551,54 @@ var ResponseCookies = class {
 	_parsed = /* @__PURE__ */ new Map();
 	constructor(headers) {
 		this._headers = headers;
-		for (const header of headers.getSetCookie()) {
-			const eq = header.indexOf("=");
-			if (eq === -1) continue;
-			const cookieName = header.slice(0, eq);
-			const semi = header.indexOf(";", eq);
-			const raw = header.slice(eq + 1, semi === -1 ? void 0 : semi);
-			let value;
-			try {
-				value = decodeURIComponent(raw);
-			} catch {
-				value = raw;
-			}
-			this._parsed.set(cookieName, {
-				serialized: header,
-				entry: {
-					name: cookieName,
-					value
-				}
-			});
+		const setCookie = headers.getSetCookie?.() ?? headers.get("set-cookie") ?? [];
+		const cookieStrings = Array.isArray(setCookie) ? setCookie : splitSetCookieString(setCookie);
+		for (const header of cookieStrings) {
+			const entry = parseSetCookieHeader(header);
+			if (entry) this._parsed.set(entry.name, entry);
 		}
 	}
 	set(...args) {
 		const [name, value, opts] = parseCookieSetArgs(args);
 		validateCookieName(name);
-		const sameSite = opts?.sameSite === true ? "Strict" : typeof opts?.sameSite === "string" ? opts.sameSite[0].toUpperCase() + opts.sameSite.slice(1) : void 0;
-		const serialized = serializeSetCookie(name, value, {
-			...opts,
-			expires: typeof opts?.expires === "number" ? new Date(opts.expires) : opts?.expires,
-			sameSite
-		});
-		this._parsed.set(name, {
-			serialized,
-			entry: {
-				name,
-				value
-			}
-		});
+		const entry = normalizeResponseCookie(name, value, opts);
+		validateResponseCookieAttributes(entry);
+		this._parsed.set(name, entry);
 		this._syncHeaders();
 		return this;
 	}
 	get(...args) {
 		const key = typeof args[0] === "string" ? args[0] : args[0].name;
-		return this._parsed.get(key)?.entry;
+		return this._parsed.get(key);
 	}
 	has(name) {
 		return this._parsed.has(name);
 	}
 	getAll(...args) {
-		const all = [...this._parsed.values()].map((v) => v.entry);
+		const all = [...this._parsed.values()];
 		if (args.length === 0) return all;
 		const key = typeof args[0] === "string" ? args[0] : args[0].name;
 		return all.filter((c) => c.name === key);
 	}
 	delete(...args) {
-		const [name, opts] = typeof args[0] === "string" ? [args[0], void 0] : [args[0].name, args[0]];
+		const [name, options] = typeof args[0] === "string" ? [args[0], void 0] : [args[0].name, args[0]];
 		return this.set({
+			...options,
 			name,
 			value: "",
-			expires: /* @__PURE__ */ new Date(0),
-			path: opts?.path,
-			domain: opts?.domain,
-			httpOnly: opts?.httpOnly,
-			secure: opts?.secure,
-			sameSite: opts?.sameSite
+			expires: /* @__PURE__ */ new Date(0)
 		});
 	}
 	[Symbol.iterator]() {
-		return new Map([...this._parsed.values()].map(({ entry }) => [entry.name, entry])).entries();
+		return new Map([...this._parsed.values()].map((entry) => [entry.name, entry])).entries();
+	}
+	toString() {
+		return [...this._parsed.values()].map(stringifyResponseCookie).join("; ");
 	}
 	/** Delete all Set-Cookie headers and re-append from the internal map. */
 	_syncHeaders() {
 		this._headers.delete("Set-Cookie");
-		for (const { serialized } of this._parsed.values()) this._headers.append("Set-Cookie", serialized);
+		for (const entry of this._parsed.values()) this._headers.append("Set-Cookie", stringifyResponseCookie(entry));
 	}
 };
 var MiddlewareResponseCookies = class extends ResponseCookies {
@@ -654,6 +626,115 @@ var MiddlewareResponseCookies = class extends ResponseCookies {
 		this._responseHeaders.set(MIDDLEWARE_SET_COOKIE_HEADER, cookies.join(","));
 	}
 };
+function normalizeResponseCookie(name, value, options) {
+	const cookie = {
+		name,
+		value,
+		...options
+	};
+	if (typeof cookie.expires === "number") cookie.expires = new Date(cookie.expires);
+	if (cookie.maxAge) cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+	if (cookie.path == null) cookie.path = "/";
+	return cookie;
+}
+function parseSetCookieHeader(header) {
+	if (!header) return void 0;
+	const [[name, value], ...attributes] = parseResponseCookiePairs(header);
+	const { domain, expires, httponly, maxage, path, samesite, secure, partitioned, priority } = Object.fromEntries(attributes.map(([key, attributeValue]) => [key.toLowerCase().replaceAll("-", ""), attributeValue]));
+	return compactResponseCookie({
+		name,
+		value: decodeURIComponent(value),
+		domain,
+		...expires && { expires: new Date(expires) },
+		...httponly && { httpOnly: true },
+		...typeof maxage === "string" && { maxAge: Number(maxage) },
+		path,
+		...samesite && { sameSite: parseResponseCookieSameSite(samesite) },
+		...secure && { secure: true },
+		...priority && { priority: parseResponseCookiePriority(priority) },
+		...partitioned && { partitioned: true }
+	});
+}
+function parseResponseCookiePairs(cookie) {
+	const map = /* @__PURE__ */ new Map();
+	for (const pair of cookie.split(/; */)) {
+		if (!pair) continue;
+		const splitAt = pair.indexOf("=");
+		if (splitAt === -1) {
+			map.set(pair, "true");
+			continue;
+		}
+		const key = pair.slice(0, splitAt);
+		const value = pair.slice(splitAt + 1);
+		try {
+			map.set(key, decodeURIComponent(value ?? "true"));
+		} catch {}
+	}
+	return map;
+}
+function compactResponseCookie(cookie) {
+	const compact = {};
+	for (const key in cookie) if (cookie[key]) compact[key] = cookie[key];
+	return compact;
+}
+function parseResponseCookieSameSite(value) {
+	const sameSite = value.toLowerCase();
+	return sameSite === "strict" || sameSite === "lax" || sameSite === "none" ? sameSite : void 0;
+}
+function parseResponseCookiePriority(value) {
+	const priority = value.toLowerCase();
+	return priority === "low" || priority === "medium" || priority === "high" ? priority : void 0;
+}
+function validateResponseCookieAttributes(cookie) {
+	if (cookie.path) validateCookieAttributeValue(cookie.path, "Path");
+	if (cookie.domain) validateCookieAttributeValue(cookie.domain, "Domain");
+}
+function stringifyResponseCookie(cookie) {
+	const attributes = [
+		cookie.path && `Path=${cookie.path}`,
+		(cookie.expires || cookie.expires === 0) && `Expires=${(typeof cookie.expires === "number" ? new Date(cookie.expires) : cookie.expires).toUTCString()}`,
+		typeof cookie.maxAge === "number" && `Max-Age=${cookie.maxAge}`,
+		cookie.domain && `Domain=${cookie.domain}`,
+		cookie.secure && "Secure",
+		cookie.httpOnly && "HttpOnly",
+		cookie.sameSite && `SameSite=${cookie.sameSite}`,
+		cookie.partitioned && "Partitioned",
+		cookie.priority && `Priority=${cookie.priority}`
+	].filter(Boolean);
+	const stringified = `${cookie.name}=${encodeURIComponent(cookie.value ?? "")}`;
+	return attributes.length === 0 ? stringified : `${stringified}; ${attributes.join("; ")}`;
+}
+function splitSetCookieString(value) {
+	const cookies = [];
+	let position = 0;
+	let start = 0;
+	const skipWhitespace = () => {
+		while (position < value.length && /\s/.test(value.charAt(position))) position++;
+		return position < value.length;
+	};
+	while (position < value.length) {
+		start = position;
+		let separatorFound = false;
+		while (skipWhitespace()) {
+			if (value.charAt(position) !== ",") {
+				position++;
+				continue;
+			}
+			const lastComma = position++;
+			skipWhitespace();
+			const nextStart = position;
+			while (position < value.length && !"=;,".includes(value.charAt(position))) position++;
+			if (position < value.length && value.charAt(position) === "=") {
+				separatorFound = true;
+				position = nextStart;
+				cookies.push(value.substring(start, lastComma));
+				start = position;
+			} else position = lastComma + 1;
+		}
+		if (!separatorFound || position >= value.length) cookies.push(value.substring(start));
+	}
+	return cookies;
+}
 /**
 * Parse the overloaded arguments for ResponseCookies.set():
 *   - (name, value, options?) — positional form
@@ -730,18 +811,36 @@ function userAgent({ headers }) {
 *
 * Uses the platform's `waitUntil` (via the per-request ExecutionContext) when
 * available so the task survives past the response on Cloudflare Workers.
-* Falls back to a fire-and-forget microtask on runtimes without an execution
-* context (e.g. Node.js dev server).
+* Node.js dev drains callbacks from its response finish/close lifecycle.
 *
 * Throws when called inside a cached scope — request-specific
 * side-effects must not leak into cached results.
 */
 function after(task) {
 	_throwIfInsideCacheScope("after()");
-	const guarded = (typeof task === "function" ? Promise.resolve().then(task) : task).catch((err) => {
-		console.error("[vinext] after() task failed:", err);
-	});
-	getRequestExecutionContext()?.waitUntil(guarded);
+	const requestContext = isInsideUnifiedScope() ? getRequestContext() : null;
+	if (!requestContext) {
+		const executionContext = getRequestExecutionContext();
+		if (executionContext) {
+			if (typeof task !== "function" && (task == null || typeof task.then !== "function")) throw new TypeError("`after()`: Argument must be a promise or a function");
+			const promise = typeof task === "function" ? Promise.resolve().then(task) : task;
+			const guarded = Promise.resolve(promise).catch((error) => {
+				console.error("[vinext] after() task failed:", error);
+			});
+			executionContext.waitUntil(guarded);
+			return;
+		}
+		throw new Error("`after()` was called outside a request scope");
+	}
+	if (typeof task !== "function") {
+		if (task == null || typeof task.then !== "function") throw new TypeError("`after()`: Argument must be a promise or a function");
+		const guarded = Promise.resolve(task).catch((error) => {
+			console.error("[vinext] after() task failed:", error);
+		});
+		getRequestExecutionContext()?.waitUntil(guarded);
+		return;
+	}
+	queueAfterCallback(requestContext, bindRequestContextSnapshot(requestContext, task));
 }
 /**
 * connection() — signals that the response requires a live connection

package/dist/shims/unified-request-context.d.ts

@@ -18,13 +18,32 @@ import { NavigationState } from "./navigation-state.js";
  */
 type UnifiedRequestContext = {
   /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */executionContext: ExecutionContextLike | null; /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
-  requestCache: WeakMap<(...args: any[]) => any, unknown>;
+  requestCache: WeakMap<(...args: any[]) => any, unknown>; /** Shared lifecycle state for work deferred until the response closes. */
+  afterContext: AfterRequestContext;
 } & VinextHeadersShimState & I18nState & NavigationState & CacheState & PrivateCacheState & FetchCacheState & RouterState & HeadState & RootParamsState;
+type AfterRequestContext = {
+  callbacks: Array<() => unknown>;
+  responseClosed: boolean;
+  pendingCallbacks: number;
+  completion: Promise<void> | null;
+  resolveCompletion: (() => void) | null;
+};
 /**
  * Create a fresh `UnifiedRequestContext` with defaults for all fields.
  * Pass partial overrides for the fields you need to pre-populate.
  */
 declare function createRequestContext(opts?: Partial<UnifiedRequestContext>): UnifiedRequestContext;
+/** Queue a callback until response close, or start it immediately once closed. */
+declare function queueAfterCallback(ctx: UnifiedRequestContext, callback: () => unknown): void;
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+declare function bindRequestContextSnapshot<T>(ctx: UnifiedRequestContext, callback: () => T): () => T;
+/**
+ * Release function-form `after()` work once the response body has closed.
+ * All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
+ */
+declare function closeAfterResponse(ctx: UnifiedRequestContext): Promise<void>;
+/** Wrap a response so deferred callbacks start on stream completion or cancellation. */
+declare function closeAfterResponseWithBody(response: Response, ctx: UnifiedRequestContext): Response;
 /**
  * Run `fn` within a unified request context scope.
  * All shim modules will read/write their state from `ctx` for the
@@ -65,4 +84,4 @@ declare function getRequestContext(): UnifiedRequestContext;
  */
 declare function isInsideUnifiedScope(): boolean;
 //#endregion
-export { UnifiedRequestContext, createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export { AfterRequestContext, UnifiedRequestContext, bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };

package/dist/shims/unified-request-context.js

@@ -43,6 +43,13 @@ function createRequestContext(opts) {
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
 		executionContext: _getInheritedExecutionContext(),
 		requestCache: /* @__PURE__ */ new WeakMap(),
+		afterContext: {
+			callbacks: [],
+			responseClosed: false,
+			pendingCallbacks: 0,
+			completion: null,
+			resolveCompletion: null
+		},
 		ssrContext: null,
 		ssrHeadChildren: [],
 		documentInitialHead: [],
@@ -50,6 +57,80 @@ function createRequestContext(opts) {
 		...opts
 	};
 }
+function ensureAfterCompletion(ctx) {
+	const state = ctx.afterContext;
+	if (state.resolveCompletion && state.completion) return;
+	let resolveCompletion;
+	const completion = new Promise((resolve) => {
+		resolveCompletion = resolve;
+	});
+	state.completion = completion;
+	state.resolveCompletion = resolveCompletion;
+	ctx.executionContext?.waitUntil(completion);
+}
+function finishAfterCallbacksIfIdle(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed || state.pendingCallbacks !== 0 || state.callbacks.length !== 0 || !state.resolveCompletion) return;
+	const resolveCompletion = state.resolveCompletion;
+	state.resolveCompletion = null;
+	resolveCompletion();
+}
+function startAfterCallback(ctx, callback) {
+	const state = ctx.afterContext;
+	ensureAfterCompletion(ctx);
+	state.pendingCallbacks += 1;
+	Promise.resolve().then(callback).catch((error) => {
+		console.error("[vinext] after() task failed:", error);
+	}).finally(() => {
+		state.pendingCallbacks -= 1;
+		finishAfterCallbacksIfIdle(ctx);
+	});
+}
+/** Queue a callback until response close, or start it immediately once closed. */
+function queueAfterCallback(ctx, callback) {
+	ensureAfterCompletion(ctx);
+	if (ctx.afterContext.responseClosed) startAfterCallback(ctx, callback);
+	else ctx.afterContext.callbacks.push(callback);
+}
+/** Bind a callback to every AsyncLocalStorage context active at registration. */
+function bindRequestContextSnapshot(ctx, callback) {
+	const constructor = _als.constructor;
+	try {
+		const runInSnapshot = constructor.snapshot?.();
+		if (runInSnapshot) return () => runInSnapshot(callback);
+	} catch {}
+	return () => _als.run(ctx, callback);
+}
+/**
+* Release function-form `after()` work once the response body has closed.
+* All queued callbacks start together, matching Next.js' unbounded PromiseQueue.
+*/
+async function closeAfterResponse(ctx) {
+	const state = ctx.afterContext;
+	if (!state.responseClosed) {
+		state.responseClosed = true;
+		const callbacks = state.callbacks.splice(0);
+		for (const callback of callbacks) startAfterCallback(ctx, callback);
+		finishAfterCallbacksIfIdle(ctx);
+	}
+	return state.completion ?? Promise.resolve();
+}
+/** Wrap a response so deferred callbacks start on stream completion or cancellation. */
+function closeAfterResponseWithBody(response, ctx) {
+	if (!response.body) {
+		queueMicrotask(() => void closeAfterResponse(ctx));
+		return response;
+	}
+	const passthrough = new TransformStream();
+	response.body.pipeTo(passthrough.writable).then(() => void closeAfterResponse(ctx), () => void closeAfterResponse(ctx));
+	const wrapped = new Response(passthrough.readable, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	wrapped.__vinextStreamedHtmlResponse = response.__vinextStreamedHtmlResponse;
+	return wrapped;
+}
 function runWithRequestContext(ctx, fn) {
 	return _als.run(ctx, fn);
 }
@@ -86,4 +167,4 @@ function isInsideUnifiedScope() {
 	return _als.getStore() != null;
 }
 //#endregion
-export { createRequestContext, getRequestContext, isInsideUnifiedScope, runWithRequestContext, runWithUnifiedStateMutation };
+export { bindRequestContextSnapshot, closeAfterResponse, closeAfterResponseWithBody, createRequestContext, getRequestContext, isInsideUnifiedScope, queueAfterCallback, runWithRequestContext, runWithUnifiedStateMutation };

package/dist/utils/cache-control-metadata.d.ts

@@ -1,4 +1,5 @@
 //#region src/utils/cache-control-metadata.d.ts
 declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
+declare function readCacheControlRevalidateField(ctx: Record<string, unknown> | undefined): number | false | undefined;
 //#endregion
-export { readCacheControlNumberField };
+export { readCacheControlNumberField, readCacheControlRevalidateField };

package/dist/utils/cache-control-metadata.js

@@ -8,5 +8,9 @@ function readCacheControlNumberField(ctx, field) {
 	const value = readRecordField(ctx, "cacheControl")?.[field] ?? ctx?.[field];
 	return typeof value === "number" ? value : void 0;
 }
+function readCacheControlRevalidateField(ctx) {
+	const value = readRecordField(ctx, "cacheControl")?.revalidate ?? ctx?.revalidate;
+	return typeof value === "number" || value === false ? value : void 0;
+}
 //#endregion
-export { readCacheControlNumberField };
+export { readCacheControlNumberField, readCacheControlRevalidateField };

package/dist/utils/html-limited-bots.js

@@ -1,5 +1,5 @@
 //#region src/utils/html-limited-bots.ts
-const HTML_LIMITED_BOT_UA_RE_STRING = String.raw`[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight`;
+const HTML_LIMITED_BOT_UA_RE_STRING = String.raw`[\w-]+-Google|Google-[\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|meta-externalagent|meta-externalfetcher|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight`;
 const HEADLESS_BROWSER_BOT_UA_RE = /Googlebot(?!-)|Googlebot$/i;
 const htmlLimitedBotRegexCache = /* @__PURE__ */ new Map();
 function getHtmlLimitedBotRegex(htmlLimitedBots) {

package/dist/utils/protocol-headers.d.ts

@@ -7,6 +7,8 @@ declare const VINEXT_PRERENDER_SECRET_HEADER = "x-vinext-prerender-secret";
 declare const VINEXT_PRERENDER_ROUTE_PARAMS_HEADER = "x-vinext-prerender-route-params";
 /** Indicates a build-time prerender render is probing whether a route can be static. */
 declare const VINEXT_PRERENDER_SPECULATIVE_HEADER = "x-vinext-prerender-speculative";
+/** Logical hostname carried only by authenticated Node revalidation loopbacks. */
+declare const VINEXT_REVALIDATE_HOST_HEADER = "x-vinext-revalidate-host";
 /** Prefix for forwarded request headers (e.g. `x-middleware-request-cookie`). */
 declare const MIDDLEWARE_REQUEST_HEADER_PREFIX = "x-middleware-request-";
 /** Comma-separated list of header names that middleware wants to override. */
@@ -19,5 +21,9 @@ declare const MIDDLEWARE_CACHE_HEADER = "x-middleware-cache";
 declare const MIDDLEWARE_SKIP_HEADER = "x-middleware-skip";
 /** Generic prefix for all middleware internal headers. */
 declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-";
+/** Authenticates an internal Pages Router on-demand revalidation request. */
+declare const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/** Restricts on-demand revalidation to paths that were already generated. */
+declare const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
 //#endregion
-export { MIDDLEWARE_CACHE_HEADER, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER };
+export { MIDDLEWARE_CACHE_HEADER, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_HEADER };

package/dist/utils/protocol-headers.js

@@ -7,6 +7,8 @@ const VINEXT_PRERENDER_SECRET_HEADER = "x-vinext-prerender-secret";
 const VINEXT_PRERENDER_ROUTE_PARAMS_HEADER = "x-vinext-prerender-route-params";
 /** Indicates a build-time prerender render is probing whether a route can be static. */
 const VINEXT_PRERENDER_SPECULATIVE_HEADER = "x-vinext-prerender-speculative";
+/** Logical hostname carried only by authenticated Node revalidation loopbacks. */
+const VINEXT_REVALIDATE_HOST_HEADER = "x-vinext-revalidate-host";
 /** Prefix for forwarded request headers (e.g. `x-middleware-request-cookie`). */
 const MIDDLEWARE_REQUEST_HEADER_PREFIX = "x-middleware-request-";
 /** Comma-separated list of header names that middleware wants to override. */
@@ -19,5 +21,9 @@ const MIDDLEWARE_CACHE_HEADER = "x-middleware-cache";
 const MIDDLEWARE_SKIP_HEADER = "x-middleware-skip";
 /** Generic prefix for all middleware internal headers. */
 const MIDDLEWARE_HEADER_PREFIX = "x-middleware-";
+/** Authenticates an internal Pages Router on-demand revalidation request. */
+const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+/** Restricts on-demand revalidation to paths that were already generated. */
+const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
 //#endregion
-export { MIDDLEWARE_CACHE_HEADER, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER };
+export { MIDDLEWARE_CACHE_HEADER, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_OVERRIDE_HEADERS, MIDDLEWARE_REQUEST_HEADER_PREFIX, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_HEADER };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {