vinext 0.1.7 → 0.1.8

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

@@ -1,5 +1,5 @@
-import { normalizePathSeparators } from "../utils/path.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
@@ -360,8 +360,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.dirname(file);
-		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+		const dir = path.posix.dirname(file);
+		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, scanMatcher).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null);
@@ -434,11 +434,16 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	const applySlotSubPages = (route, slotPages, rawSegments) => {
 		route.parallelSlots = route.parallelSlots.map((slot) => {
 			const subPage = slotPages.get(slot.key);
-			if (subPage !== void 0) return {
-				...slot,
-				pagePath: subPage,
-				routeSegments: rawSegments
-			};
+			if (subPage !== void 0) {
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				return {
+					...slot,
+					pagePath: subPage,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					routeSegments: rawSegments
+				};
+			}
 			return slot;
 		});
 	};
@@ -495,9 +500,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (Array.from(routesByPattern.values()).some((r) => patternsStructurallyEquivalent(r.patternParts, syntheticParts))) continue;
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -574,6 +582,23 @@ function findSlotSubPages(slotDir, matcher) {
 	perMatcher.set(slotDir, results);
 	return results;
 }
+function findSlotConfigLayoutPaths(slotDir, pagePath, matcher) {
+	if (!pagePath) return [];
+	const layouts = [];
+	let dir = path.dirname(pagePath);
+	while (dir !== slotDir && dir.startsWith(`${slotDir}${path.sep}`)) {
+		const layoutPath = findFile(dir, "layout", matcher);
+		if (layoutPath) layouts.unshift(layoutPath);
+		dir = path.dirname(dir);
+	}
+	return layouts;
+}
+function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
+	return layoutPaths.map((layoutPath) => {
+		const relativeDir = path.relative(slotDir, path.dirname(layoutPath));
+		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
+	});
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -613,8 +638,14 @@ function fileToAppRoute(file, appDir, type, matcher) {
 	}
 	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
+/**
+* `dir` and `appDir` must both be forward-slash. `dir` is split on
+* `path.posix.sep` and joined onto `appDir` with `path.posix.join`, and `appDir`
+* is threaded to the layout/slot/boundary discovery below, which build paths the
+* same way.
+*/
 function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.sep);
+	const segments = dir === "." ? [] : dir.split(path.posix.sep);
 	const params = [];
 	let isDynamic = false;
 	const convertedRoute = convertSegmentsToRouteParts(segments);
@@ -631,7 +662,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	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.join(appDir, dir);
+	const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
 	const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
@@ -863,6 +894,10 @@ 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) {
 	const slotMap = /* @__PURE__ */ new Map();
@@ -875,7 +910,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.join(currentDir, segments[i]);
+		currentDir = path.posix.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -902,9 +937,12 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 				slotPatternParts = [...ownerUrl?.urlSegments ?? [], ...mirror.slotUrlSegments];
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
+			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
 			const inheritedSlot = {
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
+				configLayoutPaths,
+				configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 				layoutIndex: slotLayoutIdx,
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
@@ -1035,6 +1073,9 @@ 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.
@@ -1051,7 +1092,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.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.posix.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
@@ -1068,13 +1109,14 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.join(dir, entry.name);
+		const slotDir = path.posix.join(dir, entry.name);
 		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
+		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
@@ -1085,6 +1127,8 @@ function discoverParallelSlots(dir, appDir, matcher) {
 			pagePath,
 			defaultPath,
 			layoutPath: findFile(slotDir, "layout", matcher),
+			configLayoutPaths,
+			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
 			interceptingRoutes,
@@ -1272,8 +1316,12 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			results.push({
+				branchSegments: [interceptSegment, ...normalizePathSeparators(path.relative(interceptRoot, path.dirname(page))).split("/").filter(Boolean)],
 				convention,
 				layoutPaths: [...layoutPaths],
+				layoutSegments: layoutPaths.map((layoutPath) => {
+					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+				}),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,

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

@@ -12,11 +12,16 @@ 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,6 +30,9 @@ 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) {
@@ -44,6 +47,8 @@ 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

@@ -54,6 +54,11 @@ declare function buildViteResolveExtensions(pageExtensions?: readonly string[] |
 declare function normalizeViteResolveExtensions(extensions: readonly string[]): 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.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion

package/dist/routing/file-matcher.js

@@ -1,4 +1,5 @@
 import { escapeRegExp } from "../utils/regex.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { glob } from "node:fs/promises";
@@ -135,13 +136,18 @@ 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.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	const pattern = buildExtensionGlob(stem, extensions);
 	for await (const file of glob(pattern, {
 		cwd,
 		...exclude ? { exclude } : {}
-	})) yield file;
+	})) yield normalizePathSeparators(file);
 }
 //#endregion
 export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

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

@@ -1,5 +1,4 @@
-import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
-import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_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";
@@ -14,7 +13,7 @@ import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../s
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
@@ -25,26 +24,23 @@ import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.js
 import { navigationPlanner } from "./navigation-planner.js";
 import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, getClientNavigationRenderContext, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.js";
 import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
-import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot } from "./app-browser-action-result.js";
 import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
-import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
+import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch } from "./app-browser-navigation-controller.js";
-import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
 import { AppBrowserHistoryController } from "./app-browser-history-controller.js";
 import { createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition } from "./app-browser-popstate.js";
 import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError } from "./app-browser-error.js";
