vinext 1.0.0-beta.6 → 1.0.0-beta.8

package/README.md

@@ -2,6 +2,8 @@
 
 Run Next.js applications on Vite, with Cloudflare Workers as the primary deployment target.
 
+**Website:** [vinext.dev](https://vinext.dev)
+
 > **Read the announcement:** [How we rebuilt Next.js with AI in one week](https://blog.cloudflare.com/vinext/)
 
 > **Under active development.** vinext supports substantial Next.js applications today, but it is not yet a drop-in replacement for every application or production workload. Expect compatibility gaps, especially in newer App Router features, and evaluate it against your own application before adopting it.
@@ -516,12 +518,12 @@ These are deployed to Cloudflare Workers and updated on every push to `main`:
 | App Router (minimal)   | Minimal App Router on Workers                                                                                    | [app-router-cloudflare.vinext.workers.dev](https://app-router-cloudflare.vinext.workers.dev)     |
 | Pages Router (minimal) | Minimal Pages Router on Workers                                                                                  | [pages-router-cloudflare.vinext.workers.dev](https://pages-router-cloudflare.vinext.workers.dev) |
 | RealWorld API          | REST API routes example                                                                                          | [realworld-api-rest.vinext.workers.dev](https://realworld-api-rest.vinext.workers.dev)           |
-| Benchmarks Dashboard   | Build performance tracking over time (D1-backed)                                                                 | [vinext-web.vinext.workers.dev/benchmarks](https://vinext-web.vinext.workers.dev/benchmarks)     |
+| Benchmarks Dashboard   | Build performance tracking over time (D1-backed)                                                                 | [vinext.dev/benchmarks](https://vinext.dev/benchmarks)                                           |
 | App Router + Nitro     | App Router deployed via Nitro (multi-platform)                                                                   | [examples/app-router-nitro](examples/app-router-nitro)                                           |
 
 ## API coverage
 
-~94% of the Next.js 16 API surface has full or partial support. The remaining gaps are intentional stubs for deprecated features and Partial Prerendering (which Next.js 16 reworked into `"use cache"` — that directive is fully supported).
+~94% of the Next.js 16 API surface has full or partial support. The remaining gaps are intentional stubs for deprecated features, plus Partial Prerendering and Cache Components. Next.js 16 reworked PPR into `"use cache"`; vinext implements that directive for file-level and function-level caching, but full `cacheComponents` behavior is still incomplete — see [Known gaps we're working on](#known-gaps-were-working-on).
 
 > ✅ = full implementation | 🟡 = partial (runtime behavior correct, some build-time optimizations missing) | ⬜ = intentional stub/no-op
 
@@ -604,6 +606,33 @@ Every `next/*` import is shimmed to a Vite-compatible implementation.
 | `images` config                                  | 🟡  | Parsed but not used for optimization                                                                                                                                                                                   |
 | `experimental.optimizePackageImports`            | ✅  | Rewrites barrel imports to direct sub-module imports in RSC/SSR environments. A default set (lucide-react, date-fns, radix-ui, antd, MUI, and others) are always optimized. Add package names here to extend the list. |
 | `vinext({ nextConfig })`                         | ✅  | Inline Next-style config from `vite.config.*`. Supports object-form and function-form config. When provided, this overrides root `next.config.*`.                                                                      |
+| `vinext({ react: { compiler: true } })`          | ✅  | React Compiler auto memoization. Needs `@vitejs/plugin-react` 6.1+ and the optional `oxc-transform-react` package.                                                                                                     |
+
+### React Compiler
+
+vinext auto-registers `@vitejs/plugin-react`, so the React Compiler is enabled through the same `react` option:
+
+```ts
+import { defineConfig } from "vite";
+import vinext from "vinext";
+
+export default defineConfig({
+  plugins: [vinext({ react: { compiler: true } })],
+});
+```
+
+The transform itself ships separately, so install it alongside:
+
+```bash
+npm install -D oxc-transform-react
+```
+
+This requires `@vitejs/plugin-react` 6.1.0 or newer. Older versions accept the option and drop it, so vinext fails with an actionable error instead of leaving the compiler silently disabled. The compiler runs on the client environment only.
+
+One caveat: modules whose JSX is lowered earlier in the pipeline are not memoized. Those build and behave correctly, they just miss auto memoization:
+
+- JSX in plain `.js` files, which `vinext:jsx-in-js` compiles first so the compiler can parse them at all. Rename to `.jsx` or `.tsx` to get memoization.
+- Components using `<style jsx>`, which `vinext:styled-jsx` compiles through the Next.js SWC transform before the compiler runs.
 
 ### Environment variable loading (`.env*`)
 
@@ -643,16 +672,21 @@ The cache is pluggable. The default `MemoryCacheHandler` works out of the box. S
 Instead of wiring up cache handlers imperatively from a worker entry, you can declare them in the `vinext()` plugin config. The `@vinext/cloudflare` package ships Cloudflare adapters for this:
 
 - **`kvDataAdapter()`** (`@vinext/cloudflare/cache/kv-data-adapter`) — backs the `"use cache"` data cache with a Workers KV namespace.
+- **`cdnAdapter()`** (`@vinext/cloudflare/cache/cdn-adapter`) — serves page-level ISR from the Cloudflare Workers Cache (`ctx.cache`) instead of from the origin.
+
+The two fill different slots and can be used together:
 
 ```ts
 import { defineConfig } from "vite";
 import vinext from "vinext";
+import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
 import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
 
 export default defineConfig({
   plugins: [
     vinext({
       cache: {
+        cdn: cdnAdapter(),
         data: kvDataAdapter(),
       },
     }),
@@ -670,6 +704,16 @@ The KV data adapter reads `env[binding]` at runtime, so add the matching KV name
 
 `binding` defaults to `VINEXT_KV_CACHE`, so `kvDataAdapter()` with no options works as long as that's your binding name. Other options: `appPrefix` (namespace cache keys to isolate multiple apps in one KV namespace), `ttlSeconds` (default KV `expirationTtl`, default 30 days), and `tagCacheTtlMs` (in-memory tag-invalidation cache TTL, default 5s).
 
+`cdnAdapter()` takes no options, but the Workers Cache only exposes `ctx.cache` when `cache.enabled` is set in `wrangler.jsonc`:
+
+```jsonc
+{
+  "cache": { "enabled": true },
+}
+```
+
+While the data adapter can store entries and serve HIT/STALE itself, the CDN adapter delegates serving to Cloudflare's edge: the origin renders fresh responses and tags them with `Cache-Tag`, and `revalidateTag()` / `revalidatePath()` purge the edge through `ctx.cache.purge({ tags })`. See [examples/workers-cache](examples/workers-cache) for both adapters wired up together.
+
 Each builder returns a plain, serializable `{ adapter, options }` descriptor — **it never touches the Workers runtime**, so nothing throws at build or dev time when bindings aren't available. The actual adapter (and its `env` binding lookup) is instantiated lazily on the first request.
 
 Registration is wired into **every router and runtime** — App Router and Pages Router, on Cloudflare Workers as well as the Node.js server (`vinext start`) and dev. It self-guards (instantiated once per isolate) and is resilient: if an adapter can't initialize on a given runtime (e.g. a KV binding doesn't exist on the Node server), vinext logs a warning and falls back to the default handler instead of failing requests.
@@ -713,7 +757,7 @@ We measure three things:
 - **Client bundle size** — gzipped output of each build.
 - **Dev server cold start** — 10 runs, randomized execution order. Vite's dependency optimizer cache is cleared before each run.
 
-Benchmarks run on GitHub CI runners (2-core Ubuntu) on every merge to `main`. See the launch numbers in the [announcement blog post](https://blog.cloudflare.com/vinext/) and the latest results at **[vinext-web.vinext.workers.dev/benchmarks](https://vinext-web.vinext.workers.dev/benchmarks)**.
+Benchmarks run on GitHub CI runners (2-core Ubuntu) on every merge to `main`. See the launch numbers in the [announcement blog post](https://blog.cloudflare.com/vinext/) and the latest results at **[vinext.dev/benchmarks](https://vinext.dev/benchmarks)**.
 
 <details>
 <summary>Why the bundle size difference?</summary>

package/dist/build/action-owner-manifest.d.ts

@@ -0,0 +1,42 @@
+import { AppRoute } from "../routing/app-route-graph.js";
+import { Rollup } from "vite";
+import { RscPluginManager } from "@vitejs/plugin-rsc";
+//#region src/build/action-owner-manifest.d.ts
+type ActionOwnerRoute = Pick<AppRoute, "errorPath" | "errorPaths" | "forbiddenPath" | "forbiddenPaths" | "layoutErrorPaths" | "layouts" | "loadingPath" | "loadingPaths" | "notFoundPath" | "notFoundPaths" | "pagePath" | "parallelSlots" | "pattern" | "siblingIntercepts" | "templates" | "unauthorizedPath" | "unauthorizedPaths">;
+type ActionOwnerRouteReachability = Map<string, {
+  clientReferenceImportIds: Set<string>;
+  serverReferenceIds: Set<string>;
+}>;
+type ActionOwnerModuleInfo = Pick<Rollup.ModuleInfo, "dynamicallyImportedIds" | "importedIds">;
+type ActionOwnerReferenceMaps = {
+  clientReferenceMetaMap: RscPluginManager["clientReferenceMetaMap"];
+  serverReferenceMetaMap: RscPluginManager["serverReferences"]["metaMap"];
+};
+declare function actionOwnerRouteEntryIds(route: ActionOwnerRoute): string[];
+declare function collectReachableActionReferences(options: {
+  canonicalizeModuleId?: (id: string) => string;
+  getModuleInfo: (id: string) => ActionOwnerModuleInfo | null;
+  roots: readonly string[];
+} & ActionOwnerReferenceMaps): {
+  clientReferenceImportIds: Set<string>;
+  serverReferenceIds: Set<string>;
+};
+declare function collectRscActionReachability(options: {
+  canonicalizeModuleId?: (id: string) => string;
+  getModuleInfo: (id: string) => ActionOwnerModuleInfo | null;
+  routes: readonly ActionOwnerRoute[];
+  sharedRoots?: readonly string[];
+} & ActionOwnerReferenceMaps): ActionOwnerRouteReachability;
+declare function resolveClientReferenceImportIds(options: {
+  canonicalizeModuleId?: (id: string) => string;
+  resolveId: (id: string) => Promise<string | null>;
+  routeReachability: ActionOwnerRouteReachability;
+}): Promise<void>;
+declare function addClientActionReachability(options: {
+  canonicalizeModuleId?: (id: string) => string;
+  getModuleInfo: (id: string) => ActionOwnerModuleInfo | null;
+  routeReachability: ActionOwnerRouteReachability;
+} & ActionOwnerReferenceMaps): void;
+declare function buildActionOwnerManifest(routeReachability: ActionOwnerRouteReachability): Record<string, string[]>;
+//#endregion
+export { ActionOwnerRouteReachability, actionOwnerRouteEntryIds, addClientActionReachability, buildActionOwnerManifest, collectReachableActionReferences, collectRscActionReachability, resolveClientReferenceImportIds };

package/dist/build/action-owner-manifest.js

@@ -0,0 +1,110 @@
+//#region src/build/action-owner-manifest.ts
+function actionOwnerRouteEntryIds(route) {
+	return [
+		route.pagePath,
+		...route.layouts,
+		...route.templates,
+		route.loadingPath,
+		...route.loadingPaths ?? [],
+		route.errorPath,
+		...route.layoutErrorPaths ?? [],
+		...route.errorPaths ?? [],
+		route.notFoundPath,
+		...route.notFoundPaths ?? [],
+		route.forbiddenPath,
+		...route.forbiddenPaths ?? [],
+		route.unauthorizedPath,
+		...route.unauthorizedPaths ?? [],
+		...route.parallelSlots.flatMap((slot) => [
+			slot.pagePath,
+			slot.defaultPath,
+			slot.layoutPath,
+			...slot.configLayoutPaths ?? [],
+			slot.loadingPath,
+			...slot.loadingPaths ?? [],
+			slot.errorPath,
+			slot.notFoundPath,
+			...slot.interceptingRoutes.flatMap((intercept) => [
+				intercept.pagePath,
+				...intercept.layoutPaths,
+				...intercept.loadingPaths ?? [],
+				intercept.notFoundPath
+			])
+		]),
+		...route.siblingIntercepts.flatMap((intercept) => [
+			intercept.pagePath,
+			...intercept.layoutPaths,
+			...intercept.loadingPaths ?? [],
+			intercept.notFoundPath
+		])
+	].filter((value) => typeof value === "string");
+}
+function collectReachableActionReferences(options) {
+	const canonicalizeModuleId = options.canonicalizeModuleId ?? ((id) => id);
+	const clientReferenceImportIds = /* @__PURE__ */ new Set();
+	const serverReferenceIds = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const queue = options.roots.map(canonicalizeModuleId);
+	for (let index = 0; index < queue.length; index++) {
+		const id = queue[index];
+		if (visited.has(id)) continue;
+		visited.add(id);
+		const clientReference = options.clientReferenceMetaMap[id];
+		if (clientReference) clientReferenceImportIds.add(clientReference.importId);
+		const serverReference = options.serverReferenceMetaMap.get(id);
+		if (serverReference) for (const exportName of serverReference.exportNames) serverReferenceIds.add(`${serverReference.referenceKey}#${exportName}`);
+		const info = options.getModuleInfo(id);
+		for (const importedId of [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []]) if (!visited.has(importedId)) queue.push(importedId);
+	}
+	return {
+		clientReferenceImportIds,
+		serverReferenceIds
+	};
+}
+function collectRscActionReachability(options) {
+	const routeReachability = new Map(options.routes.map((route) => [route.pattern, collectReachableActionReferences({
+		canonicalizeModuleId: options.canonicalizeModuleId,
+		clientReferenceMetaMap: options.clientReferenceMetaMap,
+		getModuleInfo: options.getModuleInfo,
+		roots: actionOwnerRouteEntryIds(route),
+		serverReferenceMetaMap: options.serverReferenceMetaMap
+	})]));
+	if (options.sharedRoots?.length) routeReachability.set("*", collectReachableActionReferences({
+		canonicalizeModuleId: options.canonicalizeModuleId,
+		clientReferenceMetaMap: options.clientReferenceMetaMap,
+		getModuleInfo: options.getModuleInfo,
+		roots: options.sharedRoots,
+		serverReferenceMetaMap: options.serverReferenceMetaMap
+	}));
+	return routeReachability;
+}
+async function resolveClientReferenceImportIds(options) {
+	const canonicalizeModuleId = options.canonicalizeModuleId ?? ((id) => id);
+	for (const reachability of options.routeReachability.values()) {
+		const resolvedImportIds = /* @__PURE__ */ new Set();
+		for (const importId of reachability.clientReferenceImportIds) {
+			const resolvedId = await options.resolveId(importId) ?? importId;
+			resolvedImportIds.add(canonicalizeModuleId(resolvedId));
+		}
+		reachability.clientReferenceImportIds = resolvedImportIds;
+	}
+}
+function addClientActionReachability(options) {
+	for (const reachability of options.routeReachability.values()) {
+		const clientReachability = collectReachableActionReferences({
+			canonicalizeModuleId: options.canonicalizeModuleId,
+			clientReferenceMetaMap: options.clientReferenceMetaMap,
+			getModuleInfo: options.getModuleInfo,
+			roots: [...reachability.clientReferenceImportIds],
+			serverReferenceMetaMap: options.serverReferenceMetaMap
+		});
+		for (const actionId of clientReachability.serverReferenceIds) reachability.serverReferenceIds.add(actionId);
+	}
+}
+function buildActionOwnerManifest(routeReachability) {
+	const manifest = {};
+	for (const [pattern, reachability] of routeReachability) for (const actionId of reachability.serverReferenceIds) (manifest[actionId] ??= []).push(pattern);
+	return manifest;
+}
+//#endregion
+export { actionOwnerRouteEntryIds, addClientActionReachability, buildActionOwnerManifest, collectReachableActionReferences, collectRscActionReachability, resolveClientReferenceImportIds };

package/dist/build/clean-output.js

@@ -1,4 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { isPathInsideOrEqual } from "../utils/path.js";
 import fs from "node:fs";
 //#region src/build/clean-output.ts
 function resolveOutDir(root, outDir) {
@@ -6,10 +7,6 @@ function resolveOutDir(root, outDir) {
 	if (!outDir) return path.join(resolvedRoot, "dist");
 	return path.isAbsolute(outDir) ? outDir : path.resolve(resolvedRoot, outDir);
 }
-function isPathInsideOrEqual(parent, child) {
-	const relative = path.relative(parent, child);
-	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-}
 function shouldCleanBuildOutput(options) {
 	if (options.emptyOutDir === false) return false;
 	if (options.emptyOutDir === true) return true;

package/dist/build/client-build-config.js

@@ -86,11 +86,20 @@ function getPackageName(id) {
 */
 function createClientManualChunks(shimsDir, preserveRouteBoundaries = false) {
 	return function clientManualChunks(id) {
+		const slashedId = toSlash(id);
+		if (slashedId.startsWith(shimsDir)) {
+			if (preserveRouteBoundaries) {
+				const relativeId = slashedId.slice(shimsDir.length).split("?", 1)[0] ?? "";
+				const extensionIndex = relativeId.lastIndexOf(".");
+				const shimName = extensionIndex === -1 ? relativeId : relativeId.slice(0, extensionIndex);
+				if (ROUTE_OWNED_CLIENT_SHIMS.has(shimName)) return void 0;
+			}
+			return "vinext";
+		}
 		if (id.includes("node_modules")) {
 			const pkg = getPackageName(id);
 			if (!pkg) return void 0;
 			if (pkg === "react-dom") {
-				const slashedId = toSlash(id);
 				const sub = slashedId.slice(slashedId.lastIndexOf("react-dom/") + 10);
 				if (sub.startsWith("server.") || sub.startsWith("static.") || sub.startsWith("cjs/react-dom-server")) return "react-dom-server";
 				return "framework";
@@ -98,16 +107,6 @@ function createClientManualChunks(shimsDir, preserveRouteBoundaries = false) {
 			if (pkg === "react" || pkg === "scheduler") return "framework";
 			return;
 		}
-		const slashedId = toSlash(id);
-		if (slashedId.startsWith(shimsDir)) {
-			if (preserveRouteBoundaries) {
-				const relativeId = slashedId.slice(shimsDir.length).split("?", 1)[0] ?? "";
-				const extensionIndex = relativeId.lastIndexOf(".");
-				const shimName = extensionIndex === -1 ? relativeId : relativeId.slice(0, extensionIndex);
-				if (ROUTE_OWNED_CLIENT_SHIMS.has(shimName)) return void 0;
-			}
-			return "vinext";
-		}
 	};
 }
 function createClientFileNameConfig(assetsDir) {

package/dist/build/prerender.d.ts

@@ -1,6 +1,6 @@
+import { AppRoute } from "../routing/app-route-graph.js";
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
-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";

package/dist/build/prerender.js

@@ -1,7 +1,7 @@
 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 { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH } from "../server/headers.js";
+import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_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";
@@ -781,11 +781,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					const request = new Request(`http://localhost${config.basePath ?? ""}${urlPath}`);
 					const response = await runWithHeadersContext(headersContextFromRequest(request), () => rscHandler(request));
 					if (!response.ok) {
+						const fatal = response.headers.get(VINEXT_PRERENDER_RENDER_ERROR_HEADER) === "1";
 						await response.body?.cancel();
 						return {
 							route: routePattern,
 							status: "error",
-							error: `Metadata route returned ${response.status}`
+							error: `Metadata route returned ${response.status}`,
+							...fatal ? { fatal: true } : {}
 						};
 					}
 					const cacheControl = response.headers.get("cache-control") ?? "";
@@ -834,6 +836,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					const linkHeader = response.headers.get("link");
 					const responseCacheLife = readPrerenderCacheLifeHeader(response.headers);
 					const cacheTags = readPrerenderCacheTagsHeader(response.headers);
+					const fatal = response.headers.get(VINEXT_PRERENDER_RENDER_ERROR_HEADER) === "1";
 					if (!response.ok || cacheControl.includes("no-store")) {
 						await response.body?.cancel();
 						return {
@@ -843,7 +846,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							ok: response.ok,
 							requestCacheLife: null,
 							tags: [],
-							status: response.status
+							status: response.status,
+							fatal
 						};
 					}
 					const html = await response.text();
@@ -855,12 +859,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						ok: true,
 						requestCacheLife: responseCacheLife ?? processCacheLife,
 						status: response.status,
-						tags: cacheTags
+						tags: cacheTags,
+						fatal: false
 					};
 				});
 				const htmlCacheControl = htmlRender.cacheControl;
 				if (!htmlRender.ok) {
-					if (isSpeculative) return {
+					if (isSpeculative && !htmlRender.fatal) return {
 						route: routePattern,
 						status: "skipped",
 						reason: "dynamic"
@@ -868,7 +873,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					return {
 						route: routePattern,
 						status: "error",
-						error: `RSC handler returned ${htmlRender.status}`
+						error: `RSC handler returned ${htmlRender.status}`,
+						...htmlRender.fatal ? { fatal: true } : {}
 					};
 				}
 				if (htmlCacheControl.includes("no-store")) return {

package/dist/build/report.d.ts

@@ -1,6 +1,6 @@
+import { AppRoute } from "../routing/app-route-graph.js";
 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";

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

@@ -1,5 +1,5 @@
-import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
 import { AppRoute } from "../routing/app-route-graph.js";
+import { ClassificationReason, ModuleGraphStaticReason } from "./layout-classification-types.js";
 //#region src/build/route-classification-manifest.d.ts
 type Layer1Class = "static" | "dynamic";
 type RouteManifestEntry = {

package/dist/build/static-export.d.ts

@@ -1,6 +1,6 @@
+import { AppRoute } from "../routing/app-route-graph.js";
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
-import { AppRoute } from "../routing/app-route-graph.js";
 //#region src/build/static-export.d.ts
 type StaticExportOptions = {
   /**

package/dist/client/app-nav-failure-handler.js

@@ -22,6 +22,7 @@ function clearAppNavigationFailureTarget(target) {
 }
 function handleAppNavigationFailure(error) {
 	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return false;
+	if (error !== null && typeof error === "object" && "handled" in error && error.handled === true) return false;
 	const pendingUrl = getPendingUrl();
 	if (pendingUrl === null || pendingUrl.href === window.location.href) return false;
 	console.error("Error occurred during navigation, falling back to hard navigation", error);

package/dist/client/navigation-runtime.d.ts

@@ -10,6 +10,7 @@ type NavigationRuntimeRscBootstrap = {
   done?: boolean;
   dynamicStaleTimeSeconds?: number;
   initialCacheKind?: "dynamic" | "static";
+  searchParamsFromBrowser?: boolean;
   nav?: NavigationRuntimeSnapshot;
   params?: Record<string, string | string[]>;
   rsc: NavigationRuntimeRscChunk[];
@@ -32,7 +33,7 @@ type NavigationRuntimeTraversalIntent = {
   historyState: unknown;
   targetHistoryIndex: number | null;
 };
-type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null, visibleCommitMode?: NavigationRuntimeVisibleCommitMode) => Promise<void>;
+type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null, visibleCommitMode?: NavigationRuntimeVisibleCommitMode, bypassNavigationCache?: boolean) => Promise<void>;
 type NavigationRuntimeFunctions = {
   clearNavigationCaches?: () => void;
   commitHashNavigation?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode, scroll: boolean) => void;
@@ -49,6 +50,8 @@ type NavigationRuntimeFunctions = {
   notifyLinkNavigationStart?: () => void;
   pingVisibleLinks?: () => void;
   preparePrefetchResponse?: (response: Response) => Promise<unknown>;
+  claimCurrentHistoryTreeSnapshot?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
+  commitAppOwnedHistoryStateWrite?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
 };
 type NavigationRuntimeBootstrap = {
   routeManifest: RouteManifest | null;
@@ -64,7 +67,6 @@ declare function getNavigationRuntime(): NavigationRuntime | null;
 declare function registerNavigationRuntimeBootstrap(bootstrap: Partial<NavigationRuntimeBootstrap>): NavigationRuntime;
 declare function registerNavigationRuntimeFunctions(functions: Partial<NavigationRuntimeFunctions>): NavigationRuntime;
 declare function ensureNavigationRuntimeRscBootstrap(): NavigationRuntimeRscBootstrap;
-declare function subscribeNavigationRuntimeRscChunk(chunk: NavigationRuntimeRscChunk): NavigationRuntime;
 declare function hasAppNavigationRuntime(): boolean;
 /**
  * True when the App Router has installed its runtime bootstrap on `window`,
@@ -80,4 +82,4 @@ declare function hasAppNavigationRuntime(): boolean;
  */
 declare function hasAppNavigationRuntimeBootstrap(): boolean;
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeSnapshot, NavigationRuntimeVisibleCommitMode, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeVisibleCommitMode, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };

package/dist/client/navigation-runtime.js

@@ -31,7 +31,7 @@ function readRuntimeWindow() {
 }
 function isNavigationRuntimeFunctions(value) {
 	if (!isUnknownRecord(value)) return false;
-	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse"));
+	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse")) && isOptionalRuntimeFunction(Reflect.get(value, "claimCurrentHistoryTreeSnapshot")) && isOptionalRuntimeFunction(Reflect.get(value, "commitAppOwnedHistoryStateWrite"));
 }
 function isNavigationRuntimeRscChunk(value) {
 	if (typeof value === "string") return true;
@@ -52,11 +52,12 @@ function isNavigationRuntimeRscBootstrap(value) {
 	const done = Reflect.get(value, "done");
 	const dynamicStaleTimeSeconds = Reflect.get(value, "dynamicStaleTimeSeconds");
 	const initialCacheKind = Reflect.get(value, "initialCacheKind");
+	const searchParamsFromBrowser = Reflect.get(value, "searchParamsFromBrowser");
 	const nav = Reflect.get(value, "nav");
 	const params = Reflect.get(value, "params");
 	const rsc = Reflect.get(value, "rsc");
 	const staleTimeSeconds = Reflect.get(value, "staleTimeSeconds");
-	return (done === void 0 || typeof done === "boolean") && isOptionalStaleTimeSeconds(dynamicStaleTimeSeconds) && (initialCacheKind === void 0 || initialCacheKind === "dynamic" || initialCacheKind === "static") && (nav === void 0 || isNavigationRuntimeSnapshot(nav)) && (params === void 0 || isNavigationRuntimeParams(params)) && Array.isArray(rsc) && rsc.every(isNavigationRuntimeRscChunk) && isOptionalStaleTimeSeconds(staleTimeSeconds);
+	return (done === void 0 || typeof done === "boolean") && isOptionalStaleTimeSeconds(dynamicStaleTimeSeconds) && (initialCacheKind === void 0 || initialCacheKind === "dynamic" || initialCacheKind === "static") && (searchParamsFromBrowser === void 0 || typeof searchParamsFromBrowser === "boolean") && (nav === void 0 || isNavigationRuntimeSnapshot(nav)) && (params === void 0 || isNavigationRuntimeParams(params)) && Array.isArray(rsc) && rsc.every(isNavigationRuntimeRscChunk) && isOptionalStaleTimeSeconds(staleTimeSeconds);
 }
 function isOptionalStaleTimeSeconds(value) {
 	return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -148,11 +149,6 @@ function ensureNavigationRuntimeRscBootstrapForRuntime(runtime) {
 	}
 	return rscBootstrap;
 }
-function subscribeNavigationRuntimeRscChunk(chunk) {
-	const runtime = ensureNavigationRuntime();
-	ensureNavigationRuntimeRscBootstrapForRuntime(runtime).rsc.push(chunk);
-	return runtime;
-}
 function hasAppNavigationRuntime() {
 	return typeof getNavigationRuntime()?.functions.navigate === "function";
 }
@@ -172,4 +168,4 @@ function hasAppNavigationRuntimeBootstrap() {
 	return getNavigationRuntime() !== null;
 }
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };

package/dist/entries/app-browser-entry.d.ts

@@ -1,5 +1,5 @@
-import { NextRewrite } from "../config/next-config.js";
 import { AppRoute, RouteManifest } from "../routing/app-route-graph.js";
+import { NextRewrite } from "../config/next-config.js";
 import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../client/vinext-next-data.js";
 //#region src/entries/app-browser-entry.d.ts
 /**

package/dist/entries/app-rsc-entry.d.ts

@@ -1,5 +1,5 @@
-import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PrefetchInliningConfig } from "../config/next-config.js";
 import { AppRoute } from "../routing/app-route-graph.js";
+import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PrefetchInliningConfig } from "../config/next-config.js";
 import { MetadataFileRoute } from "../server/metadata-routes.js";
 import { ImageConfig } from "../server/image-optimization.js";
 //#region src/entries/app-rsc-entry.d.ts
@@ -8,6 +8,7 @@ import { ImageConfig } from "../server/image-optimization.js";
  * Passed from the Vite plugin where the full next.config.js is loaded.
  */
 type AppRouterConfig = {
+  actionOwners?: Record<string, string[]> | null;
   redirects?: NextRedirect[];
   rewrites?: {
     beforeFiles: NextRewrite[];