vinext 0.1.3 → 0.1.5

package/dist/server/app-page-cache-finalizer.d.ts

@@ -0,0 +1,62 @@
+import { RenderObservation } from "./cache-proof.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { AppPageRenderObservationState } from "./app-page-render-observation.js";
+
+//#region src/server/app-page-cache-finalizer.d.ts
+type AppPageDebugLogger = (event: string, detail: string) => void;
+type AppPageCacheSetter = (key: string, data: CachedAppPageValue, revalidateSeconds: number, tags: string[], expireSeconds?: number) => Promise<void>;
+type AppPageRscCacheKeyBuilder = (pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null) => string;
+type AppPageRequestCacheLife = {
+  revalidate?: number;
+  expire?: number;
+};
+type BuildAppPageCacheRenderObservation = (input: {
+  cacheTags: readonly string[];
+  state: AppPageRenderObservationState;
+}) => RenderObservation;
+type FinalizeAppPageHtmlCacheResponseOptions = {
+  capturedDynamicUsageBeforeContextCleanup?: () => boolean;
+  capturedRscDataPromise: Promise<ArrayBuffer> | null;
+  cleanPathname: string;
+  consumeDynamicUsage: () => boolean;
+  consumeRenderObservationState?: () => AppPageRenderObservationState;
+  createHtmlRenderObservation?: BuildAppPageCacheRenderObservation;
+  createRscRenderObservation?: BuildAppPageCacheRenderObservation;
+  getPageTags: () => string[];
+  getRequestCacheLife?: () => AppPageRequestCacheLife | null;
+  isrDebug?: AppPageDebugLogger;
+  isrHtmlKey: (pathname: string) => string;
+  isrRscKey: AppPageRscCacheKeyBuilder;
+  isrSet: AppPageCacheSetter;
+  interceptionContext?: string | null;
+  preserveClientResponseHeaders?: boolean;
+  expireSeconds?: number;
+  revalidateSeconds: number | null;
+  waitUntil?: (promise: Promise<void>) => void;
+};
+type ScheduleAppPageRscCacheWriteOptions = {
+  capturedRscDataPromise: Promise<ArrayBuffer> | null;
+  cleanPathname: string;
+  consumeDynamicUsage: () => boolean;
+  consumeRenderObservationState?: () => AppPageRenderObservationState;
+  createRscRenderObservation?: BuildAppPageCacheRenderObservation;
+  dynamicUsedDuringBuild: boolean;
+  getPageTags: () => string[];
+  getRequestCacheLife?: () => AppPageRequestCacheLife | null;
+  isrDebug?: AppPageDebugLogger;
+  isrRscKey: AppPageRscCacheKeyBuilder;
+  isrSet: AppPageCacheSetter;
+  interceptionContext?: string | null;
+  mountedSlotsHeader?: string | null;
+  renderMode?: AppRscRenderMode;
+  preserveClientResponseHeaders?: boolean;
+  expireSeconds?: number;
+  revalidateSeconds: number | null;
+  waitUntil?: (promise: Promise<void>) => void;
+};
+declare function finalizeAppPageHtmlCacheResponse(response: Response, options: FinalizeAppPageHtmlCacheResponseOptions): Response;
+declare function finalizeAppPageRscCacheResponse(response: Response, options: ScheduleAppPageRscCacheWriteOptions): Response;
+declare function scheduleAppPageRscCacheWrite(options: ScheduleAppPageRscCacheWriteOptions): boolean;
+//#endregion
+export { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite };

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

@@ -0,0 +1,122 @@
+import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { buildAppPageCacheValue } from "./isr-cache.js";
+import { readStreamAsText } from "../utils/text-stream.js";
+import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
+//#region src/server/app-page-cache-finalizer.ts
+function applyPendingDynamicCdnHeaders(headers, tags) {
+	applyCdnResponseHeaders(headers, {
+		cacheControl: headers.get("Cache-Control") ?? "",
+		pendingDynamicCheck: true,
+		tags
+	});
+	setCacheStateHeaders(headers, "MISS");
+}
+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 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 { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite };

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

@@ -1,5 +1,5 @@
-import { CacheControlMetadata } from "../shims/cache.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { CacheControlMetadata } from "../shims/cache-handler.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";

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

@@ -1,5 +1,5 @@
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError } from "../shims/headers.js";
-import { _consumeRequestScopedCacheLife } from "../shims/cache.js";
+import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { getCollectedFetchTags } from "../shims/fetch-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { teeAppPageRscStreamForCapture } from "./app-page-execution.js";

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

@@ -1,7 +1,7 @@
 import { RenderObservation } from "./cache-proof.js";
-import { CacheControlMetadata, CachedAppPageValue } from "../shims/cache.js";
-import { AppPageRenderObservationState } from "./app-page-render-observation.js";
+import { CacheControlMetadata, CachedAppPageValue } from "../shims/cache-handler.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, scheduleAppPageRscCacheWrite } from "./app-page-cache-finalizer.js";
 import { ISRCacheEntry } from "./isr-cache.js";
 
 //#region src/server/app-page-cache.d.ts