-import { dismissOverlay } from "./dev-error-overlay-store.js";
-import { devOnCaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } from "./dev-error-overlay.js";
-import { throwOnServerActionNotFound } from "./server-action-not-found.js";
 import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
 import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
-import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
+import { createFromFetch, createFromReadableStream, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { createRoot, hydrateRoot } from "react-dom/client";
+import { hasServerActions, loadServerActionClient } from "virtual:vinext-app-capabilities";
 //#region src/server/app-browser-entry.ts
 function toActionType(kind) {
 	return kind === "traverse" ? "traverse" : "navigate";
@@ -94,10 +90,14 @@ const browserNavigationController = createAppBrowserNavigationController({
 	getRouteManifest: getBrowserRouteManifest,
 	syncHistoryStatePreviousNextUrl: (previousNextUrl, bfcacheIds) => historyController.syncCurrentHistoryStatePreviousNextUrl(previousNextUrl, bfcacheIds)
 });
-const discardedServerActionRefreshScheduler = createDiscardedServerActionRefreshScheduler({ runRefresh() {
+const discardedServerActionRefreshScheduler = hasServerActions ? createDiscardedServerActionRefreshScheduler({ runRefresh() {
 	clearClientNavigationCaches();
 	getNavigationRuntime()?.functions.navigate?.(window.location.href, 0, "refresh", void 0, void 0, true);
-} });
+} }) : {
+	markNavigationSettled() {},
+	markNavigationStart() {},
+	schedule() {}
+};
 const NavigationCommitSignal = browserNavigationController.NavigationCommitSignal;
 const ACTION_HTTP_FALLBACK_ROBOTS_META_ATTR = "data-vinext-action-http-fallback";
 function syncServerActionHttpFallbackHead(status) {
@@ -303,52 +303,6 @@ async function renderNavigationPayload(payload, navigationSnapshot, targetHref,
 		visibleCommitMode
 	});
 }
-function resolveActionRedirectTarget(response) {
-	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
-	if (!actionRedirect) return null;
-	if (isDangerousScheme(actionRedirect)) {
-		console.error(DANGEROUS_URL_BLOCK_MESSAGE);
-		return null;
-	}
-	try {
-		let redirectUrl;
-		if (actionRedirect.startsWith("/") || /^[a-z]+:/i.test(actionRedirect)) redirectUrl = new URL(actionRedirect, window.location.href);
-		else {
-			const baseParsed = new URL(window.location.href);
-			let baseDir = baseParsed.pathname;
-			if (!baseDir.endsWith("/")) baseDir = baseDir + "/";
-			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
-		}
-		if (redirectUrl.origin !== window.location.origin) {
-			browserNavigationController.performHardNavigation(actionRedirect);
-			return null;
-		}
-		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
-		const status = statusHeader ? parseInt(statusHeader, 10) : 307;
-		return {
-			href: redirectUrl.href,
-			type: response.headers.get("x-action-redirect-type") ?? "push",
-			status
-		};
-	} catch {
-		browserNavigationController.performHardNavigation(actionRedirect);
-		return null;
-	}
-}
-var ServerActionRedirectError = class extends Error {
-	digest;
-	handled = true;
-	constructor(target) {
-		super("NEXT_REDIRECT");
-		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};`;
-	}
-};
-function createServerActionRedirectError(target) {
-	return new ServerActionRedirectError(target);
-}
 async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none") {
 	const navigationSnapshot = createClientNavigationRenderSnapshot(actionInitiation.href, actionInitiation.routerState.navigationSnapshot.params);
 	return browserNavigationController.commitSameUrlNavigatePayload(nextElements, navigationSnapshot, returnValue, actionInitiation.routerState, {
@@ -709,112 +663,53 @@ function applyRuntimeRscBootstrap(rsc) {
 	if (rsc.nav) restoreHydrationNavigationContext(rsc.nav.pathname, rsc.nav.searchParams, params);
 }
 function registerServerActionCallback() {
-	const serverActionCallback = async (id, args) => {
-		syncServerActionHttpFallbackHead(null);
-		const temporaryReferences = createTemporaryReferenceSet();
+	setServerCallback((id, args) => {
+		const releaseCacheInvalidationGuard = historyController.beginCacheInvalidationGuard();
 		const actionInitiation = createActionInitiationSnapshot();
-		historyController.syncCurrentHistoryStatePreviousNextUrl(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
-		const body = await encodeReply(args, { temporaryReferences });
-		const { headers } = resolveServerActionRequestState({
-			actionId: id,
+		return loadServerActionClient().then(({ invokeClientServerAction }) => invokeClientServerAction(id, args, actionInitiation, {
 			basePath: __basePath,
-			elements: actionInitiation.routerState.elements,
-			previousNextUrl: actionInitiation.routerState.previousNextUrl
-		});
-		const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
-			method: "POST",
-			headers,
-			body
-		});
-		throwOnServerActionNotFound(fetchResponse, id);
-		const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
-		const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse);
-		if (hasActionRedirect && !actionRedirectTarget) return;
-		const actionResultFacts = createServerActionResultFacts({
-			actionRedirectHref: actionRedirectTarget?.href ?? null,
-			actionRedirectType: actionRedirectTarget?.type ?? null,
-			clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
-			compatibilityIdHeader: fetchResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
-			contentTypeHeader: fetchResponse.headers.get("content-type"),
-			currentHref: actionInitiation.href,
-			origin: window.location.origin,
-			responseUrl: fetchResponse.url
-		});
-		const fetchResponseIsRsc = actionResultFacts.isRscContentType;
-		if (applyServerActionResultDecision(navigationPlanner.classifyServerActionResult(actionResultFacts), clearClientNavigationCaches, (url, historyMode) => browserNavigationController.performHardNavigation(url, historyMode))) return;
-		const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
-		if (revalidation !== "none") clearClientNavigationCaches();
-		const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
-		if (invalidResponseError) throw invalidResponseError;
-		if (actionRedirectTarget && !fetchResponseIsRsc) {
-			browserNavigationController.performHardNavigation(actionRedirectTarget.href);
-			return;
-		}
-		const flightResponse = fetchResponse.status === 303 ? new Response(fetchResponse.body, {
-			headers: fetchResponse.headers,
-			status: 200,
-			statusText: "OK"
-		}) : fetchResponse;
-		const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
-		if (revalidation === "none" && shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) clearClientNavigationCaches();
-		if (actionRedirectTarget) {
-			if (isServerActionResult(result) && result.root !== void 0) {
-				const decoded = AppElementsWire.decode(result.root);
-				const hashIdx = actionRedirectTarget.href.indexOf("#");
-				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? actionRedirectTarget.href.slice(hashIdx) : "") || null);
-				if (actionRedirectTarget.type === "push") saveScrollPosition();
-				renderNavigationPayload(Promise.resolve(decoded), createClientNavigationRenderSnapshot(actionRedirectTarget.href, actionInitiation.routerState.navigationSnapshot.params), actionRedirectTarget.href, actionInitiation.navigationId, actionRedirectTarget.type === "push" ? "push" : "replace", {}, null, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, actionRedirectTarget.type === "push" ? "navigate" : "replace", "server-action", null, actionScrollIntent).catch(() => {
-					browserNavigationController.performHardNavigation(actionRedirectTarget.href);
+			clearClientNavigationCaches,
+			clientRscCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+			commitSameUrlNavigatePayload,
+			navigationPlanner,
+			performHardNavigation: (url, historyMode) => browserNavigationController.performHardNavigation(url, historyMode),
+			renderRedirectPayload(elements, target, actionInitiation) {
+				const hashIdx = target.href.indexOf("#");
+				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? target.href.slice(hashIdx) : "") || null);
+				if (target.type === "push") saveScrollPosition();
+				renderNavigationPayload(Promise.resolve(elements), createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params), target.href, actionInitiation.navigationId, target.type === "push" ? "push" : "replace", {}, null, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, target.type === "push" ? "navigate" : "replace", "server-action", null, actionScrollIntent).catch(() => {
+					browserNavigationController.performHardNavigation(target.href);
 				});
-				throw createServerActionRedirectError(actionRedirectTarget);
-			}
-			browserNavigationController.performHardNavigation(actionRedirectTarget.href);
-			return;
-		}
-		syncServerActionHttpFallbackHead(isServerActionResult(result) && result.root !== void 0 ? null : fetchResponse.status);
-		if (isServerActionResult(result)) {
-			if (result.root !== void 0) {
-				const returnValue = result.returnValue && !result.returnValue.ok ? {
-					ok: false,
-					data: normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status)
-				} : result.returnValue;
-				return commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation);
-			}
-			if (result.returnValue) {
-				if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
-				return result.returnValue.data;
-			}
-			return;
-		}
-		return commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
-	};
-	setServerCallback((id, args) => {
-		const releaseCacheInvalidationGuard = historyController.beginCacheInvalidationGuard();
-		return Promise.resolve().then(() => serverActionCallback(id, args)).finally(releaseCacheInvalidationGuard);
+			},
+			syncCurrentHistoryState: (previousNextUrl, bfcacheIds) => historyController.syncCurrentHistoryStatePreviousNextUrl(previousNextUrl, bfcacheIds),
+			syncServerActionHttpFallbackHead
+		})).finally(releaseCacheInvalidationGuard);
 	});
 }
 async function main() {
 	if (!claimInitialAppRouterBootstrap()) return;
-	registerServerActionCallback();
+	if (hasServerActions) registerServerActionCallback();
 	installAppNavigationFailureListeners();
+	let devErrorOverlay = null;
 	if (import.meta.env.DEV) {
-		installDevErrorOverlay();
-		installViteHmrErrorHandler(import.meta.hot);
-		reportInitialDevServerErrors();
+		devErrorOverlay = await import("./dev-error-overlay.js");
+		devErrorOverlay.installDevErrorOverlay();
+		devErrorOverlay.installViteHmrErrorHandler(import.meta.hot);
+		devErrorOverlay.reportInitialDevServerErrors();
 	}
 	const rscStream = await readInitialRscStream();
 	if (rscStream === null) return;
-	bootstrapHydration(rscStream);
+	bootstrapHydration(rscStream, devErrorOverlay);
 }
-function bootstrapHydration(rscStream) {
+function bootstrapHydration(rscStream, devErrorOverlay) {
 	const root = decodeAppElementsPromise(createFromReadableStream(rscStream));
 	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
 	historyController.writeBootstrapHistoryMetadata();
 	const onUncaughtError = createOnUncaughtError();
 	const formState = consumeInitialFormState(getVinextBrowserGlobal());
-	const hydrateRootOptions = import.meta.env.DEV ? createVinextHydrateRootOptions({
+	const hydrateRootOptions = import.meta.env.DEV && devErrorOverlay ? createVinextHydrateRootOptions({
 		formState,
-		onCaughtError: createDevOnCaughtError(devOnCaughtError, onUncaughtError),
+		onCaughtError: createDevOnCaughtError(devErrorOverlay.devOnCaughtError, onUncaughtError),
 		onUncaughtError
 	}) : createVinextHydrateRootOptions({
 		formState,
@@ -1141,7 +1036,7 @@ function bootstrapHydration(rscStream) {
 			restorePopstateScrollPosition
 		}, event.state);
 	});
-	if (import.meta.hot) {
+	if (import.meta.env.DEV && import.meta.hot) {
 		const applyRscHmrUpdate = async (updateId) => {
 			if (updateId !== latestRscHmrUpdateId) return;
 			if (document.documentElement.id === "__next_error__") {
@@ -1157,7 +1052,7 @@ function bootstrapHydration(rscStream) {
 			if (!browserNavigationController.hasBrowserRouterState()) return;
 			clearClientNavigationCaches();
 			const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
-			dismissOverlay();
+			devErrorOverlay?.dismissOverlay();
 			const hmrHeaders = createRscRequestHeaders();
 			await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders }))), navigationSnapshot);
 		};

package/dist/server/app-browser-history-controller.d.ts

@@ -45,6 +45,7 @@ type CommitNavigationHistoryOptions = {
   targetHistoryIndex?: number | null;
   stageClientParams: () => void;
 };
+declare function createCanonicalBrowserHistoryHref(href: string): string;
 /**
  * Owns App Router browser-history metadata and traversal bookkeeping behind a
  * typed seam: traversal index allocation/commit, push/replace/traverse/hash-only
@@ -101,4 +102,4 @@ declare class AppBrowserHistoryController {
   restoreHistorySnapshot(options: RestoreHistorySnapshotOptions): boolean;
 }
 //#endregion
-export { AppBrowserHistoryController, RestorableSnapshotCandidate };
+export { AppBrowserHistoryController, RestorableSnapshotCandidate, createCanonicalBrowserHistoryHref };

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

@@ -1,5 +1,9 @@
 import { RestorableClientStateController, createHistoryStateWithNavigationMetadata, readHistoryStateBfcacheIds, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 //#region src/server/app-browser-history-controller.ts
+function createCanonicalBrowserHistoryHref(href) {
+	const url = new URL(href);
+	return `${url.pathname}${url.search}${url.hash}`;
+}
 function stripVinextScrollState(state) {
 	if (!state || typeof state !== "object") return state;
 	const nextState = {};
@@ -166,7 +170,7 @@ var AppBrowserHistoryController = class {
 		this.#replaceHistoryState(createHistoryStateWithNavigationMetadata(this.#readHistoryState(), {
 			previousNextUrl: null,
 			traversalIndex: this.#currentHistoryTraversalIndex
-		}), this.#readCurrentHref());
+		}), createCanonicalBrowserHistoryHref(this.#readCurrentHref()));
 	}
 	/** History write performed on the first committed (hydrated) render. */
 	writeHydratedHistoryMetadata(options) {
@@ -207,4 +211,4 @@ function areBfcacheIdMapsEqual(a, b) {
 	return aEntries.every(([key, value]) => b[key] === value);
 }
 //#endregion
-export { AppBrowserHistoryController };
+export { AppBrowserHistoryController, createCanonicalBrowserHistoryHref };

package/dist/server/app-browser-server-action-client.d.ts

@@ -0,0 +1,32 @@
+import { AppElements, AppWireElements } from "./app-elements-wire.js";
+import { navigationPlanner } from "./navigation-planner.js";
+import { AppBrowserServerActionResult, ServerActionRevalidationKind } from "./app-browser-action-result.js";
+import { AppRouterState } from "./app-browser-state.js";
+
+//#region src/server/app-browser-server-action-client.d.ts
+type ServerActionResult = AppBrowserServerActionResult<AppWireElements>;
+type ClientServerActionInitiation = {
+  href: string;
+  navigationId: number;
+  path: string;
+  routerState: AppRouterState;
+};
+type ActionRedirectTarget = {
+  href: string;
+  type: string;
+  status: number;
+};
+type ClientServerActionDeps = {
+  basePath: string;
+  clearClientNavigationCaches(): void;
+  clientRscCompatibilityId: string | null;
+  commitSameUrlNavigatePayload(elements: Promise<AppElements>, actionInitiation: ClientServerActionInitiation, returnValue: ServerActionResult["returnValue"] | undefined, revalidation: ServerActionRevalidationKind): Promise<unknown>;
+  navigationPlanner: typeof navigationPlanner;
+  performHardNavigation(url: string, historyMode?: "assign" | "replace"): void;
+  renderRedirectPayload(elements: AppElements, target: ActionRedirectTarget, actionInitiation: ClientServerActionInitiation): void;
+  syncCurrentHistoryState(previousNextUrl: string | null, bfcacheIds: Readonly<Record<string, string>>): void;
+  syncServerActionHttpFallbackHead(status: number | null): void;
+};
+declare function invokeClientServerAction(id: string, args: unknown[], actionInitiation: ClientServerActionInitiation, deps: ClientServerActionDeps): Promise<unknown>;
+//#endregion
+export { ClientServerActionDeps, ClientServerActionInitiation, invokeClientServerAction };