vinext 1.0.0-beta.3 → 1.0.0-beta.5

package/README.md

@@ -367,6 +367,49 @@ export default defineConfig({
 > Adding an explicit `rsc()` call fails the build with `[vinext] Duplicate @vitejs/plugin-rsc detected`.
 > Pass `rsc: false` to `vinext()` only if you want to own that registration.
 
+#### Module Federation (client-side)
+
+For client-side Module Federation, configure React and React DOM as singleton shared modules in both the host and remotes:
+
+```ts
+import { federation } from "@module-federation/vite";
+import { defineConfig } from "vite";
+import vinext from "vinext";
+
+export default defineConfig({
+  plugins: [
+    federation({
+      name: "host",
+      shared: {
+        react: { singleton: true },
+        "react/": { singleton: true },
+        "react-dom": { singleton: true },
+        "react-dom/": { singleton: true },
+      },
+    }),
+    vinext(),
+  ],
+});
+```
+
+In a remote client component, use `getVinextReact()` before reading React hooks. vinext registers the host's browser React instance before application modules execute, and the first registration remains stable across remote evaluation and HMR:
+
+```tsx
+"use client";
+
+import * as React from "react";
+import { getVinextReact } from "vinext/client";
+
+const { useState } = getVinextReact(React);
+
+export function RemoteCounter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount((value) => value + 1)}>{count}</button>;
+}
+```
+
+This bridge is browser-only. It does not provide App Router Module Federation SSR or transparently replace React imports inside third-party packages; compatible React versions remain the responsibility of the Module Federation `shared` configuration.
+
 See the [examples](#live-examples) for complete working configurations.
 
 ### Other platforms (via Nitro)
@@ -638,9 +681,7 @@ vinext({
   cache: {
     data: {
       adapter: require.resolve("./my-adapter.js"),
-      options: {
-        /* … */
-      },
+      options: {/* … */},
     },
   },
 });

package/dist/build/client-build-config.d.ts

@@ -1,5 +1,4 @@
 import { UserConfig } from "vite";
-
 //#region src/build/client-build-config.d.ts
 type ClientAssetFileNameInfo = {
   readonly name?: string;

package/dist/build/css-url-assets.d.ts

@@ -1,5 +1,4 @@
 import { Rolldown } from "vite";
-
 //#region src/build/css-url-assets.d.ts
 type BundleAsset = Rolldown.OutputAsset;
 type CssUrlAssetBundle = Rolldown.OutputBundle;

package/dist/build/google-fonts/build-url.d.ts

@@ -1,7 +1,10 @@
 //#region src/build/google-fonts/build-url.d.ts
 type FontAxes = {
-  /** Weight values: explicit faces ("400") or a variable range ("400..800"). */wght?: string[]; /** Ital values, "0" (normal) and/or "1" (italic). */
-  ital?: string[]; /** Other variable axes the caller wants to include, e.g. `[["opsz","14..32"]]`. */
+  /** Weight values: explicit faces ("400") or a variable range ("400..800"). */
+  wght?: string[];
+  /** Ital values, "0" (normal) and/or "1" (italic). */
+  ital?: string[];
+  /** Other variable axes the caller wants to include, e.g. `[["opsz","14..32"]]`. */
   variableAxes?: [string, string][];
 };
 declare function buildGoogleFontsUrl(fontFamily: string, axes: FontAxes, display: string): string;

package/dist/build/google-fonts/font-metadata.d.ts

@@ -6,9 +6,13 @@ type VariableAxisDescriptor = {
   defaultValue: number;
 };
 type FontFamilyMetadata = {
-  /** Available weight values, plus the literal "variable" if a variable face exists. */weights: string[]; /** Available styles, e.g. ["normal"], ["italic"], or both. */
-  styles: string[]; /** Variable axes for this family. Absent when the family has no variable face. */
-  axes?: VariableAxisDescriptor[]; /** Preloadable subsets (e.g. "latin", "latin-ext", "vietnamese"). */
+  /** Available weight values, plus the literal "variable" if a variable face exists. */
+  weights: string[];
+  /** Available styles, e.g. ["normal"], ["italic"], or both. */
+  styles: string[];
+  /** Variable axes for this family. Absent when the family has no variable face. */
+  axes?: VariableAxisDescriptor[];
+  /** Preloadable subsets (e.g. "latin", "latin-ext", "vietnamese"). */
   subsets: string[];
 };
 declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;

package/dist/build/google-fonts/get-axes.d.ts

@@ -1,5 +1,4 @@
 import { FontAxes } from "./build-url.js";
-
 //#region src/build/google-fonts/get-axes.d.ts
 declare function getFontAxes(fontFamily: string, weights: string[], styles: string[], selectedVariableAxes?: string[]): FontAxes;
 //#endregion

package/dist/build/layout-classification.d.ts

@@ -1,9 +1,9 @@
 import { ClassificationReason, LayoutBuildClassification, ModuleGraphStaticReason } from "./layout-classification-types.js";
-
 //#region src/build/layout-classification.d.ts
 type ModuleGraphClassification = "static" | "needs-probe";
 type ModuleGraphClassificationResult = {
-  result: ModuleGraphClassification; /** First dynamic shim module ID encountered during BFS, when any. */
+  result: ModuleGraphClassification;
+  /** First dynamic shim module ID encountered during BFS, when any. */
   firstShimMatch?: string;
 };
 type ModuleInfoProvider = {
@@ -13,8 +13,11 @@ type ModuleInfoProvider = {
   } | null;
 };
 type LayoutEntry = {
-  /** Rollup/Vite module ID for the layout file. */moduleId: string; /** Directory depth from the app root, used to build the stable layout ID. */
-  treePosition: number; /** Segment config source code extracted at build time, or null when absent. */
+  /** Rollup/Vite module ID for the layout file. */
+  moduleId: string;
+  /** Directory depth from the app root, used to build the stable layout ID. */
+  treePosition: number;
+  /** Segment config source code extracted at build time, or null when absent. */
   segmentConfig?: {
     code: string;
   } | null;

package/dist/build/next-client-runtime-manifests.d.ts

@@ -1,5 +1,4 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
-
 //#region src/build/next-client-runtime-manifests.d.ts
 type EmitNextClientRuntimeManifestsOptions = {
   clientDir: string;

package/dist/build/next-client-runtime-manifests.js

@@ -1,27 +1,10 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { toClientRewrites } from "../client/client-rewrites.js";
 import fs from "node:fs";
 //#region src/build/next-client-runtime-manifests.ts
-function normalizeRewriteForClientManifest(rewrite) {
-	if (rewrite.destination.startsWith("/")) return {
-		has: rewrite.has,
-		source: rewrite.source,
-		destination: rewrite.destination
-	};
-	return {
-		has: rewrite.has,
-		source: rewrite.source
-	};
-}
-function normalizeRewritesForClientManifest(rewrites) {
-	return {
-		beforeFiles: rewrites.beforeFiles.map(normalizeRewriteForClientManifest),
-		afterFiles: rewrites.afterFiles.map(normalizeRewriteForClientManifest),
-		fallback: rewrites.fallback.map(normalizeRewriteForClientManifest)
-	};
-}
 function buildNextClientBuildManifestContent(rewrites) {
 	const manifest = {
-		__rewrites: normalizeRewritesForClientManifest(rewrites),
+		__rewrites: toClientRewrites(rewrites),
 		sortedPages: []
 	};
 	return `self.__BUILD_MANIFEST = ${JSON.stringify(manifest)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`;

package/dist/build/nitro-route-rules.d.ts

@@ -1,5 +1,4 @@
 import { RouteRow } from "./report.js";
-
 //#region src/build/nitro-route-rules.d.ts
 type NitroRouteRuleConfig = Record<string, unknown> & {
   swr?: boolean | number;

package/dist/build/pages-client-assets-module.d.ts

@@ -1,5 +1,4 @@
 import { PagesClientAssets } from "../server/pages-client-assets.js";
-
 //#region src/build/pages-client-assets-module.d.ts
 declare const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 declare function buildPagesClientAssetsModule(assets: PagesClientAssets): string;

package/dist/build/precompress.d.ts

@@ -1,7 +1,11 @@
 //#region src/build/precompress.d.ts
 type PrecompressResult = {
   filesCompressed: number;
-  totalOriginalBytes: number; /** Sum of brotli-compressed sizes (used for compression ratio reporting). */
+  totalOriginalBytes: number;
+  /**
+   * Sum of the representation sizes Brotli negotiation would serve. Falls
+   * back to the original size when Brotli is not beneficial for a file.
+   */
   totalBrotliBytes: number;
 };
 /**
@@ -20,7 +24,8 @@ type PrecompressResult = {
  * emit zero compressed variants.
  */
 declare function precompressAssets(clientDir: string, options?: {
-  /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */assetsDir?: string;
+  /** Subdirectory under `clientDir` containing hashed assets. Defaults to `"_next/static"`. */
+  assetsDir?: string;
   onProgress?: (completed: number, total: number, file: string) => void;
 }): Promise<PrecompressResult>;
 //#endregion

package/dist/build/precompress.js

@@ -1,9 +1,11 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
+import { isPrecompressedVariantBeneficial } from "../utils/precompressed-variant.js";
 import fsp from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
 import os from "node:os";
 import zlib from "node:zlib";
-import { promisify } from "node:util";
 //#region src/build/precompress.ts
 /**
 * Build-time precompression for hashed static assets.
@@ -90,21 +92,53 @@ async function precompressAssets(clientDir, options = {}) {
 		const chunk = filePaths.slice(i, i + CONCURRENCY);
 		await Promise.all(chunk.map(async (fullPath) => {
 			const content = await fsp.readFile(fullPath);
-			if (content.length < MIN_SIZE) return;
+			if (content.length < MIN_SIZE) {
+				await removeCompressedVariants(fullPath);
+				return;
+			}
 			const compressions = [brotliCompress(content, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 5 } }), gzip(content, { level: 8 })];
 			if (zstdCompress) compressions.push(zstdCompress(content, { params: { [zlib.constants.ZSTD_c_compressionLevel]: 8 } }));
 			const [brContent, gzContent, zstdContent] = await Promise.all(compressions);
-			const writes = [fsp.writeFile(fullPath + ".br", brContent), fsp.writeFile(fullPath + ".gz", gzContent)];
-			if (zstdContent) writes.push(fsp.writeFile(fullPath + ".zst", zstdContent));
-			await Promise.all(writes);
-			result.filesCompressed++;
-			result.totalOriginalBytes += content.length;
-			result.totalBrotliBytes += brContent.length;
+			const outcomes = await Promise.all([
+				writeBeneficialVariant(fullPath + ".br", brContent, content.length, "br"),
+				writeBeneficialVariant(fullPath + ".gz", gzContent, content.length, "gzip"),
+				zstdContent ? writeBeneficialVariant(fullPath + ".zst", zstdContent, content.length, "zstd") : removeFileIfPresent(fullPath + ".zst").then(() => false)
+			]);
+			if (outcomes.some(Boolean)) {
+				result.filesCompressed++;
+				result.totalOriginalBytes += content.length;
+				result.totalBrotliBytes += outcomes[0] ? brContent.length : content.length;
+			}
 		}));
 		processed += chunk.length;
 		onProgress?.(processed, filePaths.length, path.basename(chunk[chunk.length - 1]));
 	}
 	return result;
 }
+async function writeBeneficialVariant(destination, compressed, originalSize, encoding) {
+	if (!isPrecompressedVariantBeneficial(compressed.length, originalSize, encoding)) {
+		await removeFileIfPresent(destination);
+		return false;
+	}
+	const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		await fsp.writeFile(temporary, compressed);
+		await fsp.rename(temporary, destination);
+	} catch (error) {
+		await removeFileIfPresent(temporary);
+		throw error;
+	}
+	return true;
+}
+async function removeCompressedVariants(fullPath) {
+	await Promise.all([
+		removeFileIfPresent(fullPath + ".br"),
+		removeFileIfPresent(fullPath + ".gz"),
+		removeFileIfPresent(fullPath + ".zst")
+	]);
+}
+async function removeFileIfPresent(filePath) {
+	await fsp.rm(filePath, { force: true });
+}
 //#endregion
 export { precompressAssets };

package/dist/build/prerender-paths.d.ts

@@ -1,6 +1,5 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { VinextRouteRootConfig } from "../config/prerender.js";
-
 //#region src/build/prerender-paths.d.ts
 type PrerenderPathManifest = {
   buildId?: string;
@@ -10,7 +9,8 @@ type PrerenderPathManifest = {
 declare const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";
 declare const PRERENDER_PATHS_MANIFEST = "vinext-prerender-paths.json";
 type EmitPrerenderPathManifestOptions = {
-  root: string; /** Fully resolved Next.js config. Loaded from disk when omitted. */
+  root: string;
+  /** Fully resolved Next.js config. Loaded from disk when omitted. */
   nextConfig?: ResolvedNextConfig;
   appDir?: string | null;
   pagesDir?: string | null;

package/dist/build/prerender-server-entry.d.ts

@@ -1 +1 @@
-export { };
+export {}

package/dist/build/prerender-server-pool.d.ts

@@ -7,7 +7,8 @@
  */
 declare function prerenderPoolAvailable(): boolean;
 type PrerenderServerPool = {
-  /** Ports of the forked render servers, for round-robin per-route fetches. */ports: number[];
+  /** Ports of the forked render servers, for round-robin per-route fetches. */
+  ports: number[];
   /**
    * Throw if any worker exited unexpectedly (i.e. not via `close()`). The
    * caller MUST call this after the render loop: a crashed worker makes every
@@ -21,7 +22,8 @@ type PrerenderServerPool = {
    * Record a failed fetch to a render worker. This closes the tiny ordering gap
    * where the request can fail before Node has delivered the child `exit` event.
    */
-  recordRenderError: (err: unknown) => void; /** Kill every forked server. Safe to call more than once. */
+  recordRenderError: (err: unknown) => void;
+  /** Kill every forked server. Safe to call more than once. */
   close: () => Promise<void>;
 };
 /**

package/dist/build/prerender.d.ts

@@ -4,26 +4,35 @@ import { AppRoute } from "../routing/app-route-graph.js";
 import { MetadataFileRoute } from "../server/metadata-routes.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { Server } from "node:http";
-
 //#region src/build/prerender.d.ts
 type PrerenderResult = {
-  /** One entry per route (including skipped/error routes). */routes: PrerenderRouteResult[]; /** Additional generated files that are not represented as route entries. */
+  /** One entry per route (including skipped/error routes). */
+  routes: PrerenderRouteResult[];
+  /** Additional generated files that are not represented as route entries. */
   outputFiles?: string[];
 };
 type PrerenderRouteResult = {
-  /** The route's file-system pattern, e.g. `/blog/:slug`. */route: string;
+  /** The route's file-system pattern, e.g. `/blog/:slug`. */
+  route: string;
   status: "rendered";
   outputFiles: string[];
   revalidate: number | false;
   expire?: number;
+  /** Client-router reuse bound resolved from the prerender's `cacheLife`. */
+  stale?: number;
   /**
    * The concrete prerendered URL path, e.g. `/blog/hello-world`.
    * Only present when the route is dynamic and `path` differs from `route`.
    * Omitted for non-dynamic routes where pattern === path.
    */
-  path?: string; /** Which router produced this route. Used by cache seeding. */
-  router: "app" | "pages"; /** Response headers that must be replayed with the prerendered artifact. */
-  headers?: Record<string, string>; /** Set to true when this is a PPR fallback shell. */
+  path?: string;
+  /** Which router produced this route. Used by cache seeding. */
+  router: "app" | "pages";
+  /** Response headers that must be replayed with the prerendered artifact. */
+  headers?: Record<string, string>;
+  /** Cache tags collected while rendering this route. */
+  tags?: string[];
+  /** Set to true when this is a PPR fallback shell. */
   fallback?: boolean;
 } | {
   route: string;
@@ -43,9 +52,13 @@ type PrerenderRouteResult = {
 };
 /** Called after each route is resolved (rendered, skipped, or error). */
 type PrerenderProgressCallback = (update: {
-  /** Routes completed so far (rendered + skipped + error). */completed: number; /** Total routes queued for rendering. */
-  total: number; /** The route URL that just finished. */
-  route: string; /** Its final status. */
+  /** Routes completed so far (rendered + skipped + error). */
+  completed: number;
+  /** Total routes queued for rendering. */
+  total: number;
+  /** The route URL that just finished. */
+  route: string;
+  /** Its final status. */
   status: PrerenderRouteResult["status"];
 }) => void;
 type PrerenderOptions = {
@@ -53,7 +66,8 @@ type PrerenderOptions = {
    * 'default' — prerender static/ISR routes; skip SSR routes
    * 'export'  — same as default but SSR routes are errors
    */
-  mode: "default" | "export"; /** Output directory for generated HTML/RSC files. */
+  mode: "default" | "export";
+  /** Output directory for generated HTML/RSC files. */
   outDir: string;
   /**
    * Directory where `vinext-prerender.json` is written.
@@ -61,7 +75,8 @@ type PrerenderOptions = {
    * Set this when the manifest should land in a different location than the
    * generated HTML/RSC files (e.g. `dist/server/` while HTML goes to `dist/server/prerendered-routes/`).
    */
-  manifestDir?: string; /** Resolved next.config.js. */
+  manifestDir?: string;
+  /** Resolved next.config.js. */
   config: ResolvedNextConfig;
   /**
    * Maximum number of routes rendered in parallel.
@@ -81,8 +96,11 @@ type PrerenderOptions = {
   skipManifest?: boolean;
 };
 type PrerenderPagesOptions = {
-  /** Discovered page routes (non-API). */routes: Route[]; /** Discovered API routes. */
-  apiRoutes: Route[]; /** Pages directory path. */
+  /** Discovered page routes (non-API). */
+  routes: Route[];
+  /** Discovered API routes. */
+  apiRoutes: Route[];
+  /** Pages directory path. */
   pagesDir: string;
   /**
    * Absolute path to the pre-built Pages Router server bundle
@@ -94,7 +112,9 @@ type PrerenderPagesOptions = {
   pagesBundlePath?: string;
 } & PrerenderOptions;
 type PrerenderAppOptions = {
-  /** Discovered app routes. */routes: AppRoute[]; /** Discovered file-based metadata routes. Used by static export. */
+  /** Discovered app routes. */
+  routes: AppRoute[];
+  /** Discovered file-based metadata routes. Used by static export. */
   metadataRoutes?: readonly MetadataFileRoute[];
   /**
    * Absolute path to the pre-built RSC handler bundle (e.g. `dist/server/index.js`).
@@ -171,15 +191,7 @@ declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: Stat
  * Writes HTML files to `outDir`. If `manifestDir` is set, writes
  * `vinext-prerender.json` there; otherwise writes it to `outDir`.
  */
-declare function prerenderPages({
-  routes,
-  apiRoutes,
-  pagesDir,
-  outDir,
-  config,
-  mode,
-  ...options
-}: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
+declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mode, ...options }: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
 /**
  * Run the prerender phase for App Router.
  *
@@ -197,15 +209,7 @@ declare function prerenderPages({
  * If they succeed, they are marked as rendered. If they throw a DynamicUsageError
  * or fail, they are marked as skipped with reason 'dynamic'.
  */
-declare function prerenderApp({
-  routes,
-  metadataRoutes,
-  outDir,
-  config,
-  mode,
-  rscBundlePath,
-  ...options
-}: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
+declare function prerenderApp({ routes, metadataRoutes, outDir, config, mode, rscBundlePath, ...options }: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
 /**
  * Write `vinext-prerender.json` to `outDir`.
  *

package/dist/build/prerender.js

@@ -1,8 +1,9 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
-import { VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
+import { NEXT_CACHE_TAGS_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
+import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
@@ -760,6 +761,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					const cacheControl = response.headers.get("cache-control") ?? "";
 					const linkHeader = response.headers.get("link");
 					const responseCacheLife = readPrerenderCacheLifeHeader(response.headers);
+					const cacheTags = readPrerenderCacheTagsHeader(response.headers);
 					if (!response.ok || cacheControl.includes("no-store")) {
 						await response.body?.cancel();
 						return {
@@ -768,6 +770,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							html: null,
 							ok: response.ok,
 							requestCacheLife: null,
+							tags: [],
 							status: response.status
 						};
 					}
@@ -779,7 +782,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						html,
 						ok: true,
 						requestCacheLife: responseCacheLife ?? processCacheLife,
-						status: response.status
+						status: response.status,
+						tags: cacheTags
 					};
 				});
 				const htmlCacheControl = htmlRender.cacheControl;
@@ -835,13 +839,16 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				outputFiles.push(rscOutputPath);
 				const renderedCacheControl = resolveRenderedCacheControl(htmlRender.requestCacheLife ?? {}, htmlCacheControl, config.expireTime);
 				const renderedRevalidate = typeof revalidate === "number" ? renderedCacheControl.revalidate === void 0 ? revalidate : Math.min(revalidate, renderedCacheControl.revalidate) : renderedCacheControl.revalidate ?? revalidate;
+				const renderedStale = resolveClientStaleTimeSeconds(htmlRender.requestCacheLife);
 				return {
 					route: routePattern,
 					status: "rendered",
 					outputFiles,
 					revalidate: renderedRevalidate,
 					...typeof renderedRevalidate === "number" ? { expire: renderedCacheControl.expire } : {},
+					...renderedStale === void 0 ? {} : { stale: renderedStale },
 					router: "app",
+					...htmlRender.tags.length > 0 ? { tags: htmlRender.tags } : {},
 					...htmlRender.linkHeader ? { headers: { link: htmlRender.linkHeader } } : {},
 					...urlPath !== routePattern ? { path: urlPath } : {},
 					...isFallback ? { fallback: true } : {}
@@ -940,11 +947,17 @@ function readPrerenderCacheLifeHeader(headers) {
 		const cacheLife = {};
 		if (typeof parsed.revalidate === "number" && Number.isFinite(parsed.revalidate)) cacheLife.revalidate = parsed.revalidate;
 		if (typeof parsed.expire === "number" && Number.isFinite(parsed.expire)) cacheLife.expire = parsed.expire;
-		return cacheLife.revalidate === void 0 && cacheLife.expire === void 0 ? null : cacheLife;
+		if (typeof parsed.stale === "number" && Number.isFinite(parsed.stale) && parsed.stale >= 0) cacheLife.stale = parsed.stale;
+		return cacheLife.revalidate === void 0 && cacheLife.expire === void 0 && cacheLife.stale === void 0 ? null : cacheLife;
 	} catch {
 		return null;
 	}
 }
+function readPrerenderCacheTagsHeader(headers) {
+	const value = headers.get(NEXT_CACHE_TAGS_HEADER);
+	if (!value) return [];
+	return [...new Set(value.split(",").filter(Boolean))];
+}
 function resolveRenderedExpireSeconds(options) {
 	const { fallbackExpireSeconds, sMaxage, staleWhileRevalidate } = options;
 	if (sMaxage === void 0 || staleWhileRevalidate === void 0) return fallbackExpireSeconds;
@@ -975,7 +988,9 @@ function writePrerenderIndex(routes, outDir, options) {
 			status: r.status,
 			revalidate: r.revalidate,
 			...typeof r.revalidate === "number" ? { expire: r.expire } : {},
+			...typeof r.stale === "number" ? { stale: r.stale } : {},
 			router: r.router,
+			...r.tags && r.tags.length > 0 ? { tags: r.tags } : {},
 			...r.headers ? { headers: r.headers } : {},
 			...r.path ? { path: r.path } : {},
 			...r.fallback ? { fallback: true } : {}

package/dist/build/public-dir-conflict.d.ts

@@ -0,0 +1,14 @@
+//#region src/build/public-dir-conflict.d.ts
+type PublicDirConflictOptions = {
+  root: string;
+  publicDir: string | null;
+  assetsDir: string;
+};
+type PublicNextRequestConflictOptions = Pick<PublicDirConflictOptions, "root" | "publicDir"> & {
+  basePath: string;
+  requestUrl: string;
+};
+declare function assertNoPublicNextRequestConflict({ root, publicDir, basePath, requestUrl }: PublicNextRequestConflictOptions): void;
+declare function assertNoPublicDirAssetConflict({ root, publicDir, assetsDir }: PublicDirConflictOptions): void;
+//#endregion
+export { PublicDirConflictOptions, PublicNextRequestConflictOptions, assertNoPublicDirAssetConflict, assertNoPublicNextRequestConflict };

package/dist/build/public-dir-conflict.js

@@ -0,0 +1,25 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { existsSync } from "node:fs";
+//#region src/build/public-dir-conflict.ts
+const PUBLIC_NEXT_CONFLICT_ERROR = "You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict";
+function assertNoPublicNextDir(root, publicDir) {
+	if (!publicDir) return;
+	if (existsSync(path.join(path.resolve(root, publicDir), "_next"))) throw new Error(PUBLIC_NEXT_CONFLICT_ERROR);
+}
+function assertNoPublicNextRequestConflict({ root, publicDir, basePath, requestUrl }) {
+	const internalOrigin = "http://vinext.invalid";
+	const parseTarget = requestUrl.startsWith("/") ? internalOrigin + requestUrl : requestUrl;
+	let pathname = new URL(parseTarget, internalOrigin).pathname;
+	if (basePath && (pathname === basePath || pathname.startsWith(basePath + "/"))) pathname = pathname.slice(basePath.length) || "/";
+	if (pathname.startsWith("/_next")) assertNoPublicNextDir(root, publicDir);
+}
+function assertNoPublicDirAssetConflict({ root, publicDir, assetsDir }) {
+	assertNoPublicNextDir(root, publicDir);
+	if (!publicDir || !assetsDir) return;
+	const resolvedPublicDir = path.resolve(root, publicDir);
+	const publicAssetsDir = path.resolve(resolvedPublicDir, assetsDir);
+	const relativeAssetsDir = path.relative(resolvedPublicDir, publicAssetsDir);
+	if (relativeAssetsDir !== "" && !relativeAssetsDir.startsWith("../") && !path.isAbsolute(relativeAssetsDir) && existsSync(publicAssetsDir)) throw new Error(`[vinext] The public directory contains a path reserved for build assets: ${relativeAssetsDir}`);
+}
+//#endregion
+export { assertNoPublicDirAssetConflict, assertNoPublicNextRequestConflict };

package/dist/build/report.d.ts

@@ -2,12 +2,12 @@ import { LayoutBuildClassification } from "./layout-classification-types.js";
 import { Route } from "../routing/pages-router.js";
 import { AppRoute } from "../routing/app-route-graph.js";
 import { PrerenderResult } from "./prerender.js";
-
 //#region src/build/report.d.ts
 type RouteType = "static" | "isr" | "ssr" | "unknown" | "api";
 type RouteRow = {
   pattern: string;
-  type: RouteType; /** Only set for `isr` routes. */
+  type: RouteType;
+  /** Only set for `isr` routes. */
   revalidate?: number;
   /**
    * True when the route was classified as `static` by speculative prerender

package/dist/build/route-classification-injector.d.ts

@@ -1,6 +1,5 @@
 import { ModuleInfoProvider } from "./layout-classification.js";
 import { RouteClassificationManifest } from "./route-classification-manifest.js";
-
 //#region src/build/route-classification-injector.d.ts
 /**
  * Build-time route classification injection.

package/dist/build/route-classification-manifest.d.ts

@@ -1,11 +1,13 @@
 import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
 import { AppRoute } from "../routing/app-route-graph.js";
-
 //#region src/build/route-classification-manifest.d.ts
 type Layer1Class = "static" | "dynamic";
 type RouteManifestEntry = {
-  /** Route pattern for diagnostics (e.g. "/blog/:slug"). */pattern: string; /** Absolute file paths for each layout, ordered root → leaf. */
-  layoutPaths: string[]; /** Layer 1 (segment config) results keyed by numeric layout index. */
+  /** Route pattern for diagnostics (e.g. "/blog/:slug"). */
+  pattern: string;
+  /** Absolute file paths for each layout, ordered root → leaf. */
+  layoutPaths: string[];
+  /** Layer 1 (segment config) results keyed by numeric layout index. */
   layer1: Map<number, Layer1Class>;
   /**
    * Structured reasons for every Layer 1 decision, keyed by the same layout

package/dist/build/run-prerender.d.ts

@@ -1,9 +1,10 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { PrerenderResult, PrerenderRouteResult } from "./prerender.js";
-
 //#region src/build/run-prerender.d.ts
 type RunPrerenderOptions = {
-  /** Project root directory. */root: string; /** Fully resolved Next.js config. Loaded from disk when omitted. */
+  /** Project root directory. */
+  root: string;
+  /** Fully resolved Next.js config. Loaded from disk when omitted. */
   nextConfig?: ResolvedNextConfig;
   /**
    * Override the path to the Pages Router server bundle.