@vinext/cloudflare 1.2.0 → 1.3.0

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

@@ -0,0 +1,13 @@
+//#region src/cache/app-page-parts.d.ts
+/**
+ * Whether the response-stage props select an App page's own document or RSC
+ * payload, the two parts Next.js keeps in one entry, rather than a variant.
+ */
+export declare function isCanonicalAppPage(responseStageProps: unknown, isRscRequest: boolean): boolean;
+/**
+ * Whether a canonical RSC request has a document part. A `.rsc` path reaches
+ * its page's HTML path only through the app's trailingSlash policy, and
+ * vinext's client never sends one, so it stores its payload alone.
+ */
+export declare function hasDocumentPart(rscRequestUrl: string): boolean;
+//#endregion

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

@@ -0,0 +1,18 @@
+//#region src/cache/app-page-parts.ts
+/**
+* Whether the response-stage props select an App page's own document or RSC
+* payload, the two parts Next.js keeps in one entry, rather than a variant.
+*/
+function isCanonicalAppPage(responseStageProps, isRscRequest) {
+	return responseStageProps !== null && typeof responseStageProps === "object" && Reflect.get(responseStageProps, "kind") === "app-page" && Reflect.get(responseStageProps, "isRscRequest") === isRscRequest && (Reflect.get(responseStageProps, "matchKind") === "request" || Reflect.get(responseStageProps, "matchKind") === "resolved") && (!isRscRequest || Reflect.get(responseStageProps, "renderMode") === "navigation") && Reflect.get(responseStageProps, "interceptionContext") === null && Reflect.get(responseStageProps, "interceptionId") === null && Reflect.get(responseStageProps, "mountedSlotsHeader") === null;
+}
+/**
+* Whether a canonical RSC request has a document part. A `.rsc` path reaches
+* its page's HTML path only through the app's trailingSlash policy, and
+* vinext's client never sends one, so it stores its payload alone.
+*/
+function hasDocumentPart(rscRequestUrl) {
+	return !new URL(rscRequestUrl).pathname.endsWith(".rsc");
+}
+//#endregion
+export { hasDocumentPart, isCanonicalAppPage };

package/dist/cache/cdn-adapter-config.d.ts

@@ -28,4 +28,5 @@ export declare function finalizeCdnAdapterBuildOutput({ root, outDir, isPrimaryS
   binding: string;
   bindingIsExplicit: boolean;
 }): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/cache/cdn-adapter.runtime.d.ts

@@ -13,6 +13,7 @@ export declare class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
   private readonly versionMetadata?;
   private readonly versionMetadataBinding;
   readonly requiresCompletedResponseAdmission = true;
+  readonly responseStageCacheIdentity: "host-free";
   readonly responseVary: "verbatim";
   readonly responsePolicy: {
     isHeader(name: string): boolean;

package/dist/cache/cdn-adapter.runtime.js

@@ -150,6 +150,7 @@ var CloudflareCdnCacheAdapter = class {
 	versionMetadata;
 	versionMetadataBinding;
 	requiresCompletedResponseAdmission = true;
+	responseStageCacheIdentity = "host-free";
 	responseVary = "verbatim";
 	responsePolicy = {
 		isHeader(name) {

package/dist/cache/cdn-adapter.worker.js

@@ -1,7 +1,9 @@
 import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-build-id.js";
+import { hasDocumentPart, isCanonicalAppPage } from "./app-page-parts.js";
 import { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse } from "./browser-cache-policy.js";
 import { hasCacheMethod, invalidateOrPurge } from "./workers-cache-invalidation.js";
 import { VINEXT_PRERENDER_READINESS_PATH, VINEXT_RSC_VARY_HEADER } from "vinext/internal/server/headers";
+import { createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, stripRscCacheBustingSearchParam } from "vinext/internal/server/app-rsc-cache-busting";
 import { isNonCacheableCacheControl, splitCacheControlDirectives } from "vinext/shims/cdn-cache";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import "vinext/internal/server/cloudflare-workers-tracing";
@@ -15,11 +17,29 @@ const AUTHORIZATION_TRANSPORT_HEADER = "x-vinext-internal-authorization";
 const REQUEST_CACHE_CONTROL_TRANSPORT_HEADER = "x-vinext-internal-request-cache-control";
 const REQUEST_CF_TRANSPORT_HEADER = "x-vinext-internal-request-cf";
 const REQUEST_PRAGMA_TRANSPORT_HEADER = "x-vinext-internal-request-pragma";
+const RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER = "x-vinext-internal-render-whole-document";
+const DISPATCH_TRANSPORT_HEADER = "x-vinext-internal-dispatch";
+/** The stage props a host-free cache identity replaces. */
+const HOST_BEARING_PROPS = /* @__PURE__ */ new Set([
+	"requestHost",
+	"requestOrigin",
+	"requestUrl"
+]);
 const WARMUP_USER_AGENT = "vinext-cloudflare-cdn-warm";
 const RESPONSE_STAGE_WIRE_CACHE = {
 	bypass: "vinext-cloudflare-v1:bypass",
 	shared: "vinext-cloudflare-v1:shared"
 };
+/**
+* The statuses of a part Workers Cache just rendered for its entry, inline or
+* as a background refresh of a stale one.
+* https://developers.cloudflare.com/workers/cache/debugging/
+*/
+const RENDERED_ENTRY_CACHE_STATUSES = /* @__PURE__ */ new Set([
+	"EXPIRED",
+	"MISS",
+	"UPDATING"
+]);
 const FRAMEWORK_RESPONSE_VARY_FIELDS = new Set(VINEXT_RSC_VARY_HEADER.split(",").map((name) => name.trim().toLowerCase()));
 function isResponseStageReadinessRequest(request) {
 	return request.url.includes(VINEXT_PRERENDER_READINESS_PATH) && new URL(request.url).pathname === VINEXT_PRERENDER_READINESS_PATH;
@@ -63,20 +83,25 @@ function validateResponseStageBuildIdentity(response) {
 	return responseStageUnavailable();
 }
 function stripUntrustedTransportHeaders(request) {
-	if (!request.headers.has(AUTHORIZATION_TRANSPORT_HEADER) && !request.headers.has(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER) && !request.headers.has(REQUEST_CF_TRANSPORT_HEADER) && !request.headers.has(REQUEST_PRAGMA_TRANSPORT_HEADER)) return request;
+	if (!request.headers.has(AUTHORIZATION_TRANSPORT_HEADER) && !request.headers.has(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER) && !request.headers.has(REQUEST_CF_TRANSPORT_HEADER) && !request.headers.has(REQUEST_PRAGMA_TRANSPORT_HEADER) && !request.headers.has(RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER) && !request.headers.has(DISPATCH_TRANSPORT_HEADER)) return request;
 	const headers = new Headers(request.headers);
 	headers.delete(AUTHORIZATION_TRANSPORT_HEADER);
 	headers.delete(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER);
 	headers.delete(REQUEST_CF_TRANSPORT_HEADER);
 	headers.delete(REQUEST_PRAGMA_TRANSPORT_HEADER);
-	const sanitized = new Request(request, { headers });
-	const requestCf = Reflect.get(request, "cf");
-	if (requestCf !== void 0) Object.defineProperty(sanitized, "cf", {
+	headers.delete(RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER);
+	headers.delete(DISPATCH_TRANSPORT_HEADER);
+	return withRequestCf(new Request(request, { headers }), request);
+}
+/** Give a request built from another the platform's `request.cf` of that one. */
+function withRequestCf(request, source) {
+	const requestCf = Reflect.get(source, "cf");
+	if (requestCf !== void 0) Object.defineProperty(request, "cf", {
 		configurable: true,
 		enumerable: true,
 		value: requestCf
 	});
-	return sanitized;
+	return request;
 }
 function withWorkerHostRuntime(context, env) {
 	const candidateAssets = env && typeof env === "object" && Reflect.has(env, "ASSETS") ? Reflect.get(env, "ASSETS") : void 0;
@@ -100,7 +125,7 @@ function getResponseStageBinding(context, exportName, serializedInvocation) {
 	const target = binding({ props: JSON.parse(serializedInvocation) });
 	return hasFetch(target) ? target : null;
 }
-async function createCacheFacingRequest(request, serializedInvocation) {
+async function createCacheFacingRequest(request, serializedInvocation, identityRequest, dispatchRestore) {
 	const authorization = request.headers.get("Authorization");
 	let serializedRequestCf = null;
 	const requestCf = Reflect.get(request, "cf");
@@ -109,9 +134,9 @@ async function createCacheFacingRequest(request, serializedInvocation) {
 		if (json !== void 0) serializedRequestCf = encodeURIComponent(json);
 	} catch {}
 	const authorizationIdentity = authorization === null ? "absent" : `present:${authorization.length}:${authorization}`;
-	const frameworkVaryIdentity = JSON.stringify([...FRAMEWORK_RESPONSE_VARY_FIELDS].map((name) => [name, request.headers.get(name)]));
+	const frameworkVaryIdentity = JSON.stringify([...FRAMEWORK_RESPONSE_VARY_FIELDS].map((name) => [name, identityRequest.headers.get(name)]));
 	const responseStageBuildIdentity = getVinextCdnBuildIdentity() ?? "";
-	const bytes = new TextEncoder().encode(`${request.url}\0${serializedInvocation}\0${authorizationIdentity}\0${frameworkVaryIdentity}\0${responseStageBuildIdentity}`);
+	const bytes = new TextEncoder().encode(`${identityRequest.url}\0${serializedInvocation}\0${authorizationIdentity}\0${frameworkVaryIdentity}\0${responseStageBuildIdentity}`);
 	const key = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 	const url = new URL(request.url);
 	url.searchParams.set("__vinext_cache_key", key);
@@ -125,7 +150,9 @@ async function createCacheFacingRequest(request, serializedInvocation) {
 	headers.delete(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER);
 	headers.delete(REQUEST_CF_TRANSPORT_HEADER);
 	headers.delete(REQUEST_PRAGMA_TRANSPORT_HEADER);
+	headers.delete(DISPATCH_TRANSPORT_HEADER);
 	if (authorization !== null) headers.set(AUTHORIZATION_TRANSPORT_HEADER, encodeURIComponent(authorization));
+	if (dispatchRestore !== null) headers.set(DISPATCH_TRANSPORT_HEADER, encodeURIComponent(JSON.stringify(dispatchRestore)));
 	if (serializedRequestCf !== null) headers.set(REQUEST_CF_TRANSPORT_HEADER, serializedRequestCf);
 	if (requestCacheControl !== null) headers.set(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER, encodeURIComponent(requestCacheControl));
 	if (requestPragma !== null) headers.set(REQUEST_PRAGMA_TRANSPORT_HEADER, encodeURIComponent(requestPragma));
@@ -149,6 +176,8 @@ function restoreResponseStageRequest(request, requestUrl, requestMethod) {
 	headers.delete(REQUEST_CACHE_CONTROL_TRANSPORT_HEADER);
 	headers.delete(REQUEST_CF_TRANSPORT_HEADER);
 	headers.delete(REQUEST_PRAGMA_TRANSPORT_HEADER);
+	headers.delete(RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER);
+	headers.delete(DISPATCH_TRANSPORT_HEADER);
 	if (serializedAuthorization !== null) try {
 		headers.set("Authorization", decodeURIComponent(serializedAuthorization));
 	} catch {}
@@ -199,11 +228,11 @@ function revalidatesStoredEntry(request) {
 	return request.headers.has("If-None-Match") || request.headers.has("If-Modified-Since");
 }
 /**
-* No client waits on a deployment warm-up or on a revalidation, as with the
-* Response Store's.
+* No client waits on a deployment warm-up, on a revalidation, as with the
+* Response Store's, or on the gateway's fill of a page's document.
 */
 function rendersWholeDocument(request) {
-	return request.headers.get("user-agent") === WARMUP_USER_AGENT || revalidatesStoredEntry(request);
+	return request.headers.get("user-agent") === WARMUP_USER_AGENT || request.headers.has(RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER) || revalidatesStoredEntry(request);
 }
 /**
 * A conditional revalidation of a Pages page skips getStaticPaths(), so only a
@@ -328,6 +357,8 @@ function getResponseStageInvocation(value, expectedCache) {
 	} catch {
 		return null;
 	}
+	const restoresDispatch = Reflect.get(value, "restoresDispatch");
+	if (restoresDispatch !== void 0 && restoresDispatch !== true) return null;
 	return {
 		...typeof expectedResponseStageBuildIdentity === "string" ? { expectedResponseStageBuildIdentity } : {},
 		options: {
@@ -336,6 +367,117 @@ function getResponseStageInvocation(value, expectedCache) {
 		},
 		props: Reflect.get(value, "props"),
 		requestMethod,
+		requestUrl,
+		...restoresDispatch ? { restoresDispatch } : {}
+	};
+}
+/**
+* The dispatch of the other part of the page a canonical App page part belongs
+* to. Next.js keeps a page's document and RSC payload in one entry, so the two
+* dispatches differ only in the RSC request selectors, the URL's `_rsc` and the
+* request type in the props. The request keeps the client's other headers,
+* minus those that would make the fetch conditional or partial. No client
+* waits on a document fetched this way, so it is rendered whole, marked by a
+* header that, unlike the props, does not key its entry.
+*/
+function otherPagePartDispatch(request, props) {
+	const isRscRequest = isCanonicalAppPage(props, true);
+	if (!isRscRequest && !isCanonicalAppPage(props, false)) return null;
+	if (isRscRequest && !hasDocumentPart(request.url)) return null;
+	const headers = new Headers(request.headers);
+	for (const name of FRAMEWORK_RESPONSE_VARY_FIELDS) headers.delete(name);
+	for (const name of [
+		"If-Match",
+		"If-Modified-Since",
+		"If-None-Match",
+		"If-Range",
+		"If-Unmodified-Since",
+		"Range"
+	]) headers.delete(name);
+	if (isRscRequest) {
+		const url = new URL(request.url);
+		stripRscCacheBustingSearchParam(url);
+		headers.delete("x-deployment-id");
+		headers.set("Accept", "text/html");
+		headers.set(RENDER_WHOLE_DOCUMENT_TRANSPORT_HEADER, "1");
+		return {
+			props: {
+				...props,
+				isRscRequest: false
+			},
+			request: withRequestCf(new Request(url, { headers }), request)
+		};
+	}
+	for (const [name, value] of createCanonicalRscRequestHeaders()) headers.set(name, value);
+	return {
+		props: {
+			...props,
+			isRscRequest: true,
+			renderMode: "navigation"
+		},
+		request: withRequestCf(new Request(new URL(createCanonicalRscRequestUrl(request.url), request.url), { headers }), request)
+	};
+}
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pathAndSearch(url) {
+	return `${url.pathname}${url.search}`;
+}
+/**
+* What a shared dispatch's host-free identity replaced: the request URL, and
+* the top-level props that name the host. Null when the identity is anything
+* else, so the dispatch keys itself, host and all.
+*/
+function getDispatchRestore(request, props, identity) {
+	if (identity.request.method !== request.method || pathAndSearch(new URL(identity.request.url)) !== pathAndSearch(new URL(request.url))) return null;
+	const dispatched = JSON.parse(JSON.stringify(props) ?? "null");
+	const keyed = JSON.parse(JSON.stringify(identity.props) ?? "null");
+	if (!isPlainObject(dispatched) || !isPlainObject(keyed)) return null;
+	if (Object.keys(keyed).some((name) => !Object.hasOwn(dispatched, name))) return null;
+	const replaced = {};
+	for (const [name, value] of Object.entries(dispatched)) {
+		if (JSON.stringify(value) === JSON.stringify(keyed[name])) continue;
+		if (!HOST_BEARING_PROPS.has(name)) return null;
+		replaced[name] = value;
+	}
+	return {
+		props: replaced,
+		requestUrl: request.url
+	};
+}
+/**
+* Rebuild the dispatch a host-free invocation keys from the restore header
+* the gateway sent. Null when an identity invocation has no valid restore.
+*/
+function restoreDispatchInvocation(request, invocation) {
+	if (!invocation.restoresDispatch) return invocation;
+	const serialized = request.headers.get(DISPATCH_TRANSPORT_HEADER);
+	if (serialized === null || !isPlainObject(invocation.props)) return null;
+	let restore;
+	try {
+		restore = JSON.parse(decodeURIComponent(serialized));
+	} catch {
+		return null;
+	}
+	if (!isPlainObject(restore) || !isPlainObject(restore.props)) return null;
+	if (Object.keys(restore.props).some((name) => !HOST_BEARING_PROPS.has(name))) return null;
+	const requestUrl = restore.requestUrl;
+	if (typeof requestUrl !== "string") return null;
+	let url;
+	try {
+		url = new URL(requestUrl);
+	} catch {
+		return null;
+	}
+	if (pathAndSearch(url) !== pathAndSearch(new URL(invocation.requestUrl))) return null;
+	const { restoresDispatch: _restoresDispatch, ...dispatch } = invocation;
+	return {
+		...dispatch,
+		props: {
+			...invocation.props,
+			...restore.props
+		},
 		requestUrl
 	};
 }
@@ -363,22 +505,27 @@ var VinextCachedResponse = class extends WorkerEntrypoint {
 			headers: { "Cache-Control": "no-store" }
 		}));
 		if (invocation.expectedResponseStageBuildIdentity !== void 0 && invocation.expectedResponseStageBuildIdentity !== getVinextCdnBuildIdentity()) return stampResponseStageBuildIdentity(responseStageUnavailable());
-		const restored = restoreResponseStageRequest(request, invocation.requestUrl, invocation.requestMethod);
-		const isAppPageDocument = isAppPageDocumentInvocation(invocation);
-		const isPagesPage = isPagesPageInvocation(invocation);
+		const dispatch = restoreDispatchInvocation(request, invocation);
+		if (!dispatch) return stampResponseStageBuildIdentity(new Response("Invalid vinext response-stage invocation", {
+			status: 400,
+			headers: { "Cache-Control": "no-store" }
+		}));
+		const restored = restoreResponseStageRequest(request, dispatch.requestUrl, dispatch.requestMethod);
+		const isAppPageDocument = isAppPageDocumentInvocation(dispatch);
+		const isPagesPage = isPagesPageInvocation(dispatch);
 		const response = await invokeResponseStage(restored.request, this.env, context, isAppPageDocument && rendersWholeDocument(request) ? {
-			...invocation,
+			...dispatch,
 			options: {
-				...invocation.options,
+				...dispatch.options,
 				renderWholeDocument: true
 			}
 		} : isPagesPage && revalidatesStoredEntry(request) ? {
-			...invocation,
+			...dispatch,
 			options: {
-				...invocation.options,
+				...dispatch.options,
 				regeneratesStoredEntry: true
 			}
-		} : invocation);
+		} : dispatch);
 		return stampResponseStageBuildIdentity(restored.didAccessRequestCf() || hasTaggedCustomVary(response) ? preventResponseCaching(response) : isAppPageDocument ? withRevalidationValidator(response) : isPagesPage ? withPagesRevalidationValidator(response) : response);
 	}
 	async purge(options) {
@@ -408,30 +555,71 @@ var cdn_adapter_worker_default = { async fetch(request, env, context) {
 	request = stripUntrustedTransportHeaders(request);
 	const sharedResponses = /* @__PURE__ */ new Map();
 	const stageContext = withResponseStageCache(withWorkerHostRuntime(context, env));
-	const dispatchResponseStage = async (stageRequest, props, options) => {
+	const createInvocation = (stageRequest, props, options) => {
 		const expectedResponseStageBuildIdentity = getVinextCdnBuildIdentity();
-		const invocation = {
+		const { cacheIdentity: _cacheIdentity, ...stageOptions } = options;
+		return {
 			...expectedResponseStageBuildIdentity === null ? {} : { expectedResponseStageBuildIdentity },
-			options,
+			options: stageOptions,
 			props,
 			requestMethod: stageRequest.method,
 			requestUrl: stageRequest.url
 		};
+	};
+	/** Fetch a response stage through its named entrypoint, the cached one for a shared dispatch. */
+	const fetchResponseStageEntrypoint = async (stageRequest, props, options) => {
+		const invocation = createInvocation(stageRequest, props, options);
+		const usesSharedCache = options.cache === "shared";
+		const { cacheIdentity } = options;
+		const dispatchRestore = usesSharedCache && cacheIdentity ? getDispatchRestore(stageRequest, props, cacheIdentity) : null;
+		const keyedRequest = dispatchRestore ? cacheIdentity.request : stageRequest;
+		const serializedInvocation = JSON.stringify({
+			...invocation,
+			...dispatchRestore ? {
+				props: cacheIdentity.props,
+				requestMethod: keyedRequest.method,
+				requestUrl: keyedRequest.url,
+				restoresDispatch: true
+			} : {},
+			options: invocation.expectedResponseStageBuildIdentity === void 0 ? invocation.options : {
+				...invocation.options,
+				cache: RESPONSE_STAGE_WIRE_CACHE[options.cache]
+			}
+		});
+		const binding = getResponseStageBinding(stageContext, usesSharedCache ? CACHED_RESPONSE_STAGE_EXPORT : UNCACHED_RESPONSE_STAGE_EXPORT, serializedInvocation);
+		if (!binding) return responseStageUnavailable();
+		const entrypointRequest = usesSharedCache ? await createCacheFacingRequest(stageRequest, serializedInvocation, keyedRequest, dispatchRestore) : stageRequest;
+		return validateResponseStageBuildIdentity(await binding.fetch(entrypointRequest));
+	};
+	/**
+	* Fetch the other part of a canonical App page part Workers Cache just
+	* rendered, so its entry is filled or refreshed too. Workers Cache stores
+	* only what its entrypoint returns, so the other part renders on its own.
+	* A deployment warm-up already requests both parts, and this fetch reaches
+	* the entrypoint directly, so it never fetches another part itself.
+	*/
+	const storeOtherPagePart = (stageRequest, props, options, cacheStatus) => {
+		if (cacheStatus === null || !RENDERED_ENTRY_CACHE_STATUSES.has(cacheStatus) || stageRequest.headers.get("user-agent") === WARMUP_USER_AGENT || typeof stageContext.waitUntil !== "function") return;
+		stageContext.waitUntil((async () => {
+			const otherPart = otherPagePartDispatch(stageRequest, props);
+			if (!otherPart) return;
+			const { cacheIdentity, ...otherOptions } = options;
+			const otherIdentity = cacheIdentity ? otherPagePartDispatch(cacheIdentity.request, cacheIdentity.props) : null;
+			await (await fetchResponseStageEntrypoint(otherPart.request, otherPart.props, otherIdentity ? {
+				...otherOptions,
+				cacheIdentity: otherIdentity
+			} : otherOptions)).body?.pipeTo(new WritableStream());
+		})().catch((error) => {
+			console.error("[vinext] Workers Cache could not store a page's other part:", error);
+		}));
+	};
+	const dispatchResponseStage = async (stageRequest, props, options) => {
 		const usesSharedCache = options.cache === "shared";
 		try {
-			if (!usesSharedCache && !isResponseStageReadinessRequest(stageRequest)) return stampResponseStageBuildIdentity(await invokeResponseStage(stageRequest, env, stageContext, invocation));
-			const serializedInvocation = JSON.stringify({
-				...invocation,
-				options: expectedResponseStageBuildIdentity === null ? options : {
-					...options,
-					cache: RESPONSE_STAGE_WIRE_CACHE[options.cache]
-				}
-			});
-			const binding = getResponseStageBinding(stageContext, usesSharedCache ? CACHED_RESPONSE_STAGE_EXPORT : UNCACHED_RESPONSE_STAGE_EXPORT, serializedInvocation);
-			if (!binding) return responseStageUnavailable();
-			const entrypointRequest = usesSharedCache ? await createCacheFacingRequest(stageRequest, serializedInvocation) : stageRequest;
-			const response = validateResponseStageBuildIdentity(await binding.fetch(entrypointRequest));
+			if (!usesSharedCache && !isResponseStageReadinessRequest(stageRequest)) return stampResponseStageBuildIdentity(await invokeResponseStage(stageRequest, env, stageContext, createInvocation(stageRequest, props, options)));
+			const response = await fetchResponseStageEntrypoint(stageRequest, props, options);
 			if (!usesSharedCache) return response;
+			storeOtherPagePart(stageRequest, props, options, response.headers.get("CF-Cache-Status"));
 			const shared = markSharedResponseStage(response, crypto.randomUUID(), props, true);
 			sharedResponses.set(shared.headers.get(SHARED_RESPONSE_STAGE_HEADER), { headers: new Headers(shared.headers) });
 			return shared;

package/dist/cache/config.d.ts

@@ -134,4 +134,5 @@ export declare function createWorkersCacheConfig({ versionMetadataBinding }?: {
     VinextUncachedResponse: import("cf/config").WorkerEntrypointExport;
   };
 }>;
-//#endregion
+//#endregion
+export {};

package/dist/cache/kv-data-adapter.runtime.d.ts

@@ -60,7 +60,7 @@ export declare class KVCacheHandler implements CacheHandler {
   private keySpace;
   private ctx;
   private ttlSeconds;
-  /** Local in-memory cache for tag invalidation timestamps. Avoids redundant KV reads. */
+  /** Local in-memory cache for tag invalidation markers. Avoids redundant KV reads. */
   private _tagCache;
   /** Monotonic ordering for concurrent tag-cache fills and local invalidations. */
   private _tagCacheOrder;
@@ -95,14 +95,18 @@ export declare class KVCacheHandler implements CacheHandler {
    */
   private _readTagMarkers;
   /**
-   * Report whether any tag has an invalidation marker at or after `lastModified`.
+   * Report whether any tag expired an entry last modified at `lastModified`:
+   * its marker's expire time is at or after `lastModified` and, for a cacheLife
+   * profile's marker, has passed.
    * Call `_primeTagCache` for the same tags first — a tag with no cache entry
    * counts as never invalidated. Pass `requireFresh` to call it before a prime,
    * so an entry past `tagCacheTtlMs` does not answer for a tag it never re-read.
    */
   private _hasRevalidatedTag;
+  /** Report whether any primed tag was marked stale after `lastModified`. */
+  private _hasStaleTag;
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[], _durations?: {
+  revalidateTag(tags: string | string[], durations?: {
     expire?: number;
   }): Promise<void>;
   /**

package/dist/cache/kv-data-adapter.runtime.js

@@ -1,4 +1,5 @@
-import { isUnknownRecord, readCacheControlNumberField } from "../utils/cache-control-metadata.js";
+import { isStaleTagInvalidation } from "./workers-cache-invalidation.js";
+import { isUnknownRecord, readCacheControlNumberField, readCacheTimestamp } from "../utils/cache-control-metadata.js";
 import { ENTRY_PREFIX, createKvKeySpace, resolveKvExpirationTtlSeconds } from "./kv-key.js";
 import { Buffer } from "node:buffer";
 import { getRequestExecutionContext } from "vinext/shims/request-context";
@@ -24,6 +25,23 @@ import { getRequestExecutionContext } from "vinext/shims/request-context";
 */
 /** Default KV namespace binding name read from the Worker `env`. */
 const DEFAULT_BINDING = "VINEXT_KV_CACHE";
+function parseTagMarker(raw) {
+	if (raw === null || raw === void 0) return {};
+	if (!raw.startsWith("{")) return { expired: /^\d+$/.test(raw) ? Number(raw) : NaN };
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return { expired: NaN };
+	}
+	if (!isUnknownRecord(parsed)) return { expired: NaN };
+	const { stale, expired } = parsed;
+	if (stale === void 0 && expired === void 0 || stale !== void 0 && typeof stale !== "number" || expired !== void 0 && typeof expired !== "number") return { expired: NaN };
+	return {
+		...stale === void 0 ? {} : { stale },
+		...expired === void 0 ? {} : { expired }
+	};
+}
 /** Prefix used by revalidatePath for path-based tags. */
 const PATH_TAG_PREFIX = "_N_T_";
 /** The runtime rejects a lower `cacheTtl` with "Cache TTL must be at least 30". */
@@ -98,7 +116,7 @@ var KVCacheHandler = class {
 	keySpace;
 	ctx;
 	ttlSeconds;
-	/** Local in-memory cache for tag invalidation timestamps. Avoids redundant KV reads. */
+	/** Local in-memory cache for tag invalidation markers. Avoids redundant KV reads. */
 	_tagCache = /* @__PURE__ */ new Map();
 	/** Monotonic ordering for concurrent tag-cache fills and local invalidations. */
 	_tagCacheOrder = 0;
@@ -179,6 +197,7 @@ var KVCacheHandler = class {
 			return null;
 		}
 		if (this._hasRevalidatedTag(softTags, entry.lastModified)) return null;
+		const hasStaleTag = this._hasStaleTag([...entryTags, ...softTags], entry.lastModified);
 		if (entry.expireAt !== void 0 && entry.expireAt !== null && Date.now() > entry.expireAt) {
 			this._deleteEntryReadInBackground(kvKey);
 			return null;
@@ -186,7 +205,7 @@ var KVCacheHandler = class {
 		const now = Date.now();
 		const requestedRevalidate = readPositiveNumberField(_ctx, "revalidate");
 		const requestedRevalidateAt = requestedRevalidate === void 0 ? null : entry.lastModified + requestedRevalidate * 1e3;
-		if (entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
+		if (hasStaleTag || entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
 			lastModified: entry.lastModified,
 			value: restoredValue,
 			cacheState: "stale",
@@ -221,7 +240,7 @@ var KVCacheHandler = class {
 			if (current && current.order >= order) continue;
 			const marker = markers.get(this._tagKey(tag));
 			tagCache.set(tag, {
-				timestamp: marker ? Number(marker) : 0,
+				marker: parseTagMarker(marker),
 				fetchedAt: now,
 				order
 			});
@@ -244,18 +263,30 @@ var KVCacheHandler = class {
 		return markers;
 	}
 	/**
-	* Report whether any tag has an invalidation marker at or after `lastModified`.
+	* Report whether any tag expired an entry last modified at `lastModified`:
+	* its marker's expire time is at or after `lastModified` and, for a cacheLife
+	* profile's marker, has passed.
 	* Call `_primeTagCache` for the same tags first — a tag with no cache entry
 	* counts as never invalidated. Pass `requireFresh` to call it before a prime,
 	* so an entry past `tagCacheTtlMs` does not answer for a tag it never re-read.
 	*/
 	_hasRevalidatedTag(tags, lastModified, requireFresh = false) {
-		const now = requireFresh ? Date.now() : 0;
+		const now = Date.now();
 		for (const tag of tags) {
 			const cached = this._tagCache.get(tag);
-			if (!cached || cached.timestamp === 0) continue;
+			if (cached?.marker.expired === void 0) continue;
 			if (requireFresh && now - cached.fetchedAt >= this._tagCacheTtl) continue;
-			if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
+			const { stale, expired } = cached.marker;
+			const pending = stale !== void 0 && expired > now;
+			if (Number.isNaN(expired) || expired >= lastModified && !pending) return true;
+		}
+		return false;
+	}
+	/** Report whether any primed tag was marked stale after `lastModified`. */
+	_hasStaleTag(tags, lastModified) {
+		for (const tag of tags) {
+			const stale = this._tagCache.get(tag)?.marker.stale;
+			if (stale !== void 0 && stale > lastModified) return true;
 		}
 		return false;
 	}
@@ -277,7 +308,7 @@ var KVCacheHandler = class {
 		const effectiveStale = readCacheControlNumberField(ctx, "stale");
 		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
 		if (effectiveRevalidate === 0) return Promise.resolve();
-		const now = Date.now();
+		const now = readCacheTimestamp(ctx, Date.now());
 		const revalidateAt = typeof effectiveRevalidate === "number" && effectiveRevalidate > 0 && Number.isFinite(effectiveRevalidate) ? now + effectiveRevalidate * 1e3 : null;
 		const expireAt = typeof effectiveExpire === "number" && effectiveExpire > 0 ? now + effectiveExpire * 1e3 : null;
 		const cacheControl = typeof effectiveRevalidate === "number" ? {
@@ -300,16 +331,32 @@ var KVCacheHandler = class {
 			metadata
 		});
 	}
-	async revalidateTag(tags, _durations) {
+	async revalidateTag(tags, durations) {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
 		const validTags = tagList.filter((t) => validateTag(t) !== null);
-		await Promise.all(validTags.map((tag) => this.kv.put(this._tagKey(tag), String(now))));
+		const markers = await Promise.all(validTags.map(async (tag) => {
+			const tagKey = this._tagKey(tag);
+			if (!isStaleTagInvalidation(durations)) {
+				await this.kv.put(tagKey, String(now));
+				return { expired: now };
+			}
+			const expire = durations?.expire;
+			const expired = expire === void 0 ? parseTagMarker(await this.kv.get(tagKey)).expired : now + expire * 1e3;
+			const marker = {
+				stale: now,
+				...expired !== void 0 && Number.isFinite(expired) ? { expired } : {}
+			};
+			await this.kv.put(tagKey, JSON.stringify(marker));
+			return marker;
+		}));
 		const order = ++this._tagCacheOrder;
-		for (const tag of validTags) this._tagCache.set(tag, {
-			timestamp: now,
-			fetchedAt: now,
-			order
+		validTags.forEach((tag, index) => {
+			this._tagCache.set(tag, {
+				marker: markers[index],
+				fetchedAt: now,
+				order
+			});
 		});
 	}
 	/**

package/dist/cache/response-store-adapter.worker.d.ts

@@ -11,4 +11,5 @@ export declare function createVinextResponseStoreOptions<Env extends VinextRespo
 export declare function createVinextResponseStoreHandler(store: WorkersResponseStore): {
   fetch(request: Request, env: VinextResponseStoreEnv, ctx: WorkerExecutionContext): Promise<Response>;
 };
-//#endregion
+//#endregion
+export {};