vinext 1.0.0-beta.2 → 1.0.0-beta.4

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/slot.d.ts

@@ -25,6 +25,7 @@ type MergeElementsOptions = {
   preservePreviousSlotIds?: readonly string[];
 };
 declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
+declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
 declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;
 declare function Slot({
   id,
@@ -42,4 +43,4 @@ declare function ParallelSlot({
   name: string;
 }): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React$1.ReactNode> | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | React$1.ReactPortal | null | undefined> | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
 //#endregion
-export { BfcacheSlotEntry, BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };
+export { BfcacheSlotEntry, BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, getNonCacheComponentsSegmentKey, mergeElements, updateBfcacheSlotEntryOrder };

package/dist/shims/slot.js

@@ -137,6 +137,10 @@ function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, Se
 		})
 	}, entry.stateKey)) });
 }
+function getNonCacheComponentsSegmentKey(id, activeStateKey) {
+	const parsed = AppElementsWire.parseElementKey(id);
+	return parsed?.kind === "page" || parsed?.kind === "slot" && parsed.name === "children" ? activeStateKey : void 0;
+}
 function BfcacheSlotBoundary({ content, id }) {
 	const SegmentContext = BfcacheSegmentIdContext;
 	const elements = React$1.useContext(ElementsContext);
@@ -150,7 +154,7 @@ function BfcacheSlotBoundary({ content, id }) {
 	if (!isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(SegmentContext.Provider, {
 		value: id,
 		children: content
-	});
+	}, getNonCacheComponentsSegmentKey(id, activeStateKey));
 	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
 		activeStateKey,
 		content,
@@ -224,4 +228,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };
+export { BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, getNonCacheComponentsSegmentKey, mergeElements, updateBfcacheSlotEntryOrder };

package/dist/shims/streamed-icons.d.ts

@@ -0,0 +1,9 @@
+//#region src/shims/streamed-icons.d.ts
+declare function reconcileStreamedIcons(metadataKey: string): void;
+declare function StreamedIconsInsertion({
+  metadataKey
+}: {
+  metadataKey: string;
+}): null;
+//#endregion
+export { StreamedIconsInsertion, reconcileStreamedIcons };

package/dist/shims/streamed-icons.js

@@ -0,0 +1,33 @@
+"use client";
+import { useLayoutEffect } from "react";
+//#region src/shims/streamed-icons.tsx
+const STREAMED_ICON_ATTRIBUTE = "data-vinext-streamed-icon";
+function getStreamedIconOrder(icon, metadataKey) {
+	const marker = icon.getAttribute(STREAMED_ICON_ATTRIBUTE);
+	const prefix = `${metadataKey}:`;
+	if (!marker?.startsWith(prefix)) return null;
+	const order = Number(marker.slice(prefix.length));
+	return Number.isInteger(order) && order >= 0 ? order : null;
+}
+function reconcileStreamedIcons(metadataKey) {
+	document.querySelectorAll(`body link[${STREAMED_ICON_ATTRIBUTE}]`).forEach((icon) => document.head.appendChild(icon));
+	const ownedIcons = [...document.querySelectorAll(`head link[${STREAMED_ICON_ATTRIBUTE}]`)];
+	const retainedIcons = /* @__PURE__ */ new Map();
+	for (const icon of ownedIcons) {
+		const order = getStreamedIconOrder(icon, metadataKey);
+		if (order === null) {
+			icon.remove();
+			continue;
+		}
+		const previousIcon = retainedIcons.get(order);
+		if (previousIcon) previousIcon.remove();
+		retainedIcons.set(order, icon);
+	}
+	for (const [, icon] of [...retainedIcons].sort(([leftOrder], [rightOrder]) => leftOrder - rightOrder)) document.head.appendChild(icon);
+}
+function StreamedIconsInsertion({ metadataKey }) {
+	useLayoutEffect(() => reconcileStreamedIcons(metadataKey), [metadataKey]);
+	return null;
+}
+//#endregion
+export { StreamedIconsInsertion, reconcileStreamedIcons };

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.4",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {