vinext 1.3.0 → 1.4.0

package/dist/server/default-http-access-fallback-modules.d.ts

@@ -0,0 +1,33 @@
+import DefaultForbidden from "../shims/default-forbidden.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
+//#region src/server/default-http-access-fallback-modules.d.ts
+/**
+ * Module-shaped wrappers around vinext's built-in not-found, forbidden and
+ * unauthorized components. Used as the fallback when an app does not define
+ * its own `app/not-found.tsx` (and has not opted into
+ * `app/global-not-found.tsx`), `app/forbidden.tsx` or `app/unauthorized.tsx`.
+ * The runtime treats any `{ default: Component }` record as a boundary
+ * module, so wrapping the components this way lets us thread the defaults
+ * through the existing boundary plumbing without introducing a parallel code
+ * path.
+ *
+ * Mirrors Next.js's `builtin/not-found.js`, `builtin/forbidden.js` and
+ * `builtin/unauthorized.js`, which the app loader selects for the root
+ * segment when the user has not supplied the file:
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+ * https://github.com/vercel/next.js/blob/canary/crates/next-core/src/app_structure.rs
+ */
+export declare const DEFAULT_NOT_FOUND_MODULE: {
+  readonly default: typeof DefaultNotFound;
+};
+export declare const DEFAULT_FORBIDDEN_MODULE: {
+  readonly default: typeof DefaultForbidden;
+};
+export declare const DEFAULT_UNAUTHORIZED_MODULE: {
+  readonly default: typeof DefaultUnauthorized;
+};
+export declare function getDefaultHttpAccessFallbackModule(statusCode: number): {
+  readonly default: typeof DefaultNotFound;
+} | null;
+//#endregion

package/dist/server/default-http-access-fallback-modules.js

@@ -0,0 +1,31 @@
+import DefaultForbidden from "../shims/default-forbidden.js";
+import DefaultNotFound from "../shims/default-not-found.js";
+import DefaultUnauthorized from "../shims/default-unauthorized.js";
+//#region src/server/default-http-access-fallback-modules.ts
+/**
+* Module-shaped wrappers around vinext's built-in not-found, forbidden and
+* unauthorized components. Used as the fallback when an app does not define
+* its own `app/not-found.tsx` (and has not opted into
+* `app/global-not-found.tsx`), `app/forbidden.tsx` or `app/unauthorized.tsx`.
+* The runtime treats any `{ default: Component }` record as a boundary
+* module, so wrapping the components this way lets us thread the defaults
+* through the existing boundary plumbing without introducing a parallel code
+* path.
+*
+* Mirrors Next.js's `builtin/not-found.js`, `builtin/forbidden.js` and
+* `builtin/unauthorized.js`, which the app loader selects for the root
+* segment when the user has not supplied the file:
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+* https://github.com/vercel/next.js/blob/canary/crates/next-core/src/app_structure.rs
+*/
+const DEFAULT_NOT_FOUND_MODULE = { default: DefaultNotFound };
+const DEFAULT_FORBIDDEN_MODULE = { default: DefaultForbidden };
+const DEFAULT_UNAUTHORIZED_MODULE = { default: DefaultUnauthorized };
+function getDefaultHttpAccessFallbackModule(statusCode) {
+	if (statusCode === 404) return DEFAULT_NOT_FOUND_MODULE;
+	if (statusCode === 403) return DEFAULT_FORBIDDEN_MODULE;
+	if (statusCode === 401) return DEFAULT_UNAUTHORIZED_MODULE;
+	return null;
+}
+//#endregion
+export { DEFAULT_FORBIDDEN_MODULE, DEFAULT_NOT_FOUND_MODULE, DEFAULT_UNAUTHORIZED_MODULE, getDefaultHttpAccessFallbackModule };

package/dist/server/defer-until-stream-consumed.d.ts

@@ -1,7 +1,41 @@
 //#region src/server/defer-until-stream-consumed.d.ts
