vinext 0.1.6 → 0.1.8

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 };

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

@@ -0,0 +1,128 @@
+import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER } from "./headers.js";
+import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
+import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { resolveServerActionRequestState } from "./app-browser-state.js";
+import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
+import { throwOnServerActionNotFound } from "./server-action-not-found.js";
+import { createFromFetch, createTemporaryReferenceSet, encodeReply } from "@vitejs/plugin-rsc/browser";
+//#region src/server/app-browser-server-action-client.ts
+function resolveActionRedirectTarget(response, performHardNavigation) {
+	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 += "/";
+			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
+		}
+		if (redirectUrl.origin !== window.location.origin) {
+			performHardNavigation(actionRedirect);
+			return null;
+		}
+		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
+		return {
+			href: redirectUrl.href,
+			type: response.headers.get("x-action-redirect-type") ?? "push",
+			status: statusHeader ? parseInt(statusHeader, 10) : 307
+		};
+	} catch {
+		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};`;
+	}
+};
+async function invokeClientServerAction(id, args, actionInitiation, deps) {
+	deps.syncServerActionHttpFallbackHead(null);
+	const temporaryReferences = createTemporaryReferenceSet();
+	deps.syncCurrentHistoryState(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
+	const body = await encodeReply(args, { temporaryReferences });
+	const headers = resolveServerActionRequestState({
+		actionId: id,
+		basePath: deps.basePath,
+		elements: actionInitiation.routerState.elements,
+		previousNextUrl: actionInitiation.routerState.previousNextUrl
+	}).headers;
+	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, (url, historyMode) => deps.performHardNavigation(url, historyMode));
+	if (hasActionRedirect && !actionRedirectTarget) return void 0;
+	const actionResultFacts = createServerActionResultFacts({
+		actionRedirectHref: actionRedirectTarget?.href ?? null,
+		actionRedirectType: actionRedirectTarget?.type ?? null,
+		clientCompatibilityId: deps.clientRscCompatibilityId,
+		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(deps.navigationPlanner.classifyServerActionResult(actionResultFacts), () => deps.clearClientNavigationCaches(), (url, historyMode) => deps.performHardNavigation(url, historyMode))) return;
+	const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
+	if (revalidation !== "none") deps.clearClientNavigationCaches();
+	const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
+	if (invalidResponseError) throw invalidResponseError;
+	if (actionRedirectTarget && !fetchResponseIsRsc) {
+		deps.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)) deps.clearClientNavigationCaches();
+	if (actionRedirectTarget) {
+		if (isServerActionResult(result) && result.root !== void 0) {
+			deps.renderRedirectPayload(AppElementsWire.decode(result.root), actionRedirectTarget, actionInitiation);
+			throw new ServerActionRedirectError(actionRedirectTarget);
+		}
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const hasSameUrlRerenderPayload = isServerActionResult(result) && result.root !== void 0;
+	deps.syncServerActionHttpFallbackHead(hasSameUrlRerenderPayload ? 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 deps.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 deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
+}
+//#endregion
+export { invokeClientServerAction };

package/dist/server/app-fallback-renderer.d.ts

@@ -4,6 +4,7 @@ import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppPageBoundaryRoute } from "./app-page-boundary-render.js";
 import { ReactNode } from "react";
@@ -27,6 +28,7 @@ type AppFallbackRendererFontProviders = {
   getFontStyles: () => string[];
 };
 type AppFallbackRendererOptions<TModule extends AppPageModule = AppPageModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (request: Request, pathname: string, routePath: string) => AppPageBoundaryOnError;
   fontProviders: AppFallbackRendererFontProviders;
@@ -73,7 +75,7 @@ type AppFallbackRendererCallContext = {
   sourcePageSegments?: readonly string[] | null;
 };
 type AppFallbackRenderer<TModule extends AppPageModule = AppPageModule> = {
-  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext) => Promise<Response | null>;
+  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallback: (route: AppPageBoundaryRoute<TModule> | null, statusCode: number, isRscRequest: boolean, request: Request, opts: {
     boundaryComponent?: AppPageComponent | null;
     boundaryModule?: TModule | null;

package/dist/server/app-fallback-renderer.js

@@ -7,7 +7,7 @@ const EMPTY_MW_CTX = {
 	status: null
 };
 function createAppFallbackRenderer(options) {
-	const { basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
+	const { applyFileBasedMetadata, basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
 	const { rootForbiddenModule, rootLayouts, rootNotFoundModule, rootUnauthorizedModule } = rootBoundaries;
 	const effectiveGlobalErrorModule = globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE;
 	const effectiveRootNotFoundModule = rootNotFoundModule ?? DEFAULT_NOT_FOUND_MODULE;
@@ -23,6 +23,7 @@ function createAppFallbackRenderer(options) {
 				const globalNotFoundModule = await resolveGlobalNotFoundModule();
 				const globalNotFoundComponent = globalNotFoundModule?.default ?? null;
 				if (globalNotFoundComponent) return renderAppPageHttpAccessFallback({
+					applyFileBasedMetadata,
 					boundaryComponent: globalNotFoundComponent,
 					boundaryModule: globalNotFoundModule ?? null,
 					buildFontLinkHeader: fontProviders.buildFontLinkHeader,
@@ -57,6 +58,7 @@ function createAppFallbackRenderer(options) {
 				});
 			}
 			return renderAppPageHttpAccessFallback({
+				applyFileBasedMetadata,
 				basePath,
 				trailingSlash,
 				boundaryComponent: opts?.boundaryComponent ?? null,
@@ -95,8 +97,9 @@ function createAppFallbackRenderer(options) {
 		renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
 			return this.renderHttpAccessFallback(route, 404, isRscRequest, request, { matchedParams }, scriptNonce, middlewareContext, callContext);
 		},
-		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
+		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext, errorOrigin = "rsc") {
 			return renderAppPageErrorBoundary({
+				applyFileBasedMetadata,
 				basePath,
 				trailingSlash,
 				buildFontLinkHeader: fontProviders.buildFontLinkHeader,
@@ -105,6 +108,7 @@ function createAppFallbackRenderer(options) {
 					return buildRscOnErrorHandler(request, pathname, routePath);
 				},
 				error,
+				errorOrigin,
 				getFontLinks: fontProviders.getFontLinks,
 				getFontPreloads: fontProviders.getFontPreloads,
 				getFontStyles: fontProviders.getFontStyles,

package/dist/server/app-history-state.d.ts

@@ -63,7 +63,6 @@ declare function createHistoryStateWithNavigationMetadata(state: unknown, metada
 }): HistoryStateRecord | null;
 declare function createExternalHistoryStatePreservingMetadata(callerState: unknown, currentHistoryState: unknown): unknown;
 declare function readHistoryStatePreviousNextUrl(state: unknown): string | null;
-declare function isBfcacheSegmentId(id: string): boolean;
 declare function readHistoryStateBfcacheIds(state: unknown): BfcacheIdMap | null;
 declare function readHistoryStateBfcacheVersion(state: unknown): number | null;
 /**
@@ -83,4 +82,4 @@ declare function resolveHistoryTraversalIntent(options: {
   historyState: unknown;
 }): HistoryTraversalIntent;
 //#endregion
-export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { BfcacheIdMap, HistoryStateSnapshotCache, HistoryTraversalIntent, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

package/dist/server/app-history-state.js

@@ -220,4 +220,4 @@ function resolveHistoryTraversalIntent(options) {
 	};
 }
 //#endregion
-export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };
+export { HistoryStateSnapshotCache, RestorableClientStateController, createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent };

package/dist/server/app-page-boundary-render.d.ts

@@ -4,6 +4,7 @@ import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { ComponentType, ReactNode } from "react";
 
@@ -27,6 +28,7 @@ type AppPageBoundaryRoute<TModule extends AppPageModule = AppPageModule> = {
   unauthorized?: TModule | null;
 };
 type AppPageBoundaryRenderCommonOptions<TModule extends AppPageModule = AppPageModule> = {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
   buildFontLinkHeader: (preloads: readonly AppPageFontPreload[] | null | undefined) => string;
   clearRequestContext: () => void;
   createRscOnErrorHandler: (pathname: string, routePath: string) => AppPageBoundaryOnError;
@@ -73,6 +75,7 @@ type RenderAppPageHttpAccessFallbackOptions<TModule extends AppPageModule = AppP
 } & AppPageBoundaryRenderCommonOptions<TModule>;
 type RenderAppPageErrorBoundaryOptions<TModule extends AppPageModule = AppPageModule> = {
   error: unknown;
+  errorOrigin?: "rsc" | "ssr";
   matchedParams?: AppPageParams | null;
   route?: AppPageBoundaryRoute<TModule> | null;
   sanitizeErrorForClient: (error: Error) => Error;