vinext 0.1.4 → 0.1.5

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

@@ -1,35 +1,16 @@
 import { VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { decideIsr } from "./isr-decision.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
-import { readStreamAsText } from "../utils/text-stream.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
-import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 import { isAppPprDynamicFallbackShellHtml } from "./app-ppr-fallback-shell.js";
+import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite } from "./app-page-cache-finalizer.js";
 //#region src/server/app-page-cache.ts
-/**
-* Apply the CDN cache adapter's headers to a freshly-streamed response whose
-* dynamic-ness is not yet proven.
-*
-* The cacheable `Cache-Control` value computed by the response policy is already
-* present on `headers`; the default adapter replaces it with `no-store` (so the
-* page is served from the origin store on later requests), while an edge adapter
-* may instead emit `CDN-Cache-Control`/`Cache-Tag` so the CDN performs SWR and
-* can be purged by tag. `tags` are the page's render tags (canonicalised).
-*/
-function applyPendingDynamicCdnHeaders(headers, tags) {
-	applyCdnResponseHeaders(headers, {
-		cacheControl: headers.get("Cache-Control") ?? "",
-		pendingDynamicCheck: true,
-		tags
-	});
-	setCacheStateHeaders(headers, "MISS");
-}
 function recordAppPageCacheOutcome(recordCacheOutcome, input) {
 	try {
 		recordCacheOutcome?.(input);
@@ -72,18 +53,6 @@ function getCachedAppPageValue(entry) {
 function hasQueryInvariantAppPageProof(cachedValue) {
 	return cachedValue.renderObservation !== void 0 && hasCompleteNegativeRequestApiProof(cachedValue.renderObservation, ["searchParams"]);
 }
-function resolveAppPageCacheWritePolicy(options) {
-	let revalidateSeconds = options.revalidateSeconds;
-	let expireSeconds = options.expireSeconds;
-	const requestCacheLife = options.requestCacheLife;
-	if (requestCacheLife?.revalidate !== void 0) revalidateSeconds = revalidateSeconds === null ? requestCacheLife.revalidate : Math.min(revalidateSeconds, requestCacheLife.revalidate);
-	if (requestCacheLife?.expire !== void 0) expireSeconds = requestCacheLife.expire;
-	if (revalidateSeconds === null || Number.isNaN(revalidateSeconds) || revalidateSeconds <= 0) return null;
-	return {
-		expireSeconds,
-		revalidateSeconds
-	};
-}
 function buildAppPageCachedResponse(cachedValue, options) {
 	const status = options.middlewareStatus ?? (cachedValue.status || 200);
 	const { cacheControl } = decideIsr({
@@ -203,13 +172,12 @@ async function readAppPageCacheResponse(options) {
 			options.isrDebug?.("MISS (empty cached entry)", options.cleanPathname);
 		}
 		if (cached?.isStale && cachedValue) {
-			const regenerationKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext) : options.isrHtmlKey(options.cleanPathname);
-			options.scheduleBackgroundRegeneration(regenerationKey, async () => {
+			options.scheduleBackgroundRegeneration(isrKey, async () => {
 				const revalidatedPage = await options.renderFreshPageForCache();
 				const revalidateSeconds = revalidatedPage.cacheControl?.revalidate ?? options.revalidateSeconds;
 				const expireSeconds = revalidatedPage.cacheControl?.expire ?? options.expireSeconds;
-				const writes = [options.isrSet(options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds)];
-				if (!options.isRscRequest) writes.push(options.isrSet(options.isrHtmlKey(options.cleanPathname), buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds));
+				const writes = [options.isrSet(options.isRscRequest ? isrKey : options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds)];
+				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds));
 				await Promise.all(writes);
 				options.isrDebug?.("regen complete", options.cleanPathname);
 			});
@@ -300,99 +268,5 @@ async function readAppPageFallbackShellCacheResponse(options) {
 		return null;
 	}
 }
-function finalizeAppPageHtmlCacheResponse(response, options) {
-	if (!response.body) return response;
-	const [streamForClient, streamForCache] = response.body.tee();
-	const htmlKey = options.isrHtmlKey(options.cleanPathname);
-	const rscKey = options.isrRscKey(options.cleanPathname, null, void 0, options.interceptionContext);
-	const clientHeaders = new Headers(response.headers);
-	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
-	const cachePromise = (async () => {
-		try {
-			const cachedHtml = await readStreamAsText(streamForCache);
-			if (options.capturedDynamicUsageBeforeContextCleanup?.() === true || options.consumeDynamicUsage()) {
-				options.isrDebug?.("HTML cache write skipped (dynamic usage during render)", htmlKey);
-				return;
-			}
-			const cachePolicy = resolveAppPageCacheWritePolicy({
-				expireSeconds: options.expireSeconds,
-				requestCacheLife: options.getRequestCacheLife?.(),
-				revalidateSeconds: options.revalidateSeconds
-			});
-			if (!cachePolicy) {
-				options.isrDebug?.("HTML cache write skipped (no cache policy)", htmlKey);
-				return;
-			}
-			const pageTags = options.getPageTags();
-			const observationState = options.consumeRenderObservationState?.() ?? createEmptyAppPageRenderObservationState();
-			const htmlRenderObservation = options.createHtmlRenderObservation?.({
-				cacheTags: pageTags,
-				state: observationState
-			});
-			const rscRenderObservation = options.createRscRenderObservation?.({
-				cacheTags: pageTags,
-				state: observationState
-			});
-			const writes = [options.isrSet(htmlKey, buildAppPageCacheValue(cachedHtml, void 0, 200, htmlRenderObservation), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds)];
-			if (options.capturedRscDataPromise) writes.push(options.capturedRscDataPromise.then((rscData) => options.isrSet(rscKey, buildAppPageCacheValue("", rscData, 200, rscRenderObservation), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds)));
-			await Promise.all(writes);
-			options.isrDebug?.("HTML cache written", htmlKey);
-		} catch (cacheError) {
-			console.error("[vinext] ISR cache write error:", cacheError);
-		}
-	})();
-	options.waitUntil?.(cachePromise);
-	return new Response(streamForClient, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: clientHeaders
-	});
-}
-function finalizeAppPageRscCacheResponse(response, options) {
-	if (!scheduleAppPageRscCacheWrite(options)) return response;
-	if (options.preserveClientResponseHeaders === true) return response;
-	const clientHeaders = new Headers(response.headers);
-	applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: clientHeaders
-	});
-}
-function scheduleAppPageRscCacheWrite(options) {
-	const capturedRscDataPromise = options.capturedRscDataPromise;
-	if (!capturedRscDataPromise || options.dynamicUsedDuringBuild) return false;
-	const rscKey = options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext);
-	const cachePromise = (async () => {
-		try {
-			const rscData = await capturedRscDataPromise;
-			if (options.consumeDynamicUsage()) {
-				options.isrDebug?.("RSC cache write skipped (dynamic usage during render)", rscKey);
-				return;
-			}
-			const cachePolicy = resolveAppPageCacheWritePolicy({
-				expireSeconds: options.expireSeconds,
-				requestCacheLife: options.getRequestCacheLife?.(),
-				revalidateSeconds: options.revalidateSeconds
-			});
-			if (!cachePolicy) {
-				options.isrDebug?.("RSC cache write skipped (no cache policy)", rscKey);
-				return;
-			}
-			const pageTags = options.getPageTags();
-			const observationState = options.consumeRenderObservationState?.() ?? createEmptyAppPageRenderObservationState();
-			const rscRenderObservation = options.createRscRenderObservation?.({
-				cacheTags: pageTags,
-				state: observationState
-			});
-			await options.isrSet(rscKey, buildAppPageCacheValue("", rscData, 200, rscRenderObservation), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds);
-			options.isrDebug?.("RSC cache written", rscKey);
-		} catch (cacheError) {
-			console.error("[vinext] ISR RSC cache write error:", cacheError);
-		}
-	})();
-	options.waitUntil?.(cachePromise);
-	return true;
-}
 //#endregion
 export { buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, readAppPageFallbackShellCacheResponse, scheduleAppPageRscCacheWrite };

package/dist/server/app-page-dispatch.d.ts

@@ -1,8 +1,8 @@
 import { ClassificationReason } from "../build/layout-classification-types.js";
-import { CachedAppPageValue } from "../shims/cache.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { RootParams } from "../shims/root-params.js";

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

@@ -1,11 +1,11 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
-import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
+import { beginPprFallbackShellFinalRender, createPprFallbackShellState, getPprFallbackShellState, runWithPprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
+import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -13,19 +13,14 @@ import "./app-page-response.js";
 import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
 import { createAppPageTreePath } from "./app-page-route-wiring.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
-import { rewriteAppPprFallbackShellHtmlNavigation } from "./app-ppr-fallback-shell.js";
-import { readAppPageCacheResponse, readAppPageFallbackShellCacheResponse } from "./app-page-cache.js";
 import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
 import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
-import { renderAppPageCacheArtifacts } from "./app-page-cache-render.js";
-import { warmPprFallbackShellCaches } from "./app-ppr-fallback-shell-render.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { renderAppPageLifecycle } from "./app-page-render.js";
-import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import React from "react";
 //#region src/server/app-page-dispatch.ts
 function resolveAppPageRouteBoundaryModule(route, statusCode) {
@@ -110,6 +105,7 @@ function hasSearchParams(searchParams) {
 	return searchParams !== null && searchParams !== void 0 && searchParams.size > 0;
 }
 async function runAppPageRevalidationContext(options, renderFn) {
+	const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 	return runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
 			draftModeSecret: options.draftModeSecret,
@@ -170,6 +166,8 @@ function classifyPprFallbackShellEligibility(options, currentRevalidateSeconds,
 	};
 }
 async function probePprFallbackShellCache(options, route, fallbackShells, currentRevalidateSeconds) {
+	const { readAppPageFallbackShellCacheResponse } = await import("./app-page-cache.js");
+	const { rewriteAppPprFallbackShellHtmlNavigation } = await import("./app-ppr-fallback-shell.js");
 	for (const fallbackShell of fallbackShells) {
 		const fallbackShellResponse = await readAppPageFallbackShellCacheResponse({
 			clearRequestContext: options.clearRequestContext,
@@ -241,6 +239,7 @@ async function dispatchAppPageInner(options) {
 		return methodResponse;
 	}
 	if ((isForceStatic || isDynamicError) && !isDraftMode) {
+		const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 		setHeadersContext(createStaticGenerationHeadersContext({
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig,
@@ -263,6 +262,7 @@ async function dispatchAppPageInner(options) {
 		revalidateSeconds: currentRevalidateSeconds,
 		scriptNonce: options.scriptNonce
 	})) {
+		const { readAppPageCacheResponse } = await import("./app-page-cache.js");
 		const cachedPageResponse = await readAppPageCacheResponse({
 			cleanPathname: options.cleanPathname,
 			clearRequestContext: options.clearRequestContext,
@@ -311,6 +311,7 @@ async function dispatchAppPageInner(options) {
 					routeSegments: revalidationTarget.route.routeSegments,
 					setNavigationContext: options.setNavigationContext
 				}, async () => {
+					const { renderAppPageCacheArtifacts } = await import("./app-page-cache-render.js");
 					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams());
 					const revalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern);
 					const rendered = await renderAppPageCacheArtifacts({
@@ -436,6 +437,7 @@ async function dispatchAppPageInner(options) {
 	if (fallbackShellState && process.env.VINEXT_PRERENDER === "1" && !options.isRscRequest) {
 		const warmupBuildResult = await buildCurrentPageElement();
 		if (warmupBuildResult.response) return warmupBuildResult.response;
+		const { warmPprFallbackShellCaches } = await import("./app-ppr-fallback-shell-render.js");
 		await warmPprFallbackShellCaches({
 			element: warmupBuildResult.element,
 			onError: options.createRscOnErrorHandler(options.cleanPathname, route.pattern),

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

@@ -1,5 +1,6 @@
-import { markAppPagePropsForUseCache } from "../shims/cache-runtime.js";
-import { isNextRouterError } from "../shims/navigation.js";
+import { markAppPagePropsForUseCache } from "../shims/internal/app-page-props-cache-key.js";
+import { isNextRouterError } from "../shims/navigation-errors.js";
+import "../shims/navigation-server.js";
 import { isPromiseLike } from "../utils/promise.js";
 import { probeAppPageComponent, probeAppPageLayouts } from "./app-page-execution.js";
 import { collectAppPageSearchParams } from "./app-page-head.js";

package/dist/server/app-page-render-observation.js

@@ -1,9 +1,9 @@
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage } from "../shims/headers.js";
 import { fnv1a64 } from "../utils/hash.js";
-import { _consumeRequestScopedCacheLife } from "../shims/cache.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import "./app-elements.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage } from "../shims/headers.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { consumeDynamicFetchObservations } from "../shims/fetch-cache.js";
 import { buildRenderObservation, buildRenderRequestApiObservations } from "./cache-proof.js";
 //#region src/server/app-page-render-observation.ts

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

@@ -1,14 +1,14 @@
-import { CachedAppPageValue } from "../shims/cache.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
 import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
-import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
 

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

@@ -8,9 +8,10 @@ import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageSpec
 import { probeAppPageBeforeRender } from "./app-page-probe.js";
 import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRenderObservation, buildRenderRequestApiObservations, createStaticLayoutArtifactReuseDecision } from "./cache-proof.js";
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
-import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache.js";
+import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";

package/dist/server/app-page-stream.d.ts

@@ -1,6 +1,7 @@
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-page-stream.d.ts
@@ -143,14 +144,6 @@ type AppPageRscErrorTracker = {
 };
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
 declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
-/**
- * Wraps a stream so that `onFlush` is called when the last byte has been read
- * by the downstream consumer (i.e. when the HTTP layer finishes draining the
- * response body). This is the correct place to clear per-request context,
- * because the RSC/SSR pipeline is lazy — components execute while the stream
- * is being consumed, not when the stream handle is first obtained.
- */
-declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, onFlush: () => void): ReadableStream<Uint8Array>;
 declare function renderAppPageHtmlResponse(options: RenderAppPageHtmlResponseOptions): Promise<Response>;
 declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError>): Promise<AppPageHtmlStreamRecoveryResult>;
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;

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

@@ -1,6 +1,7 @@
 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";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 //#region src/server/app-page-stream.ts
 function isAppSsrRenderResult(value) {
 	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
@@ -70,41 +71,6 @@ async function renderAppPageHtmlStream(options) {
 	};
 	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
-/**
-* Wraps a stream so that `onFlush` is called when the last byte has been read
-* by the downstream consumer (i.e. when the HTTP layer finishes draining the
-* response body). This is the correct place to clear per-request context,
-* because the RSC/SSR pipeline is lazy — components execute while the stream
-* is being consumed, not when the stream handle is first obtained.
-*/
-function deferUntilStreamConsumed(stream, onFlush) {
-	let called = false;
-	const once = () => {
-		if (!called) {
-			called = true;
-			onFlush();
-		}
-	};
-	const cleanup = new TransformStream({ flush() {
-		once();
-	} });
-	const reader = stream.pipeThrough(cleanup).getReader();
-	return new ReadableStream({
-		pull(controller) {
-			return reader.read().then(({ done, value }) => {
-				if (done) controller.close();
-				else controller.enqueue(value);
-			}, (error) => {
-				once();
-				controller.error(error);
-			});
-		},
-		cancel(reason) {
-			once();
-			return reader.cancel(reason);
-		}
-	});
-}
 async function renderAppPageHtmlResponse(options) {
 	const { htmlStream } = await renderAppPageHtmlStream(options);
 	const safeStream = deferUntilStreamConsumed(htmlStream, () => {

package/dist/server/app-request-context.d.ts

@@ -1,5 +1,4 @@
-import { NavigationContext } from "../shims/navigation.js";
-
+import { NavigationContext } from "../shims/navigation-context-state.js";
 //#region src/server/app-request-context.d.ts
 /**
  * Set navigation context in the ALS-backed store. "use client" components

package/dist/server/app-request-context.js

@@ -1,5 +1,6 @@
 import { setHeadersContext } from "../shims/headers.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
+import "../shims/navigation-server.js";
 import { setRootParams } from "../shims/root-params.js";
 //#region src/server/app-request-context.ts
 /**

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

@@ -3,13 +3,14 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { setNavigationContext } from "../shims/navigation.js";
+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 { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";

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

@@ -1,6 +1,6 @@
 import { NextI18nConfig } from "../config/next-config.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
-import { CachedRouteValue } from "../shims/cache.js";
 import { NextRequest } from "../shims/server.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";

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

@@ -1,8 +1,8 @@
 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 { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 //#region src/server/app-route-handler-execution.ts
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {

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

@@ -1,4 +1,4 @@
-import { CacheControlMetadata, CachedRouteValue } from "../shims/cache.js";
+import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 
 //#region src/server/app-route-handler-response.d.ts
 type RouteHandlerMiddlewareContext = {

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

@@ -2,7 +2,8 @@ import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+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 { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";

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

@@ -8,21 +8,19 @@ import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWith
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
-import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
-import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
@@ -167,6 +165,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	};
 	let didMiddlewareRewrite = false;
 	if (options.middlewareModule) {
+		const { applyAppMiddleware } = await import("./app-middleware.js");
 		const middlewareResult = await applyAppMiddleware({
 			basePath: options.basePath,
 			cleanPathname,
@@ -249,7 +248,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
 	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
 	const contentType = request.headers.get("content-type") || "";
-	const progressiveActionResult = await options.handleProgressiveActionRequest({
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	let progressiveActionResult = null;
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) progressiveActionResult = await options.handleProgressiveActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -257,12 +258,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (progressiveActionResult instanceof Response) return progressiveActionResult;
-	const isProgressiveActionRender = progressiveActionResult?.kind === "form-state";
-	const formState = isProgressiveActionRender ? progressiveActionResult.formState : null;
-	const failedProgressiveActionResult = isProgressiveActionRender && "actionFailed" in progressiveActionResult ? progressiveActionResult : null;
+	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
+	const isProgressiveActionRender = progressiveActionFormState !== null;
+	const formState = progressiveActionFormState?.formState ?? null;
+	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = await options.handleServerActionRequest({
+	const serverActionResponse = isPostRequest && actionId ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -272,7 +274,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		mountedSlotsHeader,
 		request,
 		searchParams: getResolvedSearchParams()
-	});
+	}) : null;
 	if (serverActionResponse) return serverActionResponse;
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
@@ -386,11 +388,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
 	const resolvedSearchParams = getResolvedSearchParams();
-	const runtimeFallbackShells = options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params ? createAppPprFallbackShells({
-		params: route.params,
-		pattern: route.pattern,
-		rootParamNames: route.rootParamNames
-	}, params) : [];
+	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);
+	}
 	options.setNavigationContext({
 		pathname: canonicalPathname,
 		searchParams: resolvedSearchParams,
@@ -443,7 +449,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: resolvedSearchParams,
 		renderMode
 	});
-	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionResult);
+	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState);
 	return pageResponse;
 }
 /**

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

@@ -4,8 +4,8 @@ import "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyConfigHeadersToResponse } from "./request-pipeline.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
-import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 //#region src/server/app-rsc-response-finalizer.ts
 /**

package/dist/server/app-server-action-execution.d.ts

@@ -1,4 +1,4 @@
-import { ActionRevalidationKind } from "../shims/cache.js";
+import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/headers.js";

package/dist/server/app-server-action-execution.js

@@ -4,17 +4,18 @@ import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS
 import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
-import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
-import { getAndClearActionRevalidationKind } from "../shims/cache.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
+import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
+import { getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
-import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import "./app-page-stream.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";

package/dist/server/app-ssr-entry.d.ts

@@ -1,4 +1,4 @@
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppSsrRenderResult } from "./app-page-stream.js";
 import { ReactFormState } from "react-dom/client";