+export type StreamConsumptionCallbacks = {
+  /** Runs once when the consumer reads the first chunk. */
+  onStart?: () => void;
+  /** Runs once when the stream ends, errors or is cancelled. */
+  onFlush?: () => void;
+  onError?: (error: unknown) => void;
+  onCancel?: (reason: unknown) => void;
+};
 /**
  * Defers cleanup until the downstream consumer drains or cancels the stream.
  * `onCancel` runs before the cancellation reaches the source stream.
  */
 export declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, onFlush: () => void, onError?: (error: unknown) => void, onCancel?: (reason: unknown) => void): ReadableStream<Uint8Array>;
+/**
+ * Runs the callbacks as the downstream consumer reads the stream: `onStart`
+ * when it reads the first chunk, the others when the stream ends, errors or
+ * is cancelled.
+ *
+ * The wrapper reads the source directly instead of piping it through an
+ * identity `TransformStream`, and a wrapper that is wrapped again before
+ * anything reads it takes on the new callbacks instead of adding a layer.
+ * Every streamed response passes through several of these, and each layer
+ * cost a pipe, two more streams and their promise hops per chunk. Nothing is
+ * read ahead of the consumer, so an unread wrapper is still untouched.
+ *
+ * The callbacks run as separate layers would run them. Start, flush and error
+ * callbacks run innermost first, and a layer sees the error an inner layer's
+ * callback threw as its stream error, or the error its own flush callback
+ * threw. Cancel callbacks run outermost first. A layer whose error or cancel
+ * callback throws doesn't run its flush callback. When a start callback
+ * throws, that layer and the layers outside it see the error, and the layers
+ * inside it are cancelled with it. As with the pipe, each layer's callbacks
+ * run in the async context that added them, and the source is read and
+ * cancelled in the context of the first layer. Cleanup reads and clears
+ * request-scoped state, and spans the source starts while producing chunks
+ * need their request parent, but the consumer (the runtime sending the body)
+ * reads from outside that scope.
+ */
+export declare function observeStreamConsumption(stream: ReadableStream<Uint8Array>, callbacks: StreamConsumptionCallbacks): ReadableStream<Uint8Array>;
 //#endregion

package/dist/server/defer-until-stream-consumed.js

