vinext 0.1.6 → 0.1.8

package/dist/server/app-page-route-wiring.d.ts

@@ -2,9 +2,9 @@ import { AppRouteSemanticIds } from "../routing/app-route-graph.js";
 import { AppElements, AppElementsInterception } from "./app-elements-wire.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
+import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppPageRenderIdentity } from "./app-page-render-identity.js";
 import { resolveAppPageChildSegments } from "./app-page-segment-state.js";
 import { ComponentType, ReactNode } from "react";
@@ -31,6 +31,8 @@ type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule, TErro
   /** Graph-owned semantic slot identity. */id?: string | null; /** Slot prop name passed to the owning layout (e.g. "modal" from @modal). */
   name: string;
   default?: TModule | null;
+  configLayouts?: readonly (TModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   error?: TErrorModule | null;
   layout?: TModule | null;
   layoutIndex: number;
@@ -83,6 +85,8 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   templates?: readonly (TModule | null | undefined)[] | null;
 };
 type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> = {
+  branchSegments?: readonly string[] | null;
+  layoutSegments?: readonly (readonly string[])[] | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
   /**
    * The page module to render for this slot. Optional — when omitted, the
@@ -118,6 +122,7 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
   route: AppPageRouteWiringRoute<TModule, TErrorModule>;
+  createPageElement?: (component: AppPageComponent, props: Readonly<Record<string, unknown>>) => ReactNode;
   searchParams?: unknown;
   slotOverrides?: Readonly<Record<string, AppPageSlotOverride<TModule>>> | null;
 };

package/dist/server/app-page-route-wiring.js

@@ -8,7 +8,7 @@ import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
 import { Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
-import { resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { probeReactServerSubtree } from "./app-page-probe.js";
 import { resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
 import { Fragment, Suspense } from "react";
@@ -16,6 +16,9 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
 const APP_PAGE_LAYOUT_PROBE_CHILD = /* @__PURE__ */ jsx(Fragment, {});
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
+function resolveSlotLayoutParams(routeSegments, treePosition, params) {
+	return resolveAppPageBranchParams(routeSegments, treePosition, params);
+}
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -293,7 +296,9 @@ function buildAppPageElements(options) {
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotOverride = resolveSlotOverride(slotKey, slotName);
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
-		const slotResetKey = resolveAppPageRouteStateKey(slot.routeSegments ?? [], slotParams);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		const slotOwnerParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntries[targetIndex]?.treePosition ?? 0, options.matchedParams);
+		const slotResetKey = resolveAppPageRouteStateKey(slotRouteSegments, slotParams);
 		const overrideOrPageComponent = getDefaultExport(slotOverride?.pageModule) ?? getDefaultExport(slot.page);
 		const defaultComponent = getDefaultExport(slot.default);
 		if (!overrideOrPageComponent && defaultComponent && options.isRscRequest && options.mountedSlotIds?.has(slotId)) continue;
@@ -302,23 +307,40 @@ function buildAppPageElements(options) {
 			elements[slotId] = AppElementsWire.unmatchedSlotValue;
 			continue;
 		}
-		const slotThenableParams = options.makeThenableParams(slotParams);
-		const slotProps = { params: slotThenableParams };
+		const slotProps = { params: options.makeThenableParams(slotParams) };
 		if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
 		if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
-		let slotElement = /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		let slotElement = options.createPageElement ? options.createPageElement(slotComponent, slotProps) : (() => {
+			return /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		})();
+		const hasSlotTreeOverride = slotOverride?.pageModule != null || slotOverride?.layoutModules !== void 0;
 		const interceptLayouts = slotOverride?.layoutModules ?? [];
 		for (let layoutIndex = interceptLayouts.length - 1; layoutIndex >= 0; layoutIndex--) {
 			const interceptLayoutComponent = getDefaultExport(interceptLayouts[layoutIndex]);
 			if (!interceptLayoutComponent) continue;
-			slotElement = /* @__PURE__ */ jsx(interceptLayoutComponent, {
-				params: slotThenableParams,
+			const InterceptLayoutComponent = interceptLayoutComponent;
+			const interceptLayoutParams = resolveSlotLayoutParams(slotOverride?.branchSegments ?? slotRouteSegments, slotOverride?.layoutSegments?.[layoutIndex]?.length ?? slotRouteSegments.length, slotParams);
+			slotElement = /* @__PURE__ */ jsx(InterceptLayoutComponent, {
+				params: options.makeThenableParams(interceptLayoutParams),
+				children: slotElement
+			});
+		}
+		if (!hasSlotTreeOverride) for (let layoutIndex = (slot.configLayouts?.length ?? 0) - 1; layoutIndex >= 0; layoutIndex--) {
+			const nestedLayoutComponent = getDefaultExport(slot.configLayouts?.[layoutIndex]);
+			if (!nestedLayoutComponent) continue;
+			const NestedLayoutComponent = nestedLayoutComponent;
+			const nestedLayoutParams = resolveSlotLayoutParams(slotRouteSegments, slot.configLayoutTreePositions?.[layoutIndex] ?? 0, slotParams);
+			slotElement = /* @__PURE__ */ jsx(NestedLayoutComponent, {
+				params: options.makeThenableParams({
+					...slotOwnerParams,
+					...nestedLayoutParams
+				}),
 				children: slotElement
 			});
 		}
 		const slotLayoutComponent = getDefaultExport(slot.layout);
 		if (slotLayoutComponent) slotElement = /* @__PURE__ */ jsx(slotLayoutComponent, {
-			params: slotThenableParams,
+			params: options.makeThenableParams(slotOwnerParams),
 			children: slotElement
 		});
 		const slotLoadingComponent = getDefaultExport(slot.loading);

package/dist/server/app-page-search-params-observation.d.ts

@@ -1,10 +1,12 @@
-import { ThenableParams } from "../shims/thenable-params.js";
+import { ThenableParams, ThenableParamsObserver } from "../shims/thenable-params.js";
 import { AppPageSearchParams } from "./app-page-head.js";
 
 //#region src/server/app-page-search-params-observation.d.ts
 type AppPageSearchParamsObservationOptions = {
+  markDynamic?: boolean;
   observeReactPromiseStatus?: boolean;
 };
+declare function createAppPageSearchParamsObserver(options?: AppPageSearchParamsObservationOptions): ThenableParamsObserver;
 declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams, options?: AppPageSearchParamsObservationOptions): ThenableParams<AppPageSearchParams>;
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-search-params-observation.js

@@ -1,15 +1,19 @@
-import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } from "../shims/headers.js";
+import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "../shims/headers.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 //#region src/server/app-page-search-params-observation.ts
-function markAppPageSearchParamsAccess() {
+function markAppPageSearchParamsAccess(markDynamic) {
+	throwIfStaticGenerationAccessError();
 	throwIfInsideCacheScope("searchParams");
-	markDynamicUsage();
+	if (markDynamic) markDynamicUsage();
 	markRenderRequestApiUsage("searchParams");
 }
-function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
-	const observer = { observeParamAccess() {
-		markAppPageSearchParamsAccess();
+function createAppPageSearchParamsObserver(options = {}) {
+	return { observeParamAccess() {
+		markAppPageSearchParamsAccess(options.markDynamic !== false);
 	} };
+}
+function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
+	const observer = createAppPageSearchParamsObserver(options);
 	if (options.observeReactPromiseStatus === true) return makeThenableParams(pageSearchParams, {
 		...observer,
 		observeReactPromiseStatus: true
@@ -17,4 +21,4 @@ function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {})
 	return makeThenableParams(pageSearchParams, observer);
 }
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-stream.js

@@ -1,3 +1,4 @@
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
@@ -131,7 +132,7 @@ function createAppPageRscErrorTracker(baseOnError) {
 			return capturedSpecialError;
 		},
 		onRenderError(error, requestInfo, errorContext) {
-			if (error && typeof error === "object" && "digest" in error) {
+			if (isNavigationSignalError(error)) {
 				if (capturedSpecialError === null) capturedSpecialError = error;
 			} else capturedError = error;
 			return baseOnError(error, requestInfo, errorContext);

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -4,7 +4,7 @@ import { ReactNode } from "react";
 //#region src/server/app-ppr-fallback-shell-render.d.ts
 type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
-declare function warmPprFallbackShellCaches(options: {
+type WarmPprFallbackShellCachesOptions = {
   element: AppPageRenderableElement;
   onError: AppPageBoundaryOnError;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
@@ -12,6 +12,7 @@ declare function warmPprFallbackShellCaches(options: {
     signal?: AbortSignal;
   }) => ReadableStream<Uint8Array>;
   state: PprFallbackShellState;
-}): Promise<void>;
+};
+declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
 //#endregion
-export { warmPprFallbackShellCaches };
+export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };

package/dist/server/app-route-handler-cache.js

@@ -1,6 +1,6 @@
 import { makeThenableParams } from "../shims/thenable-params.js";
-import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { applyRouteHandlerMiddlewareContext, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, buildRouteHandlerCachedResponse } from "./app-route-handler-response.js";
+import { markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { runAppRouteHandler } from "./app-route-handler-execution.js";
 //#region src/server/app-route-handler-cache.ts
 const EMPTY_PARAMS = Object.freeze({});

package/dist/server/app-route-handler-dispatch.js

@@ -7,10 +7,10 @@ import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import "../shims/navigation.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
-import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
-import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
+import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
@@ -24,6 +24,7 @@ function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	await runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
+			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

package/dist/server/app-route-handler-execution.js

@@ -1,12 +1,14 @@
-import { setHeadersContext } from "../shims/headers.js";
-import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
-import { isPossibleAppRouteActionRequest, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
+import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
+import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
 //#region src/server/app-route-handler-execution.ts
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
 		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeEnabled: options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret),
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

package/dist/server/app-route-handler-policy.d.ts

@@ -1,3 +1,4 @@
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-runtime.js";
 
 //#region src/server/app-route-handler-policy.d.ts
@@ -43,7 +44,6 @@ type AppRouteHandlerSpecialError = {
 type AppRouteHandlerSpecialErrorOptions = {
   isAction: boolean;
 };
-declare function isPossibleAppRouteActionRequest(request: Pick<Request, "headers" | "method">): boolean;
 declare function getAppRouteHandlerRevalidateSeconds(handler: Pick<AppRouteHandlerModule, "revalidate">): number | null;
 declare function hasAppRouteHandlerDefaultExport(handler: RouteHandlerModule): boolean;
 declare function resolveAppRouteHandlerMethod(handler: AppRouteHandlerModule, method: string): ResolvedAppRouteHandlerMethod;

package/dist/server/app-route-handler-policy.js

@@ -1,12 +1,7 @@
-import "./headers.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { buildRouteHandlerAllowHeader, collectRouteHandlerMethods } from "./app-route-handler-runtime.js";
 //#region src/server/app-route-handler-policy.ts
-function isPossibleAppRouteActionRequest(request) {
-	if (request.method.toUpperCase() !== "POST") return false;
-	const contentType = request.headers.get("content-type");
-	return request.headers.has("x-rsc-action") || request.headers.has("next-action") || contentType === "application/x-www-form-urlencoded" || contentType?.startsWith("multipart/form-data") === true;
-}
 function getAppRouteHandlerRevalidateSeconds(handler) {
 	const { revalidate } = handler;
 	if (revalidate === false) return Infinity;

package/dist/server/app-route-module-loader.d.ts

@@ -36,11 +36,13 @@ type LazyLoadableSlot = {
   page?: unknown;
   default?: unknown;
   layout?: unknown;
+  configLayouts?: readonly unknown[];
   loading?: unknown;
   error?: unknown;
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
+  __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];

package/dist/server/app-route-module-loader.js

@@ -61,6 +61,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
 		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
+		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 	}

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

@@ -5,7 +5,7 @@ import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } fro
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
-import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
@@ -24,7 +24,7 @@ async function handleRequest(request, env, ctx) {
 	} catch {
 		return badRequestResponse();
 	}
-	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
+	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
 		const filteredHeaders = filterInternalHeaders(request.headers);
@@ -35,14 +35,15 @@ async function handleRequest(request, env, ctx) {
 	const handleFn = () => rscHandler(request, ctx);
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
+		let response = result;
 		if (env?.ASSETS) {
 			const assetFetcher = env.ASSETS;
-			const assetResponse = await resolveStaticAssetSignal(result, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
-			if (assetResponse) return assetResponse;
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
+			if (assetResponse) response = assetResponse;
 		}
-		return result;
+		return finalizeMissingStaticAssetResponse(response, missingBuildAsset);
 	}
-	if (result === null || result === void 0) return notFoundResponse();
+	if (result === null || result === void 0) return missingBuildAsset ? notFoundStaticAssetResponse() : notFoundResponse();
 	return new Response(String(result), { status: 200 });
 }
 //#endregion

package/dist/server/app-rsc-errors.d.ts

@@ -19,6 +19,17 @@ type CreateRscOnErrorHandlerOptions = {
 declare function hasDigest(error: unknown): error is {
   digest: unknown;
 };
+/**
+ * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
+ * string only when the error is a genuine control-flow signal — a redirect,
+ * notFound/HTTP-access fallback, bail-out-to-client-side-rendering, or
+ * dynamic-server-usage throw. Any other digest (e.g. a hashed digest stamped on
+ * a real error, or an obfuscated digest transported from a nested boundary)
+ * returns undefined so the caller still reports it as a real error. Mere
+ * presence of a `digest` field is NOT enough — that conflation swallowed a class
+ * of server render errors with no instrumentation/telemetry.
+ */
+declare function getDigestForWellKnownError(error: unknown): string | undefined;
 /**
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
@@ -26,4 +37,4 @@ declare function errorDigest(input: string): string;
 declare function sanitizeErrorForClient(error: unknown, nodeEnv?: string | undefined): unknown;
 declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
 //#endregion
-export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

package/dist/server/app-rsc-errors.js

@@ -1,8 +1,26 @@
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
 //#region src/server/app-rsc-errors.ts
 function hasDigest(error) {
 	return Boolean(error && typeof error === "object" && "digest" in error);
 }
+const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+/**
+* vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
+* string only when the error is a genuine control-flow signal — a redirect,
+* notFound/HTTP-access fallback, bail-out-to-client-side-rendering, or
+* dynamic-server-usage throw. Any other digest (e.g. a hashed digest stamped on
+* a real error, or an obfuscated digest transported from a nested boundary)
+* returns undefined so the caller still reports it as a real error. Mere
+* presence of a `digest` field is NOT enough — that conflation swallowed a class
+* of server render errors with no instrumentation/telemetry.
+*/
+function getDigestForWellKnownError(error) {
+	if (!hasDigest(error)) return;
+	const digest = String(error.digest);
+	if (isNavigationSignalError(error) || digest === BAILOUT_TO_CSR_DIGEST || digest === DYNAMIC_SERVER_USAGE_DIGEST) return digest;
+}
 function getThrownValueMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -27,14 +45,22 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 function createRscOnErrorHandler(options) {
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
-		if (hasDigest(error)) return String(error.digest);
+		const wellKnownDigest = getDigestForWellKnownError(error);
+		if (wellKnownDigest !== void 0) return wellKnownDigest;
 		if (nodeEnv !== "production" && error instanceof Error && error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")) {
 			console.error("[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\n\nCommon causes:\n  * Passing a module namespace (import * as X) directly as a prop.\n    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\n    which are not serializable. Fix: pass individual values instead,\n    e.g. <Comp value={module.value} />\n  * Passing a class instance (new Foo()) as a prop.\n    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\n  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\n  * Passing Object.create(null). Use { ...obj } to restore a prototype.\n\nOriginal error:", error.message);
 			return;
 		}
 		if (options.requestInfo && options.errorContext && error) options.reportRequestError(error instanceof Error ? error : new Error(getThrownValueMessage(error)), options.requestInfo, options.errorContext);
-		if (nodeEnv === "production" && error) return errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+		if (hasDigest(error)) return String(error.digest);
+		if (error) {
+			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+			if (error instanceof Error) try {
+				Object.assign(error, { digest });
+			} catch {}
+			return digest;
+		}
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, hasDigest, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

package/dist/server/app-rsc-handler.d.ts

@@ -2,21 +2,26 @@ import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config
 import { ImageConfig } from "./image-optimization.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
-import { MiddlewareModule } from "./middleware-runtime.js";
-import { AppMiddlewareContext } from "./app-middleware.js";
+import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
-import { MetadataRouteMakeThenableParams, MetadataRuntimeRoute } from "./metadata-route-response.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-rsc-handler.d.ts
 type AppPageParams = Record<string, string | string[]>;
-type MetadataRoutes = readonly MetadataRuntimeRoute[];
-type MakeThenableParams = MetadataRouteMakeThenableParams;
 type StaticParamsMap = AppPrerenderStaticParamsMap;
 type RootParamNamesMap = AppPrerenderRootParamNamesMap;
 type AppRscMiddlewareContext = AppMiddlewareContext;
+type RunAppMiddlewareOptions = {
+  cleanPathname: string;
+  context: AppRscMiddlewareContext;
+  isDataRequest: boolean;
+  request: Request;
+};
 type AppRscHandlerRoute = {
+  __loadPage?: unknown;
+  __loadRouteHandler?: unknown;
   isDynamic: boolean;
   params?: readonly string[];
   page?: unknown;
@@ -147,7 +152,6 @@ type NavigationContextValue = {
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
   buildId: string | null;
-  cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -173,18 +177,16 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * Node server and dev included, not just the Cloudflare worker entry.
    */
   registerCacheAdapters: (env?: Record<string, unknown>) => void;
-  handleProgressiveActionRequest: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
-  handleServerActionRequest: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
+  handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
+  handleMetadataRouteRequest?: (cleanPathname: string) => Promise<Response | null>;
+  createPprFallbackShells?: (route: Pick<AppRscHandlerRoute, "params" | "pattern" | "rootParamNames">, params: AppPageParams) => AppPagePprFallbackCacheShell[];
+  handleServerActionRequest?: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
   imageConfig?: ImageConfig;
   isDev: boolean;
-  isMiddlewareProxy: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
-  makeThenableParams: MakeThenableParams;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
-  metadataRoutes: MetadataRoutes;
-  middlewareFilePath: string | null;
-  middlewareModule: MiddlewareModule | null;
+  runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;

package/dist/server/app-rsc-handler.js

@@ -19,6 +19,7 @@ import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, seri
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
+import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
@@ -47,6 +48,11 @@ function isExecutionContextLike(value) {
 	if (!value || typeof value !== "object") return false;
 	return hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
 }
+function createMissingServerActionResponse(options, actionId) {
+	console.warn(getServerActionNotFoundMessage(actionId));
+	options.clearRequestContext();
+	return createServerActionNotFoundResponse();
+}
 function redirectDestinationWithBasePath(destination, basePath) {
 	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
@@ -165,19 +171,12 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		status: null
 	};
 	let didMiddlewareRewrite = false;
-	if (options.middlewareModule) {
-		const { applyAppMiddleware } = await import("./app-middleware.js");
-		const middlewareResult = await applyAppMiddleware({
-			basePath: options.basePath,
+	if (options.runMiddleware) {
+		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			filePath: options.middlewareFilePath ?? void 0,
-			i18nConfig: options.i18nConfig,
 			isDataRequest,
-			isProxy: options.isMiddlewareProxy,
-			module: options.middlewareModule,
-			request: userlandRequest,
-			trailingSlash: options.trailingSlash
+			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
 			basePathState,
@@ -211,13 +210,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	if (options.metadataRoutes.length > 0) {
-		const { handleMetadataRouteRequest } = await import("./metadata-route-response.js");
-		const metadataRouteResponse = await handleMetadataRouteRequest({
-			metadataRoutes: options.metadataRoutes,
-			cleanPathname,
-			makeThenableParams: options.makeThenableParams
-		});
+	if (options.handleMetadataRouteRequest) {
+		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
 		if (metadataRouteResponse) {
 			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
 				basePathState,
@@ -255,13 +249,16 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const contentType = request.headers.get("content-type") || "";
 	const isPostRequest = request.method.toUpperCase() === "POST";
 	let progressiveActionResult = null;
-	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) progressiveActionResult = await options.handleProgressiveActionRequest({
-		actionId,
-		cleanPathname,
-		contentType,
-		middlewareContext,
-		request
-	});
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
+			actionId,
+			cleanPathname,
+			contentType,
+			middlewareContext,
+			request
+		});
+		else if (preActionMatch?.route.__loadPage && !preActionMatch.route.__loadRouteHandler) return createMissingServerActionResponse(options, null);
+	}
 	if (progressiveActionResult instanceof Response) return progressiveActionResult;
 	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
 	const isProgressiveActionRender = progressiveActionFormState !== null;
@@ -269,7 +266,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = isPostRequest && actionId ? await options.handleServerActionRequest({
+	const serverActionResponse = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -281,6 +278,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
+	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
 		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
@@ -394,14 +392,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const renderParams = prerenderRouteParams ?? params;
 	const resolvedSearchParams = getResolvedSearchParams();
 	let runtimeFallbackShells = [];
-	if (options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) {
-		const { createAppPprFallbackShells } = await import("./app-ppr-fallback-shell.js");
-		runtimeFallbackShells = createAppPprFallbackShells({
-			params: route.params,
-			pattern: route.pattern,
-			rootParamNames: route.rootParamNames
-		}, params);
-	}
+	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
+		params: route.params,
+		pattern: route.pattern,
+		rootParamNames: route.rootParamNames
+	}, params);
 	options.setNavigationContext({
 		pathname: canonicalPathname,
 		searchParams: resolvedSearchParams,

package/dist/server/app-rsc-response-finalizer.js

@@ -22,7 +22,11 @@ import { mergeVaryHeader } from "./middleware-response-headers.js";
 */
 function finalizeAppRscResponse(response, request, options) {
 	if (response.status >= 300 && response.status < 400) return response;
-	if (!response.headers.has("x-vinext-static-file")) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	if (!response.headers.has("x-vinext-static-file")) {
+		const varyHeader = response.headers.get("Vary");
+		if (varyHeader === null) response.headers.set("Vary", VINEXT_RSC_VARY_HEADER);
+		else if (varyHeader !== VINEXT_RSC_VARY_HEADER) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
+	}
 	if (!response.headers.has("Cache-Control")) applyCdnResponseHeaders(response.headers, { cacheControl: "" });
 	if (!options.configHeaders.length) return response;
 	const url = new URL(request.url);