vinext 0.1.4 → 0.1.5

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

@@ -1,144 +1,20 @@
-import { countConsumedPathnameSegments, isInvisibleSegment, normalizePathnameForRouteMatch, splitPathSegments } from "../routing/utils.js";
+import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { NEXT_ACTION_HEADER, RSC_ACTION_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
-import "./app-bfcache-id.js";
-import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isBfcacheSegmentId, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
+import { createCacheEntryReuseProof } from "./cache-proof.js";
+import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCommit } from "./operation-token.js";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 import { createSnapshotPathAndSearch } from "../shims/navigation.js";
-import { createCacheEntryReuseProof } from "./cache-proof.js";
 //#region src/server/app-browser-state.ts
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
 const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "visited-cache" };
-let nextBfcacheId = 0;
-function rememberBfcacheId(value) {
-	const match = /^_b_(\d+)_$/.exec(value);
-	if (!match) return;
-	nextBfcacheId = Math.max(nextBfcacheId, Number(match[1]));
-}
-function mintBfcacheId() {
-	nextBfcacheId += 1;
-	return `_b_${nextBfcacheId}_`;
-}
-function getVisibleTreePathSegments(treePath) {
-	return splitPathSegments(treePath).filter((segment) => !isInvisibleSegment(segment));
-}
-function getTreePathIdentityPrefix(pathname, treePath) {
-	const pathnameSegments = splitPathSegments(pathname);
-	const consumedPathnameSegments = countConsumedPathnameSegments(getVisibleTreePathSegments(treePath), pathnameSegments.length);
-	if (consumedPathnameSegments === 0) return "/";
-	return `/${pathnameSegments.slice(0, consumedPathnameSegments).join("/")}`;
-}
-function readAppElementsMetadata(elements) {
-	let metadata;
-	try {
-		metadata = AppElementsWire.readMetadata(elements);
-	} catch {
-		return null;
-	}
-	const slotBindingsBySlotId = /* @__PURE__ */ new Map();
-	for (const binding of metadata.slotBindings) slotBindingsBySlotId.set(binding.slotId, binding);
-	return {
-		metadata,
-		slotBindingsBySlotId
-	};
-}
-function createActiveSlotIdentity(id, parsed) {
-	const activeSlotBinding = parsed?.slotBindingsBySlotId.get(id);
-	if (activeSlotBinding?.activeRouteId != null) return `${id}@${activeSlotBinding.activeRouteId}`;
-	const interception = parsed?.metadata.interception;
-	if (interception?.slotId !== id) return null;
-	return `${id}@${interception.targetRouteId}`;
-}
-/**
-* Legacy bridge for deriving a bfcache segment identity from AppElements wire
-* keys. Keep wire-key parsing contained here until Vinext has a route-manifest
-* semantic authority equivalent to Next.js CacheNode/segment-cache state.
-*/
-function createBfcacheSegmentIdentity(id, options) {
-	const parsed = AppElementsWire.parseElementKey(id);
-	if (!parsed) return null;
-	if (parsed.kind === "page") return `${id}@${options.pathname}`;
-	if (parsed.kind === "slot") {
-		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
-		if (activeSlotIdentity !== null) return activeSlotIdentity;
-		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
-	}
-	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
-	return null;
-}
-function collectBfcacheSegmentIds(elements, parsed) {
-	const ids = new Set(Object.keys(elements));
-	const metadata = parsed === void 0 ? readAppElementsMetadata(elements) : parsed;
-	for (const layoutId of metadata?.metadata.layoutIds ?? []) ids.add(layoutId);
-	return Array.from(ids).filter(isBfcacheSegmentId);
-}
-function createInitialBfcacheIdMap(elements) {
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(elements)) ids[id] = "0";
-	return ids;
-}
-function normalizeBfcachePathname(pathname) {
-	const normalized = normalizePath(normalizePathnameForRouteMatch(pathname));
-	return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
-}
-function createBfcacheSegmentStateKeyMap(options) {
-	const metadata = readAppElementsMetadata(options.elements);
-	const normalizedPathname = normalizeBfcachePathname(options.pathname);
-	const stateKeys = {};
-	for (const id of collectBfcacheSegmentIds(options.elements, metadata)) {
-		const stateKey = createBfcacheSegmentIdentity(id, {
-			metadata,
-			pathname: normalizedPathname
-		});
-		if (stateKey !== null) stateKeys[id] = stateKey;
-	}
-	return stateKeys;
-}
-function createNextBfcacheIdMap(options) {
-	const current = options.reuseCurrent === false ? {} : options.current;
-	for (const value of Object.values(current)) rememberBfcacheId(value);
-	for (const value of Object.values(options.restored ?? {})) rememberBfcacheId(value);
-	const currentMetadata = readAppElementsMetadata(options.currentElements);
-	const nextMetadata = readAppElementsMetadata(options.elements);
-	const currentPathname = normalizeBfcachePathname(options.currentPathname);
-	const nextPathname = normalizeBfcachePathname(options.nextPathname);
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements, nextMetadata)) {
-		const currentValue = createBfcacheSegmentIdentity(id, {
-			metadata: currentMetadata,
-			pathname: currentPathname
-		}) === createBfcacheSegmentIdentity(id, {
-			metadata: nextMetadata,
-			pathname: nextPathname
-		}) ? current[id] : void 0;
-		const value = options.restored?.[id] ?? currentValue ?? mintBfcacheId();
-		ids[id] = value;
-		rememberBfcacheId(value);
-	}
-	return ids;
-}
-function preserveBfcacheIdsForMergedElements(options) {
-	const ids = {};
-	for (const id of collectBfcacheSegmentIds(options.elements)) {
-		const nextValue = options.next[id];
-		if (nextValue !== void 0) {
-			ids[id] = nextValue;
-			continue;
-		}
-		const previousValue = options.previous[id];
-		if (previousValue !== void 0) {
-			ids[id] = previousValue;
-			rememberBfcacheId(previousValue);
-		}
-	}
-	return ids;
-}
 function createOperationRecord(options) {
 	return {
 		id: options.id,

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

@@ -1,5 +1,5 @@
-import { ensureNavigationRuntimeRscBootstrap, getNavigationRuntime } from "../client/navigation-runtime.js";
 import { decodeRscEmbeddedChunk } from "./app-rsc-embedded-chunks.js";
+import { ensureNavigationRuntimeRscBootstrap, getNavigationRuntime } from "../client/navigation-runtime.js";
 //#region src/server/app-browser-stream.ts
 function getVinextBrowserGlobal() {
 	return globalThis;

package/dist/server/app-browser-visible-commit.js

@@ -1,8 +1,9 @@
 import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
 import { mergeElements } from "../shims/slot.js";
-import { createPendingNavigationCommit, preserveBfcacheIdsForMergedElements, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
+import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");
 function applyApprovedVisibleCommit(state, commit) {

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

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";

package/dist/server/app-layout-param-observation.d.ts

@@ -1,5 +1,5 @@
+import { UnstableCacheObservation } from "../shims/cache-request-state.js";
 import { RenderRequestApiKind } from "./cache-proof.js";
-import { UnstableCacheObservation } from "../shims/cache.js";
 import { ClientReuseManifestRejectionCode, ClientReuseManifestTraceFields } from "./client-reuse-manifest.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
 

package/dist/server/app-layout-param-observation.js

@@ -1,6 +1,6 @@
 import { isInsideUnifiedScope, runWithUnifiedStateMutation } from "../shims/unified-request-context.js";
 import { peekDynamicUsage, peekRenderRequestApiUsage } from "../shims/headers.js";
-import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache.js";
+import { _peekRequestScopedCacheLife, _peekUnstableCacheObservations } from "../shims/cache-request-state.js";
 import { getCollectedFetchTags, peekCacheableFetchObservations, peekDynamicFetchObservations } from "../shims/fetch-cache.js";
 import { isPromiseLike } from "../utils/promise.js";
 //#region src/server/app-layout-param-observation.ts

package/dist/server/app-middleware.js

@@ -5,8 +5,9 @@ import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, processMiddlewareHeaders } from "./request-pipeline.js";
 import { executeMiddleware } from "./middleware-runtime.js";
 import { applyMiddlewareRequestHeaders, setHeadersContext } from "../shims/headers.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "../shims/navigation.js";
 //#region src/server/app-middleware.ts
 const FLIGHT_HEADER_SET = new Set(FLIGHT_HEADERS);
 function isForwardedMiddlewareContext(value) {

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

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";

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

@@ -1,6 +1,6 @@
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { resolveAppPageSegmentParams } from "./app-page-params.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";
 //#region src/server/app-page-boundary.ts

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