@@ -1,37 +1,170 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/server/defer-until-stream-consumed.ts
+const UNREAD_WRAPPERS_KEY = Symbol.for("vinext.deferUntilStreamConsumed.unreadWrappers");
+const unreadWrappers = globalThis[UNREAD_WRAPPERS_KEY] ??= /* @__PURE__ */ new WeakMap();
 /**
 * Defers cleanup until the downstream consumer drains or cancels the stream.
 * `onCancel` runs before the cancellation reaches the source stream.
 */
 function deferUntilStreamConsumed(stream, onFlush, onError, onCancel) {
-	let called = false;
-	const once = () => {
-		if (!called) {
-			called = true;
-			onFlush();
+	return observeStreamConsumption(stream, {
+		onFlush,
+		onError,
+		onCancel
+	});
+}
+/**
+* Runs the callbacks as the downstream consumer reads the stream: `onStart`
+* when it reads the first chunk, the others when the stream ends, errors or
+* is cancelled.
+*
+* The wrapper reads the source directly instead of piping it through an
+* identity `TransformStream`, and a wrapper that is wrapped again before
+* anything reads it takes on the new callbacks instead of adding a layer.
+* Every streamed response passes through several of these, and each layer
+* cost a pipe, two more streams and their promise hops per chunk. Nothing is
+* read ahead of the consumer, so an unread wrapper is still untouched.
+*
+* The callbacks run as separate layers would run them. Start, flush and error
+* callbacks run innermost first, and a layer sees the error an inner layer's
+* callback threw as its stream error, or the error its own flush callback
+* threw. Cancel callbacks run outermost first. A layer whose error or cancel
+* callback throws doesn't run its flush callback. When a start callback
+* throws, that layer and the layers outside it see the error, and the layers
+* inside it are cancelled with it. As with the pipe, each layer's callbacks
+* run in the async context that added them, and the source is read and
+* cancelled in the context of the first layer. Cleanup reads and clears
+* request-scoped state, and spans the source starts while producing chunks
+* need their request parent, but the consumer (the runtime sending the body)
+* reads from outside that scope.
+*/
+function observeStreamConsumption(stream, callbacks) {
+	const layer = {
+		...callbacks,
+		runInCreationContext: AsyncLocalStorage.snapshot()
+	};
+	const unread = unreadWrappers.get(stream);
+	if (unread && !stream.locked) {
+		unread.push(layer);
+		return stream;
+	}
+	const layers = [layer];
+	let started = false;
+	let settled = false;
+	const finish = (sourceFailure, first = 0, end = layers.length) => {
+		let failure = sourceFailure;
+		for (const current of layers.slice(first, end)) current.runInCreationContext(() => {
+			const reportedError = failure !== void 0;
+			try {
+				if (failure) current.onError?.(failure.error);
+			} catch (error) {
+				failure = { error };
+				return;
+			}
+			try {
+				current.onFlush?.();
+			} catch (error) {
+				failure = { error };
+				if (reportedError) return;
+				try {
+					current.onError?.(error);
+				} catch (callbackError) {
+					failure = { error: callbackError };
+				}
+			}
+		});
+		return failure;
+	};
+	const cancelLayers = (reason, end) => {
+		let failure;
+		for (const current of layers.slice(0, end).reverse()) current.runInCreationContext(() => {
+			try {
+				current.onCancel?.(reason);
+			} catch (error) {
+				failure ??= { error };
+				return;
+			}
+			try {
+				current.onFlush?.();
+			} catch (error) {
+				failure ??= { error };
+			}
+		});
+		return failure;
+	};
+	const start = () => {
+		for (const [index, current] of layers.entries()) {
+			try {
+				current.runInCreationContext(() => current.onStart?.());
+			} catch (error) {
+				return {
+					error,
+					index
+				};
+			}
+			if (settled) return void 0;
 		}
 	};
-	const cleanup = new TransformStream({ flush() {
-		once();
-	} });
-	const reader = stream.pipeThrough(cleanup).getReader();
-	return new ReadableStream({
+	const reader = stream.getReader();
+	const release = () => {
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	const wrapped = new ReadableStream({
 		pull(controller) {
-			return reader.read().then(({ done, value }) => {
-				if (done) controller.close();
-				else controller.enqueue(value);
+			unreadWrappers.delete(wrapped);
+			return layer.runInCreationContext(() => reader.read()).then(({ done, value }) => {
+				if (settled) return;
+				if (!done) {
+					if (!started) {
+						started = true;
+						const startFailure = start();
+						if (settled) return;
+						if (startFailure) {
+							settled = true;
+							const { error, index } = startFailure;
+							let failure = finish({ error }, index, index + 1);
+							cancelLayers(error, index);
+							layer.runInCreationContext(() => reader.cancel(error)).catch(() => {}).finally(release);
+							failure = finish(failure, index + 1);
+							controller.error(failure?.error);
+							return;
+						}
+					}
+					controller.enqueue(value);
+					return;
+				}
+				settled = true;
+				release();
+				const failure = finish(void 0);
+				if (failure) controller.error(failure.error);
+				else controller.close();
 			}, (error) => {
-				onError?.(error);
-				once();
-				controller.error(error);
+				if (settled) return;
+				settled = true;
+				release();
+				controller.error(finish({ error })?.error);
 			});
 		},
 		cancel(reason) {
-			onCancel?.(reason);
-			once();
-			return reader.cancel(reason);
+			unreadWrappers.delete(wrapped);
+			let failure;
+			if (!settled) {
+				settled = true;
+				failure = cancelLayers(reason, layers.length);
+			}
+			const cancelled = layer.runInCreationContext(() => reader.cancel(reason)).finally(release);
+			if (!failure) return cancelled;
+			const { error } = failure;
+			const fail = () => {
+				throw error;
+			};
+			return cancelled.then(fail, fail);
 		}
-	});
+	}, { highWaterMark: 0 });
+	unreadWrappers.set(wrapped, layers);
+	return wrapped;
 }
 //#endregion
-export { deferUntilStreamConsumed };
+export { deferUntilStreamConsumed, observeStreamConsumption };

package/dist/server/dev-lockfile.d.ts

@@ -19,6 +19,9 @@
  *   (`process.kill(pid, 0)`), which is good enough for the dev-server
  *   "another server is running" use case. Race conditions on lock acquisition
  *   are tolerated: at worst, two dev servers race and one fails to bind a port.
+ *   Unlike a `flock()`, the lock file survives a hard restart, so a lock
+ *   written before the current boot is treated as stale whatever its PID: the
+ *   PID may now belong to an unrelated process. See `predatesCurrentBoot()`.
  * - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'
  *   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin
  *   to cache self-hosted Google Fonts, so this re-uses the same project-local
@@ -62,6 +65,31 @@ export declare function readLockfile(lockfilePath: string): DevServerInfo | unde
  * signal it (in which case it's still running, just owned by someone else).
  */
 export declare function isPidAlive(pid: number): boolean;
+/**
+ * Returns true if a lock with the given `startedAt` was written before the
+ * machine last booted.
+ *
+ * Such a lock was left behind by a session whose exit handler never ran (a
+ * crash, a forced restart, power loss). PIDs are handed out again after a
+ * boot, so the lock's PID may be held by an unrelated process, and
+ * `isPidAlive()` alone would report the dead server as running.
+ *
+ * The boot time is derived from `Date.now() - os.uptime()`. Stepping the wall
+ * clock forward moves it too (`os.uptime()` doesn't change), so a forward
+ * step larger than the uptime at which a server started makes its lock look
+ * stale, e.g. a VM resuming after the host slept. The second `vinext dev`
+ * then takes over, as in the acquisition race tolerated below: Vite moves it
+ * to another port, or it fails to bind with `strictPort`.
+ *
+ * Known limitations, where a lock is still checked by PID alone:
+ * - A wall clock that comes back from a reboot behind the previous session
+ *   (an RTC running slow, or NTP stepping it back) can leave the lock's
+ *   `startedAt` after the derived boot time.
+ * - Windows Fast Startup shuts down by hibernating the kernel, so
+ *   `os.uptime()` keeps counting across that shutdown.
+ * - A container restart doesn't reset the host's uptime.
+ */
+export declare function predatesCurrentBoot(startedAt: number): boolean;
 type FormatErrorOptions = {
   /** Existing server info from the lock file, if readable. */
   existing: DevServerInfo | undefined;
@@ -87,7 +115,8 @@ type AcquireOptions = {
   /** Initial server info to write. Port/URL may be updated later via `update()`. */
   info: DevServerInfo;
   /**
-   * If a lock file exists but its PID is dead, take over instead of failing.
+   * If a lock file exists but is stale (its PID is dead, or it was written
+   * before the current boot), take over instead of failing.
    * Defaults to `true`. Set to `false` for testing.
    */
   takeOverStale?: boolean;
@@ -117,4 +146,5 @@ type AcquireResult = AcquireSuccess | AcquireFailure;
  * already holds the lock.
  */
 export declare function tryAcquireLockfile(opts: AcquireOptions): AcquireResult;
-//#endregion
+//#endregion
+export {};

package/dist/server/dev-lockfile.js

@@ -1,5 +1,6 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
+import os from "node:os";
 //#region src/server/dev-lockfile.ts
 /**
 * Dev server lock file.
@@ -21,6 +22,9 @@ import fs from "node:fs";
 *   (`process.kill(pid, 0)`), which is good enough for the dev-server
 *   "another server is running" use case. Race conditions on lock acquisition
 *   are tolerated: at worst, two dev servers race and one fails to bind a port.
+*   Unlike a `flock()`, the lock file survives a hard restart, so a lock
+*   written before the current boot is treated as stale whatever its PID: the
+*   PID may now belong to an unrelated process. See `predatesCurrentBoot()`.
 * - Lock file lives in `<root>/.vinext/dev/lock.json` (mirroring Next.js'
 *   `.next/dev/lock` layout). `.vinext/` is already used by the fonts plugin
 *   to cache self-hosted Google Fonts, so this re-uses the same project-local
@@ -71,6 +75,46 @@ function isPidAlive(pid) {
 	}
 }
 /**
+* Slack for the boot-time comparison in `predatesCurrentBoot`. `os.uptime()`
+* has whole-second resolution on some platforms (macOS derives it from
+* `kern.boottime`), so the derived boot time is only accurate to about a
+* second.
+*/
+const BOOT_TIME_TOLERANCE_MS = 5e3;
+/**
+* Returns true if a lock with the given `startedAt` was written before the
+* machine last booted.
+*
+* Such a lock was left behind by a session whose exit handler never ran (a
+* crash, a forced restart, power loss). PIDs are handed out again after a
+* boot, so the lock's PID may be held by an unrelated process, and
+* `isPidAlive()` alone would report the dead server as running.
+*
+* The boot time is derived from `Date.now() - os.uptime()`. Stepping the wall
+* clock forward moves it too (`os.uptime()` doesn't change), so a forward
+* step larger than the uptime at which a server started makes its lock look
+* stale, e.g. a VM resuming after the host slept. The second `vinext dev`
+* then takes over, as in the acquisition race tolerated below: Vite moves it
+* to another port, or it fails to bind with `strictPort`.
+*
+* Known limitations, where a lock is still checked by PID alone:
+* - A wall clock that comes back from a reboot behind the previous session
+*   (an RTC running slow, or NTP stepping it back) can leave the lock's
+*   `startedAt` after the derived boot time.
+* - Windows Fast Startup shuts down by hibernating the kernel, so
+*   `os.uptime()` keeps counting across that shutdown.
+* - A container restart doesn't reset the host's uptime.
+*/
+function predatesCurrentBoot(startedAt) {
+	let uptime;
+	try {
+		uptime = os.uptime();
+	} catch {
+		return false;
+	}
+	return startedAt < Date.now() - uptime * 1e3 - BOOT_TIME_TOLERANCE_MS;
+}
+/**
 * Writes the lock file with the given content. Creates the parent directory
 * if it doesn't exist.
 *
@@ -128,7 +172,7 @@ function tryAcquireLockfile(opts) {
 	const lockfilePath = getLockfilePath(root);
 	const existing = readLockfile(lockfilePath);
 	if (existing) {
-		if (isPidAlive(existing.pid)) return {
+		if (!predatesCurrentBoot(existing.startedAt) && isPidAlive(existing.pid)) return {
 			ok: false,
 			existing,
 			lockfilePath
@@ -178,4 +222,4 @@ function tryAcquireLockfile(opts) {
 	};
 }
 //#endregion
-export { formatAlreadyRunningError, getLockfilePath, isPidAlive, readLockfile, tryAcquireLockfile };
+export { formatAlreadyRunningError, getLockfilePath, isPidAlive, predatesCurrentBoot, readLockfile, tryAcquireLockfile };

package/dist/server/dev-module-runner.d.ts

@@ -25,4 +25,5 @@ type DevEnvironmentLike = {
  *   Typically `server.environments["ssr"]`.
  */
 export declare function createDirectRunner(environment: DevEnvironmentLike | DevEnvironment): ModuleRunner;
-//#endregion
+//#endregion
+export {};

package/dist/server/dev-server.js

@@ -13,7 +13,7 @@ import { NEVER_CACHE_CONTROL } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import "./isr-cache.js";
-import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { ensureFetchPatch, setCurrentFetchDraftMode } from "../shims/fetch-cache.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import "../shims/router-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
@@ -41,7 +41,7 @@ import { PAGES_PREVIEW_CACHE_CONTROL, appendPagesPreviewClearCookies, getPagesPr
 import { attachPagesRequestCookies } from "./pages-node-compat.js";
 import { randomUUID } from "node:crypto";
 import React from "react";
-import { renderToReadableStream } from "react-dom/server.edge";
+import { renderToReadableStream } from "react-dom/server";
 //#region src/server/dev-server.ts
 /**
 * Render a React element to a string using renderToReadableStream.
@@ -112,6 +112,7 @@ function writeGsspRedirect(res, redirect, isDataReq, props, options) {
 		...props,
 		pageProps: props.pageProps
 	});
+	if (options.method === "getServerSideProps" && !res.getHeader("Cache-Control")) res.setHeader("Cache-Control", NEVER_CACHE_CONTROL);
 	const gsspHeaders = Object.fromEntries(Object.entries(res.getHeaders()).filter((entry) => entry[1] !== void 0));
 	if (isDangerousScheme(resolved.destination)) {
 		const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
@@ -404,7 +405,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 				res.end("{}");
 				return;
 			}
-			const requestContext = createRequestContext();
+			const requestContext = createRequestContext({ isOnDemandRevalidate: isOnDemandRevalidateRequest(req.headers[PRERENDER_REVALIDATE_HEADER]) });
 			const closeRequest = () => void closeAfterResponse(requestContext);
 			res.on("finish", closeRequest);
 			res.on("close", closeRequest);
@@ -422,7 +423,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 		let requestAsPath = isDataReq ? gsspResolvedUrl : i18nConfig ? extractLocaleFromUrl$1(originalUrl, i18nConfig, locale).url : originalUrl;
 		const userFacingParams = route.isDynamic ? params : null;
 		let query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
-		const requestContext = createRequestContext();
+		const requestContext = createRequestContext({ isOnDemandRevalidate: isOnDemandRevalidateRequest(req.headers[PRERENDER_REVALIDATE_HEADER]) });
 		let isStaticPropsRender = false;
 		const closeRequest = () => void closeAfterResponse(requestContext);
 		res.on("finish", closeRequest);
@@ -467,6 +468,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 					shouldClear: false
 				};
 				const requestPreviewData = requestPreview.data;
+				setCurrentFetchDraftMode(requestPreviewData !== false);
 				const pagesNextData = {
 					...buildPagesReadinessNextData({
 						pageModule,
@@ -643,14 +645,17 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 							const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
 							stripDevPagesNotFoundFramingHeaders(res);
 							if (!res.hasHeader("Content-Type")) res.setHeader("Content-Type", "application/json");
+							if (!res.getHeader("Cache-Control")) res.setHeader("Cache-Control", NEVER_CACHE_CONTROL);
 							if (deploymentId && !res.hasHeader("x-nextjs-deployment-id")) res.setHeader(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
 							res.writeHead(404);
 							res.end("{\"notFound\":true}");
 							return;
 						}
+						if (!res.getHeader("Cache-Control")) res.setHeader("Cache-Control", NEVER_CACHE_CONTROL);
 						await renderErrorPage(server, runner, req, res, url, pagesDir, 404, routerShim.wrapWithRouterContext, void 0, void 0, reactStrictMode, {
 							...errorPageContext,
-							notFoundSrcPage: patternToNextFormat(route.pattern)
+							notFoundSrcPage: patternToNextFormat(route.pattern),
+							cacheControl: requestPreview.data === false && !requestPreview.shouldClear ? DEV_PAGES_CACHE_CONTROL : PAGES_PREVIEW_CACHE_CONTROL
 						});
 						return;
 					}
@@ -1130,7 +1135,8 @@ async function renderErrorPage(server, runner, req, res, url, pagesDir, statusCo
 				getTailHeadHTML: () => getClientTraceMetadataHTML(context.clientTraceMetadata),
 				setDocumentInitialHead: typeof headShim.setDocumentInitialHead === "function" ? headShim.setDocumentInitialHead : void 0,
 				crossOrigin: context.crossOrigin,
-				preserveExistingContentType: statusCode === 404
+				preserveExistingContentType: statusCode === 404,
+				extraHeaders: context.cacheControl ? { "Cache-Control": context.cacheControl } : void 0
 			});
 			else {
 				const bodyHtml = await tracePagesDocument(errorPage, () => renderToStringAsync(element));
@@ -1155,6 +1161,7 @@ async function renderErrorPage(server, runner, req, res, url, pagesDir, statusCo
 					configuredCrossOrigin: context.crossOrigin,
 					protectedAssetMarker
 				}), protectedAssetMarker);
+				if (context.cacheControl) res.setHeader("Cache-Control", context.cacheControl);
 				res.writeHead(statusCode, statusCode === 404 && res.hasHeader("Content-Type") ? void 0 : { "Content-Type": "text/html; charset=utf-8" });
 				res.end(transformedHtml);
 			}
@@ -1173,6 +1180,7 @@ async function renderErrorPage(server, runner, req, res, url, pagesDir, statusCo
 		defaultResponse.headers.forEach((value, key) => {
 			headers[key] = value;
 		});
+		if (context.cacheControl) headers["cache-control"] = context.cacheControl;
 		res.writeHead(defaultResponse.status, headers);
 		res.end(await defaultResponse.text());
 		return;

package/dist/server/fetch-handler.js

@@ -1,3 +1,2 @@
-import virtual_vinext_worker_entry_default from "virtual:vinext-worker-entry";
+export { default } from "virtual:vinext-worker-entry";
 export * from "virtual:vinext-worker-entry";
-export { virtual_vinext_worker_entry_default as default };

package/dist/server/file-based-metadata.d.ts

@@ -24,4 +24,5 @@ type FileBasedMetadataOptions = {
   basePath?: string;
 };
 export declare function applyFileBasedMetadata(metadata: Metadata | null, routePath: string, params: AppPageParams, metadataRoutes: readonly MetadataFileRoute[] | null | undefined, options?: FileBasedMetadataOptions): Promise<Metadata | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/framework-tracer.d.ts

@@ -43,4 +43,5 @@ export type FrameworkTracer = {
 };
 export declare function recordFrameworkSpanError(span: FrameworkSpan, error: unknown): void;
 export declare function createFrameworkTracer(integrations: readonly FrameworkTracingIntegration[]): FrameworkTracer;
-//#endregion
+//#endregion
+export {};

package/dist/server/headers.d.ts

@@ -17,7 +17,7 @@ export declare const VINEXT_CACHE_HEADER = "X-Vinext-Cache";
 export declare const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
 /** Next.js cache-tag metadata carried by prerendered App Router responses. */
 export declare const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
-/** Timing metrics: `handlerStart,compileMs,renderMs`. */
+/** Timing metrics: `handlerStart,compileMs,renderMs` (handlerStart is wall-clock ms). */
 export declare const VINEXT_TIMING_HEADER = "x-vinext-timing";
 /** Matched route returned from an independently hosted response stage. */
 export declare const VINEXT_TRACE_ROUTE_HEADER = "X-Vinext-Trace-Route";
@@ -85,8 +85,11 @@ export declare const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-
 export declare const VINEXT_PRERENDER_SPECIAL_ERROR_HEADER = "x-vinext-prerender-special-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 export declare const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
-/** Disabled-by-default client hint describing already-held App Router payload entries. */
-export declare const VINEXT_CLIENT_REUSE_MANIFEST_HEADER = "X-Vinext-Client-Reuse-Manifest";
+/**
+ * Hashed identities of the layouts a client navigation already holds, so a
+ * render that's never stored can leave them out. Not part of the RSC cache key.
+ */
+export declare const VINEXT_MOUNTED_LAYOUTS_HEADER = "X-Vinext-Mounted-Layouts";
 /**
  * Side-channel signal that an RSC response (HTTP 200) encodes a `redirect()`
  * thrown during render. The header value is the redirect target (path-only

package/dist/server/headers.js

@@ -17,7 +17,7 @@ const VINEXT_CACHE_HEADER = "X-Vinext-Cache";
 const NEXTJS_CACHE_HEADER = "x-nextjs-cache";
 /** Next.js cache-tag metadata carried by prerendered App Router responses. */
 const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
-/** Timing metrics: `handlerStart,compileMs,renderMs`. */
+/** Timing metrics: `handlerStart,compileMs,renderMs` (handlerStart is wall-clock ms). */
 const VINEXT_TIMING_HEADER = "x-vinext-timing";
 /** Matched route returned from an independently hosted response stage. */
 const VINEXT_TRACE_ROUTE_HEADER = "X-Vinext-Trace-Route";
@@ -85,8 +85,11 @@ const VINEXT_PRERENDER_RENDER_ERROR_HEADER = "x-vinext-prerender-render-error";
 const VINEXT_PRERENDER_SPECIAL_ERROR_HEADER = "x-vinext-prerender-special-error";
 /** Internal marker persisted only inside metadata-route APP_ROUTE cache values. */
 const VINEXT_METADATA_ROUTE_CACHE_HEADER = "x-vinext-metadata-route-cache";
-/** Disabled-by-default client hint describing already-held App Router payload entries. */
-const VINEXT_CLIENT_REUSE_MANIFEST_HEADER = "X-Vinext-Client-Reuse-Manifest";
+/**
+* Hashed identities of the layouts a client navigation already holds, so a
+* render that's never stored can leave them out. Not part of the RSC cache key.
+*/
+const VINEXT_MOUNTED_LAYOUTS_HEADER = "X-Vinext-Mounted-Layouts";
 /**
 * Side-channel signal that an RSC response (HTTP 200) encodes a `redirect()`
 * thrown during render. The header value is the redirect target (path-only
@@ -152,7 +155,8 @@ const FLIGHT_HEADERS = [
 	"next-router-prefetch",
 	"next-hmr-refresh",
 	"next-router-segment-prefetch",
-	"x-vinext-rsc-state-fingerprint"
+	"x-vinext-rsc-state-fingerprint",
+	"x-vinext-mounted-layouts"
 ];
 /**
 * Headers that must be stripped from external requests before any handler
@@ -192,4 +196,4 @@ const VINEXT_INTERNAL_HEADERS = [
 	VINEXT_TRACE_ROUTE_HEADER.toLowerCase()
 ];
 //#endregion
-export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };
+export { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, INTERNAL_HEADERS, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER, MIDDLEWARE_SKIP_HEADER, NEXTJS_ACTION_NOT_FOUND_HEADER, NEXTJS_CACHE_HEADER, NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ACTION_HEADER, NEXT_CACHE_TAGS_HEADER, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, RSC_ACTION_HEADER, RSC_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_CACHE_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_EXPECTED_WORKER_VERSION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_INTERNAL_HEADERS, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_PAGES_STATIC_PATHS_PATH, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_PRERENDER_STATIC_PARAMS_PATH, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER, VINEXT_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_MARKER_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER, VINEXT_TRACE_BUFFERED_BODY_HEADER, VINEXT_TRACE_ERROR_HEADER, VINEXT_TRACE_ROUTE_HEADER, isVinextRscVaryField };

package/dist/server/html.d.ts

@@ -1,5 +1,6 @@
 //#region src/server/html.d.ts
 export declare function safeJsonStringify(data: unknown): string;
+export declare function scriptSafeJsonStringify(data: unknown): string;
 export declare function escapeHtmlAttr(value: string): string;
 export declare function htmlTokenListContains(value: string | null, token: string): boolean;
 export declare function createNonceAttribute(nonce?: string): string;