@@ -10,10 +10,6 @@ type AppPageCacheGetter = (key: string) => Promise<ISRCacheEntry | null>;
 type AppPageCacheSetter = (key: string, data: CachedAppPageValue, revalidateSeconds: number, tags: string[], expireSeconds?: number) => Promise<void>;
 type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>) => void;
 type AppPageRscCacheKeyBuilder = (pathname: string, mountedSlotsHeader?: string | null, renderMode?: AppRscRenderMode, interceptionContext?: string | null) => string;
-type AppPageRequestCacheLife = {
-  revalidate?: number;
-  expire?: number;
-};
 type AppPageCacheOutcomeMetric = Readonly<{
   artifact: "html" | "rsc";
   /**
@@ -25,10 +21,6 @@ type AppPageCacheOutcomeMetric = Readonly<{
   reason: "empty-entry" | "no-entry" | "non-app-page-entry" | "query-variant-unproven" | "read-error" | "served" | "stale-empty-entry";
 }>;
 type AppPageCacheOutcomeRecorder = (metric: AppPageCacheOutcomeMetric) => void;
-type BuildAppPageCacheRenderObservation = (input: {
-  cacheTags: readonly string[];
-  state: AppPageRenderObservationState;
-}) => RenderObservation;
 type AppPageCacheRenderResult = {
   cacheControl?: CacheControlMetadata;
   html: string;
@@ -83,52 +75,9 @@ type ReadAppPageFallbackShellCacheResponseOptions = {
   revalidateSeconds: number;
   rewriteHtml: (html: string) => string;
 };
-type FinalizeAppPageHtmlCacheResponseOptions = {
-  capturedDynamicUsageBeforeContextCleanup?: () => boolean;
-  capturedRscDataPromise: Promise<ArrayBuffer> | null;
-  cleanPathname: string;
-  consumeDynamicUsage: () => boolean;
-  consumeRenderObservationState?: () => AppPageRenderObservationState;
-  createHtmlRenderObservation?: BuildAppPageCacheRenderObservation;
-  createRscRenderObservation?: BuildAppPageCacheRenderObservation;
-  getPageTags: () => string[];
-  getRequestCacheLife?: () => AppPageRequestCacheLife | null;
-  isrDebug?: AppPageDebugLogger;
-  isrHtmlKey: (pathname: string) => string;
-  isrRscKey: AppPageRscCacheKeyBuilder;
-  isrSet: AppPageCacheSetter;
-  interceptionContext?: string | null;
-  preserveClientResponseHeaders?: boolean;
-  expireSeconds?: number;
-  revalidateSeconds: number | null;
-  waitUntil?: (promise: Promise<void>) => void;
-};
-type ScheduleAppPageRscCacheWriteOptions = {
-  capturedRscDataPromise: Promise<ArrayBuffer> | null;
-  cleanPathname: string;
-  consumeDynamicUsage: () => boolean;
-  consumeRenderObservationState?: () => AppPageRenderObservationState;
-  createRscRenderObservation?: BuildAppPageCacheRenderObservation;
-  dynamicUsedDuringBuild: boolean;
-  getPageTags: () => string[];
-  getRequestCacheLife?: () => AppPageRequestCacheLife | null;
-  isrDebug?: AppPageDebugLogger;
-  isrRscKey: AppPageRscCacheKeyBuilder;
-  isrSet: AppPageCacheSetter;
-  interceptionContext?: string | null;
-  mountedSlotsHeader?: string | null;
-  renderMode?: AppRscRenderMode;
-  preserveClientResponseHeaders?: boolean;
-  expireSeconds?: number;
-  revalidateSeconds: number | null;
-  waitUntil?: (promise: Promise<void>) => void;
-};
 declare function buildAppPageCacheTags(pathname: string, extraTags: readonly string[]): string[];
 declare function buildAppPageCachedResponse(cachedValue: CachedAppPageValue, options: BuildAppPageCachedResponseOptions): Response | null;
 declare function readAppPageCacheResponse(options: ReadAppPageCacheResponseOptions): Promise<Response | null>;
 declare function readAppPageFallbackShellCacheResponse(options: ReadAppPageFallbackShellCacheResponseOptions): Promise<Response | null>;
-declare function finalizeAppPageHtmlCacheResponse(response: Response, options: FinalizeAppPageHtmlCacheResponseOptions): Response;
-declare function finalizeAppPageRscCacheResponse(response: Response, options: ScheduleAppPageRscCacheWriteOptions): Response;
-declare function scheduleAppPageRscCacheWrite(options: ScheduleAppPageRscCacheWriteOptions): boolean;
 //#endregion
 export { AppPageCacheOutcomeMetric, buildAppPageCacheTags, buildAppPageCachedResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse, readAppPageCacheResponse, readAppPageFallbackShellCacheResponse, scheduleAppPageRscCacheWrite };

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;