vinext 0.1.0 → 0.1.2

package/README.md

@@ -528,22 +528,19 @@ The cache is pluggable. The default `MemoryCacheHandler` works out of the box. S
 
 #### Configuring cache adapters from `vite.config`
 
-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 two Cloudflare adapters for this:
+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`) — backs full-route CDN caching with the Workers Cache API.
 
 ```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(),
       },
     }),
@@ -559,7 +556,7 @@ 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 — it just needs the Workers Cache, which is always available on Workers.
+`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).
 
 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.
 

package/dist/build/assets-ignore.d.ts

@@ -0,0 +1,32 @@
+//#region src/build/assets-ignore.d.ts
+/**
+ * Build metadata that must never be served by the Cloudflare ASSETS binding.
+ *
+ * On Cloudflare Workers the ASSETS binding serves any uploaded file whose path
+ * matches the request BEFORE the Worker runs, so anything written into the
+ * client output directory (`dist/client`) is publicly fetchable unless excluded.
+ * Vite writes its build/SSR manifests under `dist/client/.vite/` (enabled for
+ * Cloudflare builds so the worker entry can compute lazy chunks), which would
+ * otherwise expose the full source-file → chunk mapping — including the paths of
+ * routes that are never linked from the UI.
+ *
+ * The Node production server already blocks `/.vite/` explicitly
+ * (see `server/static-file-cache.ts`); `.assetsignore` is the equivalent guard
+ * for the Cloudflare deployment target. wrangler matches `.assetsignore`
+ * patterns with `.gitignore` semantics (via the `ignore` package), so the bare
+ * `.vite` entry excludes the directory and everything beneath it.
+ */
+declare const DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS: readonly string[];
+/**
+ * Ensure a `.assetsignore` in `clientDir` contains every pattern in `patterns`.
+ *
+ * Any pre-existing (user-authored) content is preserved verbatim and only the
+ * missing patterns are appended, so the result is idempotent across rebuilds
+ * and never clobbers a `.assetsignore` the developer wrote themselves.
+ *
+ * @returns `true` when the file was created or modified, `false` when it already
+ *          covered every requested pattern.
+ */
+declare function ensureAssetsIgnore(clientDir: string, patterns?: readonly string[]): boolean;
+//#endregion
+export { DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS, ensureAssetsIgnore };

package/dist/build/assets-ignore.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/build/assets-ignore.ts
+/**
+* Build metadata that must never be served by the Cloudflare ASSETS binding.
+*
+* On Cloudflare Workers the ASSETS binding serves any uploaded file whose path
+* matches the request BEFORE the Worker runs, so anything written into the
+* client output directory (`dist/client`) is publicly fetchable unless excluded.
+* Vite writes its build/SSR manifests under `dist/client/.vite/` (enabled for
+* Cloudflare builds so the worker entry can compute lazy chunks), which would
+* otherwise expose the full source-file → chunk mapping — including the paths of
+* routes that are never linked from the UI.
+*
+* The Node production server already blocks `/.vite/` explicitly
+* (see `server/static-file-cache.ts`); `.assetsignore` is the equivalent guard
+* for the Cloudflare deployment target. wrangler matches `.assetsignore`
+* patterns with `.gitignore` semantics (via the `ignore` package), so the bare
+* `.vite` entry excludes the directory and everything beneath it.
+*/
+const DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS = [".vite"];
+/** wrangler reads asset-exclusion patterns from this file in the assets dir. */
+const ASSETS_IGNORE_FILENAME = ".assetsignore";
+const GENERATED_HEADER = "# Keep build metadata out of the deployed asset bundle (generated by vinext)";
+/**
+* Ensure a `.assetsignore` in `clientDir` contains every pattern in `patterns`.
+*
+* Any pre-existing (user-authored) content is preserved verbatim and only the
+* missing patterns are appended, so the result is idempotent across rebuilds
+* and never clobbers a `.assetsignore` the developer wrote themselves.
+*
+* @returns `true` when the file was created or modified, `false` when it already
+*          covered every requested pattern.
+*/
+function ensureAssetsIgnore(clientDir, patterns = DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS) {
+	const assetsIgnorePath = path.join(clientDir, ASSETS_IGNORE_FILENAME);
+	const existing = fs.existsSync(assetsIgnorePath) ? fs.readFileSync(assetsIgnorePath, "utf-8") : null;
+	const present = new Set((existing ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+	const missing = patterns.filter((pattern) => !present.has(pattern));
+	if (missing.length === 0) return false;
+	const lines = existing && existing.trim().length > 0 ? [existing.replace(/\s*$/, "")] : [GENERATED_HEADER];
+	lines.push(...missing, "");
+	fs.mkdirSync(clientDir, { recursive: true });
+	fs.writeFileSync(assetsIgnorePath, lines.join("\n"));
+	return true;
+}
+//#endregion
+export { DEFAULT_VINEXT_ASSET_IGNORE_PATTERNS, ensureAssetsIgnore };

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

@@ -51,10 +51,16 @@ declare function createClientManualChunks(shimsDir: string): (id: string) => str
  * compression efficiency — small files restart the compression dictionary,
  * adding ~5-15% wire overhead vs fewer larger chunks.
  */
+declare function createClientFileNameConfig(assetsDir: string): {
+  entryFileNames: string;
+  chunkFileNames: string;
+};
 declare function createClientOutputConfig(clientManualChunks: (id: string) => string | undefined, assetsDir: string): {
   assetFileNames: (assetInfo: ClientAssetFileNameInfo) => string;
   manualChunks: (id: string) => string | undefined;
   experimentalMinChunkSize: number;
+  entryFileNames: string;
+  chunkFileNames: string;
 };
 declare function createClientCodeSplittingConfig(clientManualChunks: (id: string) => string | undefined): {
   minSize: number;
@@ -62,6 +68,32 @@ declare function createClientCodeSplittingConfig(clientManualChunks: (id: string
     name(moduleId: string): string | null;
   }[];
 };
+/**
+ * Regex matching any {@link FRAMEWORK_PACKAGES} package inside `node_modules`.
+ * Derived from the package list so the regex and {@link isRscFrameworkModule}
+ * predicate can't drift.
+ */
+declare const RSC_FRAMEWORK_CHUNK_TEST: RegExp;
+declare function isRscFrameworkModule(id: string): boolean;
+/**
+ * Output config that isolates React (and the RSC flight runtime) into a
+ * dedicated "framework" chunk in the RSC server build. Returns the bundler-
+ * appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
+ * `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
+ * motivation (issue #1549).
+ */
+declare function createRscFrameworkChunkOutputConfig(viteMajorVersion: number): {
+  codeSplitting: {
+    groups: {
+      name: string;
+      test: RegExp;
+    }[];
+  };
+  manualChunks?: undefined;
+} | {
+  manualChunks(id: string): string | undefined;
+  codeSplitting?: undefined;
+};
 /**
  * Rollup treeshake configuration for production client builds.
  *
@@ -129,4 +161,4 @@ type VinextBuildConfigWithLegacy = VinextBuildConfig & {
 declare function getBuildBundlerOptions(build: UserConfig["build"] | undefined): VinextBuildBundlerOptions | undefined;
 declare function withBuildBundlerOptions(viteMajorVersion: number, bundlerOptions: VinextBuildBundlerOptions): Partial<VinextBuildConfigWithLegacy>;
 //#endregion
-export { clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
+export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };

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

@@ -89,8 +89,16 @@ function createClientManualChunks(shimsDir) {
 * compression efficiency — small files restart the compression dictionary,
 * adding ~5-15% wire overhead vs fewer larger chunks.
 */
+function createClientFileNameConfig(assetsDir) {
+	const chunksDir = `${assetsDir}/chunks`;
+	return {
+		entryFileNames: `${chunksDir}/[name]-[hash].js`,
+		chunkFileNames: `${chunksDir}/[name]-[hash].js`
+	};
+}
 function createClientOutputConfig(clientManualChunks, assetsDir) {
 	return {
+		...createClientFileNameConfig(assetsDir),
 		assetFileNames: createClientAssetFileNames(assetsDir),
 		manualChunks: clientManualChunks,
 		experimentalMinChunkSize: 1e4
@@ -105,6 +113,63 @@ function createClientCodeSplittingConfig(clientManualChunks) {
 	};
 }
 /**
+* Matches React framework packages (and the RSC flight runtime) inside
+* `node_modules`. Used to split them into a dedicated "framework" chunk in the
+* RSC server build.
+*
+* Why the RSC build needs this: without an explicit framework chunk, the
+* bundler colocates React into whichever chunk first reaches it — typically the
+* RSC entry chunk, which also carries the root layout's CSS. Modules that only
+* import React for runtime helpers (notably `app/global-not-found.tsx`, which
+* replaces the root layout for route-miss 404s) then import that entry chunk
+* and inherit the root layout's CSS in their `serverResources` metadata. The
+* 404 document ends up linking the layout's stylesheet last, so the layout's
+* rules win the cascade over global-not-found's — the bug tracked in
+* https://github.com/cloudflare/vinext/issues/1549.
+*
+* Splitting React into its own (CSS-free) chunk means global-not-found imports
+* the framework chunk instead of the layout-bearing entry chunk, so it no
+* longer inherits the root layout's CSS. The match list mirrors the client
+* build's `framework` chunk, plus `react-server-dom-webpack` for the RSC flight
+* runtime that the server environment bundles.
+*
+* Uses `[\\/]` rather than `/` for the path separator so it matches on Windows
+* too, per the rolldown `codeSplitting` docs.
+*/
+const FRAMEWORK_PACKAGES = [
+	"react",
+	"react-dom",
+	"scheduler",
+	"react-server-dom-webpack"
+];
+/**
+* Regex matching any {@link FRAMEWORK_PACKAGES} package inside `node_modules`.
+* Derived from the package list so the regex and {@link isRscFrameworkModule}
+* predicate can't drift.
+*/
+const RSC_FRAMEWORK_CHUNK_TEST = new RegExp(`[\\\\/]node_modules[\\\\/](${FRAMEWORK_PACKAGES.join("|")})[\\\\/]`);
+function isRscFrameworkModule(id) {
+	if (!id.includes("node_modules")) return false;
+	const pkg = getPackageName(id);
+	return pkg !== null && FRAMEWORK_PACKAGES.includes(pkg);
+}
+/**
+* Output config that isolates React (and the RSC flight runtime) into a
+* dedicated "framework" chunk in the RSC server build. Returns the bundler-
+* appropriate shape: rolldown's `codeSplitting` for Vite 8+, Rollup's
+* `manualChunks` for Vite 7. See {@link RSC_FRAMEWORK_CHUNK_TEST} for the
+* motivation (issue #1549).
+*/
+function createRscFrameworkChunkOutputConfig(viteMajorVersion) {
+	if (viteMajorVersion >= 8) return { codeSplitting: { groups: [{
+		name: "framework",
+		test: RSC_FRAMEWORK_CHUNK_TEST
+	}] } };
+	return { manualChunks(id) {
+		return isRscFrameworkModule(id) ? "framework" : void 0;
+	} };
+}
+/**
 * Rollup treeshake configuration for production client builds.
 *
 * Uses the 'recommended' preset as a safe base, then overrides
@@ -171,4 +236,4 @@ function withBuildBundlerOptions(viteMajorVersion, bundlerOptions) {
 	return viteMajorVersion >= 8 ? { rolldownOptions: bundlerOptions } : { rollupOptions: bundlerOptions };
 }
 //#endregion
-export { clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, withBuildBundlerOptions };
+export { RSC_FRAMEWORK_CHUNK_TEST, clientTreeshakeConfig, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createClientOutputConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfigForVite, isRscFrameworkModule, withBuildBundlerOptions };

package/dist/check.js

@@ -1,4 +1,5 @@
 import { detectPackageManager } from "./utils/project.js";
+import { normalizePathSeparators } from "./utils/path.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parseAst } from "vite";
@@ -342,7 +343,7 @@ function findSourceFiles(dir, extensions = [
 	if (!fs.existsSync(dir)) return results;
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name);
+		const fullPath = normalizePathSeparators(path.join(dir, entry.name));
 		if (entry.isDirectory()) {
 			if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist" || entry.name === ".git") continue;
 			results.push(...findSourceFiles(fullPath, extensions));
@@ -563,7 +564,7 @@ function scanImports(root) {
 			if (mod.startsWith("next/") || mod === "next" || mod === "server-only" || mod === "client-only") {
 				const normalized = mod === "next" ? "next" : mod;
 				if (!importUsage.has(normalized)) importUsage.set(normalized, []);
-				const relFile = path.relative(root, file);
+				const relFile = normalizePathSeparators(path.relative(root, file));
 				const usedInFiles = importUsage.get(normalized) ?? [];
 				if (!usedInFiles.includes(relFile)) usedInFiles.push(relFile);
 			}
@@ -876,7 +877,7 @@ function checkConventions(root) {
 	const cjsGlobalFiles = [];
 	for (const file of allSourceFiles) {
 		const content = fs.readFileSync(file, "utf-8");
-		const rel = path.relative(root, file);
+		const rel = normalizePathSeparators(path.relative(root, file));
 		if (viewTransitionRegex.test(content)) viewTransitionFiles.push(rel);
 		if (hasFreeCjsGlobal(content)) cjsGlobalFiles.push(rel);
 	}

package/dist/cli.js

@@ -18,6 +18,7 @@ import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { randomBytes } from "node:crypto";
 import { execFileSync } from "node:child_process";
 //#region src/cli.ts
 /**
@@ -263,6 +264,7 @@ async function buildApp() {
 	const resolvedNextConfig = await resolveNextConfig(await loadNextConfig(root, PHASE_PRODUCTION_BUILD), root);
 	process.env.__VINEXT_SHARED_BUILD_ID = resolvedNextConfig.buildId;
 	process.env.__VINEXT_SHARED_RSC_COMPATIBILITY_ID = createRscCompatibilityId(resolvedNextConfig);
+	if (!process.env.__VINEXT_SHARED_REVALIDATE_SECRET) process.env.__VINEXT_SHARED_REVALIDATE_SECRET = randomBytes(32).toString("hex");
 	const outputMode = resolvedNextConfig.output;
 	const distDir = path.resolve(root, "dist");
 	if (outputMode === "standalone") {

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

@@ -15,17 +15,26 @@ type NavigationRuntimeRscBootstrap = {
 };
 type NavigationRuntimeKind = "navigate" | "traverse" | "refresh";
 type NavigationRuntimeHistoryUpdateMode = "push" | "replace";
+type NavigationRuntimeVisibleCommitMode = "transition" | "synchronous";
 type NavigationRuntimeTraversalIntent = {
   direction: "back" | "forward" | "unknown";
   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) => Promise<void>;
+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 NavigationRuntimeFunctions = {
   clearNavigationCaches?: () => void;
   commitHashNavigation?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode, scroll: boolean) => void;
   navigateExternal?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode) => Promise<void>;
   navigate?: NavigationRuntimeNavigate;
+  /**
+   * Called at the start of every App Router navigation so the <Link> shim can
+   * reset any link that is still showing a `useLinkStatus()` pending state but
+   * is not the one driving this navigation (e.g. a programmatic router.push or
+   * a shallow-routing transition). Registered by shims/link.tsx; decoupled
+   * through the runtime to avoid a circular import with shims/navigation.ts.
+   */
+  notifyLinkNavigationStart?: () => void;
   pingVisibleLinks?: () => void;
 };
 type NavigationRuntimeBootstrap = {
@@ -58,4 +67,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, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };
+export { NAVIGATION_RUNTIME_KEY, NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION, NavigationRuntime, NavigationRuntimeBootstrap, NavigationRuntimeFunctions, NavigationRuntimeNavigate, NavigationRuntimeRscBootstrap, NavigationRuntimeRscChunk, NavigationRuntimeSnapshot, NavigationRuntimeVisibleCommitMode, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions, subscribeNavigationRuntimeRscChunk };

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, "pingVisibleLinks"));
+	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, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks"));
 }
 function isNavigationRuntimeRscChunk(value) {
 	if (typeof value === "string") return true;

package/dist/client/vinext-next-data.d.ts

@@ -10,7 +10,8 @@ type VinextNextData = {
   /** vinext-specific additions (not part of Next.js upstream). */__vinext?: {
     /** Absolute URL of the page module for dynamic import. */pageModuleUrl?: string; /** Absolute URL of the `_app` module for dynamic import. */
     appModuleUrl?: string; /** True when the Pages Router server has middleware/proxy configured. */
-    hasMiddleware?: boolean;
+    hasMiddleware?: boolean; /** True when build-time rewrites can affect the initial Pages Router ready state. */
+    hasRewrites?: boolean;
   };
 } & NEXT_DATA;
 type BrowserVinextNextData = NonNullable<Window["__NEXT_DATA__"]> & VinextNextData;

package/dist/client/window-next.d.ts

@@ -40,10 +40,9 @@
  * `window.next.router`. Mirrors the `publicAppRouterInstance` shape from
  * `packages/next/src/client/components/app-router-instance.ts`.
  *
- * `hmrRefresh` and `experimental_gesturePush` are intentionally omitted —
- * vinext does not implement them. Library callers that branch on their
- * presence (`typeof router.hmrRefresh === "function"`) will skip the
- * branch, matching what they would do on a production Next.js build.
+ * `hmrRefresh` is intentionally omitted — vinext does not implement it.
+ * `experimental_gesturePush` is attached only when
+ * `experimental.gestureTransition` is enabled, matching Next.js.
  */
 type AppRouterPublicInstance = {
   push: (href: string, options?: {
@@ -57,6 +56,9 @@ type AppRouterPublicInstance = {
   refresh: () => void;
   prefetch: (href: string, options?: {
     onInvalidate?: () => void;
+  }) => void;
+  experimental_gesturePush?: (href: string, options?: {
+    scroll?: boolean;
   }) => void; /** Default placeholder, matches Next.js. */
   bfcacheId?: string;
 };

package/dist/config/config-matchers.d.ts

@@ -32,10 +32,10 @@ declare function escapeHeaderSource(source: string): string;
  * Callers extract the relevant parts from the incoming Request.
  */
 type RequestContext = {
-  headers: Headers;
-  cookies: Record<string, string>;
-  query: URLSearchParams;
-  host: string;
+  readonly headers: Headers;
+  readonly cookies: Record<string, string>;
+  readonly query: URLSearchParams;
+  readonly host: string;
 };
 /**
  * basePath gating state passed alongside the pathname to every matcher.
@@ -65,6 +65,13 @@ type BasePathMatchState = {
 declare function parseCookies(cookieHeader: string | null): Record<string, string>;
 /**
  * Build a RequestContext from a Web Request object.
+ *
+ * `cookies` and `query` are lazy memoized getters: they are consumed only by
+ * `has`/`missing` condition evaluation (`checkHasConditions` /
+ * `matchesRuleConditions`), and most apps configure no such conditions. The
+ * cookie split and `searchParams` access are therefore deferred until first
+ * read and computed at most once. Mirrors `headersContextFromRequest` in
+ * `shims/headers.ts`.
  */
 declare function requestContextFromRequest(request: Request): RequestContext;
 declare function normalizeHost(hostHeader: string | null, fallbackHostname: string): string;
@@ -159,6 +166,25 @@ declare function sanitizeDestination(dest: string): string;
  * per RFC 3986, plus protocol-relative URLs (//).
  */
 declare function isExternalUrl(url: string): boolean;
+/**
+ * Merge the original request's query params into a config-redirect
+ * destination, preserving them on the resulting `Location`.
+ *
+ * Next.js carries the original request query across config redirects
+ * (`prepareDestination({ query: parsedUrl.query })` →
+ * `stringifyQuery(...)` in resolve-routes.ts). This matters for App Router
+ * RSC client navigations: the cache-busting `_rsc` query must survive the
+ * redirect so the browser's auto-followed request to the destination is
+ * still treated as an RSC fetch. Dropping it breaks RSC fetch semantics
+ * (issue #1529).
+ *
+ * Destination query params win — a request param is only carried over when
+ * the destination does not already specify that key. Mirrors the merge
+ * semantics in `proxyExternalRequest`. External destinations are returned
+ * untouched (a config redirect to another origin should not leak the
+ * original request's query).
+ */
+declare function preserveRedirectDestinationQuery(destination: string, requestSearch: string): string;
 /**
  * Proxy an incoming request to an external URL and return the upstream response.
  *
@@ -218,4 +244,4 @@ declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite>(route
   trailingSlash?: boolean;
 }): T[];
 //#endregion
-export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/config-matchers.js

@@ -356,13 +356,26 @@ function parseCookies(cookieHeader) {
 }
 /**
 * Build a RequestContext from a Web Request object.
+*
+* `cookies` and `query` are lazy memoized getters: they are consumed only by
+* `has`/`missing` condition evaluation (`checkHasConditions` /
+* `matchesRuleConditions`), and most apps configure no such conditions. The
+* cookie split and `searchParams` access are therefore deferred until first
+* read and computed at most once. Mirrors `headersContextFromRequest` in
+* `shims/headers.ts`.
 */
 function requestContextFromRequest(request) {
 	const url = new URL(request.url);
+	let cookies;
+	let query;
 	return {
 		headers: request.headers,
-		cookies: parseCookies(request.headers.get("cookie")),
-		query: url.searchParams,
+		get cookies() {
+			return cookies ??= parseCookies(request.headers.get("cookie"));
+		},
+		get query() {
+			return query ??= url.searchParams;
+		},
 		host: normalizeHost(request.headers.get("host"), url.hostname)
 	};
 }
@@ -764,6 +777,40 @@ function isExternalUrl(url) {
 	return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
 }
 /**
+* Merge the original request's query params into a config-redirect
+* destination, preserving them on the resulting `Location`.
+*
+* Next.js carries the original request query across config redirects
+* (`prepareDestination({ query: parsedUrl.query })` →
+* `stringifyQuery(...)` in resolve-routes.ts). This matters for App Router
+* RSC client navigations: the cache-busting `_rsc` query must survive the
+* redirect so the browser's auto-followed request to the destination is
+* still treated as an RSC fetch. Dropping it breaks RSC fetch semantics
+* (issue #1529).
+*
+* Destination query params win — a request param is only carried over when
+* the destination does not already specify that key. Mirrors the merge
+* semantics in `proxyExternalRequest`. External destinations are returned
+* untouched (a config redirect to another origin should not leak the
+* original request's query).
+*/
+function preserveRedirectDestinationQuery(destination, requestSearch) {
+	if (requestSearch === "" || requestSearch === "?" || isExternalUrl(destination)) return destination;
+	const requestParams = new URLSearchParams(requestSearch);
+	if ([...requestParams.keys()].length === 0) return destination;
+	const hashIndex = destination.indexOf("#");
+	const hash = hashIndex === -1 ? "" : destination.slice(hashIndex);
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const pathPart = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+	const destQuery = queryIndex === -1 ? "" : beforeHash.slice(queryIndex + 1);
+	const merged = new URLSearchParams(destQuery);
+	const destKeys = new Set(merged.keys());
+	for (const [key, value] of requestParams) if (!destKeys.has(key)) merged.append(key, value);
+	const mergedQuery = merged.toString();
+	return mergedQuery === "" ? `${pathPart}${hash}` : `${pathPart}?${mergedQuery}${hash}`;
+}
+/**
 * Proxy an incoming request to an external URL and return the upstream response.
 *
 * Used for external rewrites (e.g. `/ph/:path*` → `https://us.i.posthog.com/:path*`).
@@ -925,4 +972,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/next-config.d.ts

@@ -132,7 +132,14 @@ type NextConfig = {
    */
   instrumentationClientInject?: string[]; /** Extra origins allowed to access the dev server. */
   allowedDevOrigins?: string[]; /** Maximum age in seconds for stale ISR entries before blocking regeneration. */
-  expireTime?: number; /** User agents that require blocking metadata in the initial head. */
+  expireTime?: number;
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during App Router SSR. React drops whole entries once the limit is
+   * exceeded; `0` disables emission entirely. Defaults to 6000.
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/reactMaxHeadersLength
+   */
+  reactMaxHeadersLength?: number; /** User agents that require blocking metadata in the initial head. */
   htmlLimitedBots?: RegExp | string;
   /**
    * Enable Cache Components (Next.js 16).
@@ -174,6 +181,14 @@ type NextConfig = {
      */
     defineServer?: Record<string, string | number | boolean>;
   };
+  experimental?: {
+    /**
+     * Enables the experimental App Router gesture transition API:
+     * `useRouter().experimental_gesturePush()`.
+     */
+    gestureTransition?: boolean;
+    [key: string]: unknown;
+  };
   /**
    * Path to a custom cache handler module (e.g., KV, Redis, DynamoDB).
    * Accepts relative paths, absolute paths, or file:// URLs from import.meta.resolve().
@@ -223,6 +238,11 @@ type ResolvedNextConfig = {
   pageExtensions: string[];
   instrumentationClientInject: string[];
   cacheComponents: boolean;
+  /**
+   * Enables the experimental App Router gesture transition API:
+   * `useRouter().experimental_gesturePush()`.
+   */
+  gestureTransition: boolean;
   /**
    * Whether `experimental.prefetchInlining` is configured. Next.js uses this
    * with the Segment Cache to fetch the route tree before the bundled inlined
@@ -244,8 +264,14 @@ type ResolvedNextConfig = {
   serverActionsAllowedOrigins: string[]; /** Packages whose barrel imports should be optimized (from experimental.optimizePackageImports). */
   optimizePackageImports: string[]; /** Inline app CSS into production HTML (from experimental.inlineCss). */
   inlineCss: boolean; /** Parsed body size limit for server actions in bytes (from experimental.serverActions.bodySizeLimit). Defaults to 1MB. */
-  serverActionsBodySizeLimit: number; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
-  expireTime: number; /** Serialized htmlLimitedBots regexp source from next.config. */
+  serverActionsBodySizeLimit: number; /** Verbatim body size limit config value (e.g. "2mb") for the "Body exceeded {limit} limit" error. Defaults to "1 MB". */
+  serverActionsBodySizeLimitLabel: string; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
+  expireTime: number;
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during App Router SSR. `0` disables emission. Defaults to 6000.
+   */
+  reactMaxHeadersLength: number; /** Serialized htmlLimitedBots regexp source from next.config. */
   htmlLimitedBots: string | undefined;
   /**
    * Packages that should be treated as server-external (not bundled by Vite).