vinext 0.2.1 → 1.0.0-beta.1

package/dist/routing/app-route-graph.js

@@ -1,10 +1,9 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
 import fs from "node:fs";
-import path from "node:path";
 import { createHash } from "node:crypto";
 //#region src/routing/app-route-graph.ts
 /**
@@ -363,10 +362,6 @@ function createRouteManifestGraphVersion(segmentGraph) {
 }
 /**
 * Build the App Router route graph by scanning `appDir`.
-*
-* `appDir` must be forward-slash. Every path in the graph is derived from it
-* with `path.posix.*` and `findFile`, so a native appDir would produce mixed
-* separators on Windows. Production callers normalize it at their entry.
 */
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
@@ -384,8 +379,8 @@ async function buildAppRouteGraph(appDir, matcher) {
 	const routePatterns = new Set(routes.map((route) => route.pattern));
 	const ghostParentRoutes = [];
 	for await (const file of scanWithExtensions("**/layout", appDir, scanMatcher.extensions, excludeDir)) {
-		const dir = path.posix.dirname(file);
-		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
+		const dir = path.dirname(file);
+		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, scanMatcher, true).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null, true);
@@ -440,9 +435,9 @@ function validatePageRouteConflicts(routes, appDir) {
 	}
 }
 function formatAppFilePath(filePath, appDir) {
-	const relativePath = normalizePathSeparators(path.relative(appDir, filePath));
+	const relativePath = path.relative(appDir, filePath);
 	const parsedPath = path.parse(relativePath);
-	const withoutExtension = normalizePathSeparators(path.join(parsedPath.dir, parsedPath.name));
+	const withoutExtension = path.join(parsedPath.dir, parsedPath.name);
 	return withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
 }
 /**
@@ -704,27 +699,15 @@ function findCatchAllPage(dir, matcher) {
 }
 /**
 * Convert a file path relative to app/ into an AppRoute.
-*
-* `file` and `appDir` must be forward-slash. `file` comes from
-* `scanWithExtensions` (already forward-slash) and is joined onto `appDir` with
-* `path.posix.join` to form the page/route path, so a native input would
-* produce a mixed separator on Windows.
 */
 function fileToAppRoute(file, appDir, type, matcher) {
-	let dir = path.posix.dirname(file);
-	if (type === "page" && dir !== "." && path.posix.basename(dir) === "@children") {
-		const parent = path.posix.dirname(dir);
+	let dir = path.dirname(file);
+	if (type === "page" && dir !== "." && path.basename(dir) === "@children") {
+		const parent = path.dirname(dir);
 		dir = parent === "" || parent === "." ? "." : parent;
 	}
-	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.posix.join(appDir, file) : null, type === "route" ? path.posix.join(appDir, file) : null);
+	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
-/**
-* `dir`, `appDir`, `pagePath`, and `routePath` must all be forward-slash. `dir`
-* is split on `path.posix.sep` and joined onto `appDir` with `path.posix.join`.
-* `appDir` is threaded to the layout/slot/boundary discovery below, which builds
-* paths the same way. `pagePath` and `routePath` are stored on the route node as
-* canonical ids that get compared and re-joined downstream.
-*/
 function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeNestedOnlySlots = false) {
 	const segments = dir === "." ? [] : dir.split("/");
 	const params = [];
@@ -743,7 +726,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
-	const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
+	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 	const effectivePagePath = pagePath ?? (routePath ? null : findFile(routeDir, "default", matcher));
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
@@ -850,8 +833,9 @@ function convertTreePathToRouteParts(treePath) {
 function computeLayoutTreePositions(appDir, layouts) {
 	return layouts.map((layoutPath) => {
 		const layoutDir = path.dirname(layoutPath);
-		if (layoutDir === appDir) return 0;
-		return path.relative(appDir, layoutDir).split(path.sep).length;
+		const relative = path.relative(appDir, layoutDir);
+		if (relative === "") return 0;
+		return relative.split(path.sep).length;
 	});
 }
 /**
@@ -976,10 +960,6 @@ function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
 * Walk from appDir through each segment to the route's directory. At each level
 * that has @slot dirs, collect them. Slots at the route's own directory level
 * use page.tsx; slots at ancestor levels use default.tsx only.
-*
-* `appDir` and `routeDir` must be forward-slash — `currentDir` descends from
-* `appDir` via `path.posix.join`, and the `dir === routeDir` active-level test
-* below only matches when both share the canonical separator.
 */
 function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots = false) {
 	const slotMap = /* @__PURE__ */ new Map();
@@ -992,7 +972,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.posix.join(currentDir, segments[i]);
+		currentDir = path.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -1155,9 +1135,6 @@ function patternsStructurallyEquivalent(a, b) {
 *
 * Returns the absolute page path, or null if no root-level page is found.
 *
-* `slotDir` must be forward-slash: the `path.posix.join` descent stays a
-* canonical id only when the base already is.
-*
 * Only descends into route-group directories (those whose name starts with `(`
 * and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
 * are not transparent and are therefore not searched.
@@ -1169,7 +1146,7 @@ function findSlotRootPage(slotDir, matcher) {
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
-		const found = findSlotRootPage(path.posix.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
@@ -1178,9 +1155,6 @@ function findSlotRootPage(slotDir, matcher) {
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
 * Returns a ParallelSlot for each @-prefixed subdirectory that has a page,
 * default component, intercepting route, or nested page-backed sub-route.
-*
-* `dir` and `appDir` must be forward-slash. The slot directory is built from
-* `dir` with `path.posix.join`.
 */
 function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = false) {
 	const entries = readDirEntriesCached(dir, matcher);
@@ -1189,7 +1163,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.posix.join(dir, entry.name);
+		const slotDir = path.join(dir, entry.name);
 		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
@@ -1200,7 +1174,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
-			key: `${slotName}@${normalizePathSeparators(path.relative(appDir, slotDir))}`,
+			key: `${slotName}@${path.relative(appDir, slotDir)}`,
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
@@ -1259,9 +1233,6 @@ function isInterceptionMarkerDir(name) {
 * Intercepting routes use conventions like (.)photo, (..)feed, (...), etc.
 * They intercept navigation to another route and render within the slot instead.
 *
-* `slotDir`, `routeDir`, and `appDir` must be forward-slash. They are passed
-* down to `path.posix.join` when building the intercept page paths.
-*
 * @param slotDir - The parallel slot directory (e.g. app/feed/@modal)
 * @param routeDir - The directory of the route that owns this slot (e.g. app/feed)
 * @param appDir - The root app directory
@@ -1280,17 +1251,13 @@ function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 * Sibling intercepts use the same conventions and target-computation logic as
 * slot intercepts, but their intercepting page replaces the full page response
 * (not a slot) during soft navigation.
-*
-* `appDir` and each route's `pagePath` / `routePath` must be forward-slash. The
-* owner directories are derived from `pagePath` / `routePath` and matched
-* against `appDir`-relative paths built with `path.posix.*`.
 */
 function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 	const routesByDir = /* @__PURE__ */ new Map();
 	for (const route of routes) {
 		const filePath = route.pagePath ?? route.routePath;
 		if (!filePath) continue;
-		const routeDir = path.posix.dirname(filePath);
+		const routeDir = path.dirname(filePath);
 		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
 	}
 	function walk(dir) {
@@ -1304,7 +1271,7 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 			if (!entry.isDirectory()) continue;
 			if (entry.name.startsWith("_")) continue;
 			if (entry.name.startsWith("@")) continue;
-			const childDir = path.posix.join(dir, entry.name);
+			const childDir = path.join(dir, entry.name);
 			const marker = matchInterceptConvention(entry.name);
 			if (marker) {
 				const restOfName = entry.name.slice(marker.prefix.length);
@@ -1335,18 +1302,15 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 *    no sibling pages at all (e.g. `deep/path/(...)target` with no
 *    `deep/path/page.tsx`).
 *
-* All comparisons happen in forward-slash space: `appDir` is forward-slash
-* (normalized once in the config hook), but `dir` and route file paths
-* descend through native `path.join`/`path.dirname`, which reintroduce
-* backslashes on Windows. Without normalizing, the `current === appDir`
-* termination never fires there and the walk overshoots the app root.
-* `routesByDir` keys must be forward-slash dirnames of the route file paths.
+* Comparisons happen in forward-slash space — inputs go through `toSlash` so
+* callers still holding native-separator paths hit the `current === appDir`
+* termination instead of overshooting the app root.
 *
 * Exported for tests.
 */
 function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
-	const appRoot = normalizePathSeparators(appDir);
-	let current = normalizePathSeparators(dir);
+	const appRoot = toSlash(appDir);
+	let current = toSlash(dir);
 	while (true) {
 		const exact = routesByDir.get(current);
 		if (exact) return exact;
@@ -1355,7 +1319,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 		for (const route of routes) {
 			const filePath = route.pagePath ?? route.routePath;
 			if (!filePath) continue;
-			if (!normalizePathSeparators(filePath).startsWith(currentWithSep)) continue;
+			if (!toSlash(filePath).startsWith(currentWithSep)) continue;
 			if (!best || route.patternParts.length < best.patternParts.length) best = route;
 		}
 		if (best) return best;
@@ -1369,9 +1333,6 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 /**
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
-*
-* `currentDir`, `routeDir`, and `appDir` must be forward-slash. `currentDir`
-* descends with `path.posix.join` when building the intercept page paths.
 */
 function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher) {
 	if (!fs.existsSync(currentDir)) return;
@@ -1380,7 +1341,7 @@ function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
 		const interceptMatch = matchInterceptConvention(entry.name);
-		const interceptDir = path.posix.join(currentDir, entry.name);
+		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
 			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
@@ -1397,12 +1358,6 @@ function matchInterceptConvention(name) {
 /**
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
-*
-* `currentDir`, `interceptRoot`, `routeDir`, `appDir`, and `interceptParentDir`
-* must all be forward-slash. `currentDir` descends with `path.posix.join` and
-* its `findFile` results become the stored layout/page paths. The others are
-* relativized against `appDir` (and each other) to derive the intercept page
-* segments and URL patterns.
 */
 function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
@@ -1422,7 +1377,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
-				sourcePageSegments: normalizePathSeparators(path.relative(appDir, path.dirname(page))).split("/").filter(Boolean),
+				sourcePageSegments: path.relative(appDir, path.dirname(page)).split("/").filter(Boolean),
 				params: targetPattern.params
 			});
 		}
@@ -1432,7 +1387,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.posix.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
 	}
 }
 /**
@@ -1552,9 +1507,6 @@ const findFileProbeCache = /* @__PURE__ */ new WeakMap();
 * registered per-scan cache; otherwise falls back to a direct probe (identical
 * result). The `null` "not found" outcome is cached too, so repeated misses on
 * shared ancestors cost a single set of `existsSync` calls per scan.
-*
-* `dir` must be forward-slash. The returned path comes from `findFileWithExts`,
-* so it is forward-slash too.
 */
 function findFile(dir, name, matcher) {
 	const cache = findFileProbeCache.get(matcher);

package/dist/routing/app-router.d.ts

@@ -12,16 +12,11 @@ declare function invalidateAppRouteCache(): void;
  * TODO(#726): Layer 4 should consume this read model directly once the
  * navigation planner owns route graph facts.
  *
- * `appDir` must be forward-slash — callers normalize it at their entry, and it
- * flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
- *
  * @internal
  */
 declare function appRouteGraph(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraph>;
 /**
  * Scan the app/ directory and return a list of routes.
- *
- * `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
  */
 declare function appRouter(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraphRoute[]>;
 /**

package/dist/routing/app-router.js

@@ -30,9 +30,6 @@ function invalidateAppRouteCache() {
 * TODO(#726): Layer 4 should consume this read model directly once the
 * navigation planner owns route graph facts.
 *
-* `appDir` must be forward-slash — callers normalize it at their entry, and it
-* flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
-*
 * @internal
 */
 async function appRouteGraph(appDir, pageExtensions, matcher) {
@@ -47,8 +44,6 @@ async function appRouteGraph(appDir, pageExtensions, matcher) {
 }
 /**
 * Scan the app/ directory and return a list of routes.
-*
-* `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
 */
 async function appRouter(appDir, pageExtensions, matcher) {
 	return (await appRouteGraph(appDir, pageExtensions, matcher)).routes;

package/dist/routing/file-matcher.d.ts

@@ -21,9 +21,6 @@ declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatc
 /**
  * Find a file by basename and configured page extension in a directory.
  * Returns the first matching absolute path, or null if not found.
- *
- * `dir` must be forward-slash. The returned path is built with `path.posix.join`,
- * so it is forward-slash too.
  */
 declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
 /**
@@ -66,9 +63,8 @@ declare function normalizeViteResolveExtensions(extensions: readonly string[]):
  * Use function-form exclude for Node < 22.14 compatibility.
  *
  * Yields forward-slash relative paths: node's glob emits native (backslash)
- * separators on Windows, so each match is normalized — this is the entry point
- * that lets downstream consumers treat the scanned paths as canonical
- * forward-slash ids.
+ * separators on Windows, so each match goes through `toSlash` — this is the
+ * boundary where external fs output enters the canonical forward-slash space.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion

package/dist/routing/file-matcher.js

@@ -1,7 +1,6 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
 import { existsSync } from "node:fs";
-import path from "node:path";
 import { glob } from "node:fs/promises";
 //#region src/routing/file-matcher.ts
 const DEFAULT_PAGE_EXTENSIONS = [
@@ -19,6 +18,10 @@ function buildExtensionGlob(stem, extensions) {
 	if (extensions.length === 1) return `${stem}.${extensions[0]}`;
 	return `${stem}.{${extensions.join(",")}}`;
 }
+function includeDotDirectoryMatches(pattern) {
+	if (!pattern.startsWith("**/")) return pattern;
+	return `{**,**/.*/**}/${pattern.slice(3)}`;
+}
 /**
 * Ported in spirit from Next.js createValidFileMatcher:
 * packages/next/src/server/lib/find-page-file.ts
@@ -67,13 +70,10 @@ function findFileWithExtensions(basePath, matcher) {
 /**
 * Find a file by basename and configured page extension in a directory.
 * Returns the first matching absolute path, or null if not found.
-*
-* `dir` must be forward-slash. The returned path is built with `path.posix.join`,
-* so it is forward-slash too.
 */
 function findFileWithExts(dir, name, matcher) {
 	for (const ext of matcher.dottedExtensions) {
-		const filePath = path.posix.join(dir, name + ext);
+		const filePath = path.join(dir, name + ext);
 		if (existsSync(filePath)) return filePath;
 	}
 	return null;
@@ -153,16 +153,15 @@ function normalizeViteResolveExtensions(extensions) {
 * Use function-form exclude for Node < 22.14 compatibility.
 *
 * Yields forward-slash relative paths: node's glob emits native (backslash)
-* separators on Windows, so each match is normalized — this is the entry point
-* that lets downstream consumers treat the scanned paths as canonical
-* forward-slash ids.
+* separators on Windows, so each match goes through `toSlash` — this is the
+* boundary where external fs output enters the canonical forward-slash space.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
-	const pattern = buildExtensionGlob(stem, extensions);
+	const pattern = includeDotDirectoryMatches(buildExtensionGlob(stem, extensions));
 	for await (const file of glob(pattern, {
 		cwd,
 		...exclude ? { exclude } : {}
-	})) yield normalizePathSeparators(file);
+	})) yield toSlash(file);
 }
 //#endregion
 export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/routing/pages-router.js

@@ -1,11 +1,11 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { decodeRouteSegment, sortRoutes } from "./utils.js";
 import { createValidFileMatcher, scanWithExtensions } from "./file-matcher.js";
 import { patternToNextFormat, validateRoutePatterns } from "./route-validation.js";
 import { createRouteTrieCache, matchRouteWithTrie } from "./route-matching.js";
-import path from "node:path";
 //#region src/routing/pages-router.ts
 /** Next.js special pages that should not produce routes. */
-const RESERVED_PAGE_NAMES = new Set([
+const RESERVED_PAGE_NAMES = /* @__PURE__ */ new Set([
 	"_app",
 	"_document",
 	"_error"
@@ -152,7 +152,7 @@ async function scanApiRoutes(pagesDir, matcher) {
 	}
 	const routes = [];
 	for (const file of files) {
-		const route = fileToRoute(path.posix.join("api", file), pagesDir, matcher);
+		const route = fileToRoute(path.join("api", file), pagesDir, matcher);
 		if (route) routes.push(route);
 	}
 	validateRoutePatterns(routes.map((route) => route.pattern));

package/dist/server/api-handler.js

@@ -8,7 +8,7 @@ import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pa
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
-import { attachPagesRequestCookies } from "./pages-node-compat.js";
+import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
@@ -166,41 +166,49 @@ function enhanceApiObjects(req, res, query, body) {
 		query
 	});
 	attachPagesRequestCookies(apiReq);
-	return {
-		apiReq,
-		apiRes: Object.assign(res, {
-			status(code) {
-				this.statusCode = code;
-				return this;
-			},
-			json(data) {
+	const apiRes = Object.assign(res, {
+		status(code) {
+			this.statusCode = code;
+			return this;
+		},
+		json(data) {
+			this.setHeader("Content-Type", "application/json");
+			this.end(JSON.stringify(data));
+		},
+		send(data) {
+			if (Buffer.isBuffer(data)) {
+				if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
+				this.setHeader("Content-Length", String(data.length));
+				this.end(data);
+				return;
+			}
+			if (typeof data === "object" && data !== null) {
 				this.setHeader("Content-Type", "application/json");
 				this.end(JSON.stringify(data));
-			},
-			send(data) {
-				if (Buffer.isBuffer(data)) {
-					if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
-					this.setHeader("Content-Length", String(data.length));
-					this.end(data);
-					return;
-				}
-				if (typeof data === "object" && data !== null) {
-					this.setHeader("Content-Type", "application/json");
-					this.end(JSON.stringify(data));
-				} else {
-					if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "text/plain");
-					this.end(String(data));
-				}
-			},
-			redirect(statusOrUrl, url) {
-				if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
-				else this.writeHead(statusOrUrl, { Location: url ?? "" });
-				this.end();
-			},
-			async revalidate(urlPath, opts) {
-				await performOnDemandRevalidate(req, urlPath, opts);
+			} else {
+				if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "text/plain");
+				this.end(String(data));
+			}
+		},
+		redirect(statusOrUrl, url) {
+			if (typeof statusOrUrl === "string") {
+				url = statusOrUrl;
+				statusOrUrl = 307;
 			}
-		})
+			if (typeof statusOrUrl !== "number" || typeof url !== "string") throw new Error("Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').");
+			this.writeHead(statusOrUrl, { Location: url });
+			this.write(url);
+			this.end();
+			return this;
+		},
+		async revalidate(urlPath, opts) {
+			await performOnDemandRevalidate(req, urlPath, opts);
+		}
+	});
+	attachPagesPreviewApi(apiReq, apiRes);
+	return {
+		apiReq,
+		apiRes
 	};
 }
 /**

package/dist/server/app-browser-entry.js

@@ -1,6 +1,5 @@
-import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
+import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { AppElementsWire } from "./app-elements-wire.js";
-import { APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI } from "./app-rsc-render-mode.js";
 import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
@@ -598,9 +597,10 @@ function BrowserRoot({ hydrationCachePublication, initialElements, initialNaviga
 		resetKey: treeState.renderId,
 		onCatch: handleDevRecoveryBoundaryCatch
 	}, innerTree) : innerTree;
+	const scrollScopedTree = createElement(AppRouterScrollCommitProvider, { commitId: treeState.renderId }, committedTree);
 	const rootErrorTree = createElement(GlobalErrorBoundary, {
 		fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
-		children: createElement(AppRouterScrollCommitProvider, { commitId: treeState.renderId }, committedTree)
+		children: scrollScopedTree
 	});
 	const ClientNavigationRenderContext = getClientNavigationRenderContext();
 	if (!ClientNavigationRenderContext) return rootErrorTree;
@@ -764,7 +764,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		const metadata = AppElementsWire.readMetadata(elements);
 		if (!isCompleteAppPayloadMetadata(metadata)) return;
 		const mountedSlotsHeader = getMountedSlotIdsHeader(elements);
-		const rscUrl = await createRscRequestUrl(initialPathAndSearch, createRscRequestHeaders({ mountedSlotsHeader }));
+		const headers = createRscRequestHeaders({ mountedSlotsHeader });
+		const rscUrl = await createRscRequestUrl(initialPathAndSearch, headers);
 		if (cacheGeneration !== clientNavigationCacheGeneration) return;
 		const snapshot = {
 			compatibilityIdHeader: CLIENT_RSC_COMPATIBILITY_ID,
@@ -852,9 +853,9 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			let redirectCount = redirectDepth;
 			let detachedNavigationCommits = false;
 			const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? historyController.resolveTraversalIntent(window.history.state) : null;
-			const performHardNavigationForScrollIntent = (targetHref) => {
+			const performHardNavigationForScrollIntent = (targetHref, mode) => {
 				consumeAppRouterScrollIntent(scrollIntent ?? null);
-				const didNavigate = browserNavigationController.performHardNavigation(targetHref);
+				const didNavigate = browserNavigationController.performHardNavigation(targetHref, mode);
 				if (!didNavigate) clearAppNavigationFailureTarget(targetHref);
 				return didNavigate;
 			};
@@ -888,8 +889,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const shouldBypassNavigationCache = earlyIntentDecision?.kind === "flightNavigation" && earlyIntentDecision.bypassNavigationCache;
 					const requestHeaders = createRscRequestHeaders({
 						interceptionContext: requestInterceptionContext,
-						mountedSlotsHeader,
-						renderMode: navigationKind === "refresh" ? APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI : void 0
+						mountedSlotsHeader
 					});
 					const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
 					const rewrittenNavigationHref = navigationKind === "navigate" ? resolveHybridClientRewriteHref(currentHref, __basePath) : null;
@@ -1035,6 +1035,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					const navContentType = navResponse.headers.get("content-type") ?? "";
 					const streamedRedirectTarget = navResponse.headers.get(VINEXT_RSC_REDIRECT_HEADER);
+					const streamedRedirectTypeHeader = navResponse.headers.get(VINEXT_RSC_REDIRECT_TYPE_HEADER);
+					const streamedRedirectType = streamedRedirectTypeHeader === "push" || streamedRedirectTypeHeader === "replace" ? streamedRedirectTypeHeader : null;
 					if (blockDangerousStreamedRscRedirect(navResponse, streamedRedirectTarget)) return;
 					const liveFetchDecision = navigationPlanner.classifyRscFetchResult({
 						clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
@@ -1049,13 +1051,14 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						responseOk: navResponse.ok,
 						responseUrl: navResponseUrl ?? navResponse.url,
 						source: "live",
-						streamedRedirectTarget
+						streamedRedirectTarget,
+						streamedRedirectType
 					});
 					if (liveFetchDecision.kind === "hardNavigate") {
 						if (liveFetchDecision.discardBody) navResponse.body?.cancel().catch(() => {});
 						if (liveFetchDecision.reason === "redirectDepthExhausted") console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
 						if (liveFetchDecision.reason === "streamedRedirectLoop") console.error("[vinext] RSC streamed redirect resolved to the current URL — aborting navigation to prevent infinite loop.");
-						performHardNavigationForScrollIntent(liveFetchDecision.url);
+						performHardNavigationForScrollIntent(liveFetchDecision.url, liveFetchDecision.hardNavigationMode);
 						return;
 					}
 					if (liveFetchDecision.kind === "followRedirect") {
@@ -1206,7 +1209,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			}
 		};
 		import.meta.hot.on("rsc:update", () => {
-			handleRscUpdate(++latestRscHmrUpdateId);
+			const updateId = ++latestRscHmrUpdateId;
+			handleRscUpdate(updateId);
 		});
 	}
 }

package/dist/server/app-browser-navigation-controller.js

@@ -259,12 +259,14 @@ function createAppBrowserNavigationController(deps = {}) {
 		}
 		if (visibleCommitMode === "synchronous") {
 			flushSync(() => {
-				setter(captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit)));
+				const committedState = captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
+				setter(committedState);
 			});
 			return;
 		}
 		startTransition(() => {
-			setter(captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit)));
+			const committedState = captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
+			setter(committedState);
 		});
 	}
 	function dispatchSynchronousVisibleCommit(commit) {
@@ -449,8 +451,11 @@ function createAppBrowserNavigationController(deps = {}) {
 				return;
 			}
 			if (latestApproval.approvedCommit) {
-				dispatchSynchronousVisibleCommit(latestApproval.approvedCommit);
-				syncHistoryStatePreviousNextUrl(latestApproval.approvedCommit.previousNextUrl, latestApproval.approvedCommit.action.bfcacheIds);
+				const approvedRevalidationCommit = latestApproval.approvedCommit;
+				startTransition(() => {
+					dispatchSynchronousVisibleCommit(approvedRevalidationCommit);
+				});
+				syncHistoryStatePreviousNextUrl(approvedRevalidationCommit.previousNextUrl, approvedRevalidationCommit.action.bfcacheIds);
 			} else notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		} else if (decision.disposition === "no-commit") notifyDiscardedServerActionRevalidation(lifecycleOptions);
 		if (returnValue) {

package/dist/server/app-browser-server-action-client.js

@@ -49,7 +49,7 @@ var ServerActionRedirectError = class extends Error {
 		const redirectUrl = new URL(target.href, window.location.href);
 		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
 		const redirectType = target.type === "push" ? "push" : "replace";
-		this.digest = `NEXT_REDIRECT;${redirectType};${encodeURIComponent(redirectHref)};${target.status};`;
+		this.digest = `NEXT_REDIRECT;${redirectType};${redirectHref};${target.status};`;
 	}
 };
 async function invokeClientServerAction(id, args, actionInitiation, deps) {