@vinext/cloudflare 1.1.0 → 1.2.0

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

@@ -132,6 +132,7 @@ function toEdgeCacheControl(cacheControl) {
 */
 const MAX_CACHE_TAG_BYTES = 16384;
 const CACHE_TAG_PREFIX = "vinext-";
+const MAX_TAGS_PER_PURGE = 100;
 /** Encode a case-sensitive Next.js tag into a fixed Workers Cache tag. */
 function encodeCloudflareCacheTag(tag) {
 	return `${CACHE_TAG_PREFIX}${fnv1a64(`0:${tag}`)}${fnv1a64(`1:${tag}`)}`;
@@ -222,11 +223,16 @@ var CloudflareCdnCacheAdapter = class {
 		if (!cache) return;
 		const tagList = (Array.isArray(tags) ? tags : [tags]).filter((t) => typeof t === "string");
 		if (tagList.length === 0) return;
-		const options = { tags: tagList.map(encodeCloudflareCacheTag) };
+		const encodedTags = [...new Set(tagList.map(encodeCloudflareCacheTag))];
 		const operation = isStaleTagInvalidation(durations) ? "invalidate" : "purge";
-		const result = await (operation === "invalidate" ? invalidateOrPurge(cache, options) : cache.purge(options));
-		if (result?.success === false) {
-			const errors = result.errors.map(({ code, message }) => `${code}: ${message}`).join(", ");
+		const chunks = [];
+		for (let i = 0; i < encodedTags.length; i += MAX_TAGS_PER_PURGE) chunks.push(encodedTags.slice(i, i + MAX_TAGS_PER_PURGE));
+		const settled = await Promise.allSettled(chunks.map(async (chunk) => await (operation === "invalidate" ? invalidateOrPurge(cache, { tags: chunk }) : cache.purge({ tags: chunk }))));
+		const rejection = settled.find((result) => result.status === "rejected");
+		if (rejection) throw rejection.reason;
+		const failures = settled.flatMap((result) => result.status === "fulfilled" && result.value?.success === false ? [result.value] : []);
+		if (failures.length > 0) {
+			const errors = failures.flatMap((result) => result.errors).map(({ code, message }) => `${code}: ${message}`).join(", ");
 			throw new Error(`[vinext] Workers Cache ${operation} failed${errors ? `: ${errors}` : ""}`);
 		}
 	}

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

@@ -2,7 +2,7 @@ import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-bui
 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 { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
+import { isNonCacheableCacheControl, splitCacheControlDirectives } from "vinext/shims/cdn-cache";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import "vinext/internal/server/cloudflare-workers-tracing";
 import { loadVinextRequestStage } from "vinext/server/request-stage";
@@ -132,7 +132,8 @@ async function createCacheFacingRequest(request, serializedInvocation) {
 	return new Request(url, {
 		cf: { vary: { default: { action: "passthrough" } } },
 		headers,
-		method: request.method
+		method: request.method,
+		redirect: "manual"
 	});
 }
 function restoreResponseStageRequest(request, requestUrl, requestMethod) {
@@ -183,18 +184,63 @@ function isAppPageDocumentInvocation(invocation) {
 	const props = invocation.props;
 	return props !== null && typeof props === "object" && Reflect.get(props, "kind") === "app-page" && Reflect.get(props, "isRscRequest") === false;
 }
+/** A Pages page render, as an HTML document or a `_next/data` payload. */
+function isPagesPageInvocation(invocation) {
+	const props = invocation.props;
+	if (props === null || typeof props !== "object") return false;
+	const kind = Reflect.get(props, "kind");
+	return kind === "pages-page" || kind === "hybrid-pages" && Reflect.get(props, "resourceKind") === "page";
+}
+/**
+* Workers Cache revalidates an entry that has a validator with a conditional
+* request, and serves the stale entry meanwhile or fills an expired one.
+*/
+function revalidatesStoredEntry(request) {
+	return request.headers.has("If-None-Match") || request.headers.has("If-Modified-Since");
+}
 /**
-* No client waits on a deployment warm-up. Workers Cache revalidates an entry
-* that has a validator with a conditional request, as it does the Response
-* Store's, and serves the stale entry meanwhile or fills an expired one.
+* No client waits on a deployment warm-up or on a revalidation, as with the
+* Response Store's.
 */
 function rendersWholeDocument(request) {
-	return request.headers.get("user-agent") === WARMUP_USER_AGENT || request.headers.has("If-None-Match") || request.headers.has("If-Modified-Since");
+	return request.headers.get("user-agent") === WARMUP_USER_AGENT || revalidatesStoredEntry(request);
+}
+/**
+* A conditional revalidation of a Pages page skips getStaticPaths(), so only a
+* successful render may be stored with a validator. Bot renders carry an ETag
+* whatever their status. A 304 answers a revalidation of a stored 200, and a
+* response a shared cache may not store keeps its validators.
+*/
+function withPagesRevalidationValidator(response) {
+	if (response.status === 200) return withRevalidationValidator(response);
+	const policy = selectedCachePolicy(response);
+	if (response.status === 304 || policy !== null && forbidsSharedStorage(policy) || !response.headers.has("ETag") && !response.headers.has("Last-Modified")) return response;
+	const headers = new Headers(response.headers);
+	headers.delete("ETag");
+	headers.delete("Last-Modified");
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/**
+* `no-cache` and a field-qualified `private` still let a shared cache store the
+* response (RFC 9111 sections 5.2.2.4 and 5.2.2.7).
+*/
+function forbidsSharedStorage(policy) {
+	return splitCacheControlDirectives(policy).some((directive) => {
+		const normalized = directive.toLowerCase();
+		return normalized === "private" || normalized.split("=", 1)[0].trim() === "no-store";
+	});
+}
+function selectedCachePolicy(response) {
+	return response.headers.get("Cloudflare-CDN-Cache-Control") ?? response.headers.get("CDN-Cache-Control") ?? response.headers.get("Cache-Control");
 }
 /** Give a cacheable document a validator, so Workers Cache revalidates it conditionally. */
 function withRevalidationValidator(response) {
 	if (response.headers.has("ETag") || response.headers.has("Last-Modified")) return response;
-	const policy = response.headers.get("Cloudflare-CDN-Cache-Control") ?? response.headers.get("CDN-Cache-Control") ?? response.headers.get("Cache-Control");
+	const policy = selectedCachePolicy(response);
 	if (policy === null || isNonCacheableCacheControl(policy)) return response;
 	const headers = new Headers(response.headers);
 	headers.set("Last-Modified", (/* @__PURE__ */ new Date()).toUTCString());
@@ -319,14 +365,21 @@ var VinextCachedResponse = class extends WorkerEntrypoint {
 		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 response = await invokeResponseStage(restored.request, this.env, context, isAppPageDocument && rendersWholeDocument(request) ? {
 			...invocation,
 			options: {
 				...invocation.options,
 				renderWholeDocument: true
 			}
+		} : isPagesPage && revalidatesStoredEntry(request) ? {
+			...invocation,
+			options: {
+				...invocation.options,
+				regeneratesStoredEntry: true
+			}
 		} : invocation);
-		return stampResponseStageBuildIdentity(restored.didAccessRequestCf() || hasTaggedCustomVary(response) ? preventResponseCaching(response) : isAppPageDocument ? withRevalidationValidator(response) : response);
+		return stampResponseStageBuildIdentity(restored.didAccessRequestCf() || hasTaggedCustomVary(response) ? preventResponseCaching(response) : isAppPageDocument ? withRevalidationValidator(response) : isPagesPage ? withPagesRevalidationValidator(response) : response);
 	}
 	async purge(options) {
 		const cache = Reflect.get(this.ctx, "cache");

package/dist/cache/config.d.ts

@@ -6,7 +6,7 @@ type ResponseStoreStorageOptions = {
 };
 export declare function createWorkersResponseStoreSelfContainedConfig(options: ResponseStoreStorageOptions): Promise<{
   cache: {
-    enabled: true;
+    enabled: false;
   };
   exports: {
     CacheMetadata: {
@@ -45,7 +45,7 @@ export declare function createWorkersResponseStoreServiceBindingConfig(options:
   accountId: string | undefined;
   serviceBindingWorker: {
     cache: {
-      enabled: true;
+      enabled: false;
     };
     exports: {
       CacheMetadata: {
@@ -84,7 +84,7 @@ export declare function createWorkersResponseStoreServiceBindingConfig(options:
     env: {
       RESPONSE_STORE: import("cf/config").WorkerBinding<{
         cache: {
-          enabled: true;
+          enabled: false;
         };
         exports: {
           CacheMetadata: {

package/dist/cache/config.js

@@ -10,7 +10,7 @@ const RESPONSE_STORE_SERVICE_ENTRYPOINT = "@cloudflare/workers-response-store/se
 async function createResponseStoreWorkerConfig(options) {
 	const { bindings, exports } = await import("cf/config");
 	return {
-		cache: { enabled: true },
+		cache: { enabled: false },
 		exports: {
 			[CACHE_METADATA_CLASS]: {
 				...exports.durableObject({ storage: "sqlite" }),

package/dist/cache/kv-key.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { fnv1a64 } from "vinext/internal/utils/hash";
 //#region src/cache/kv-key.ts
 /** Key prefix for tag invalidation timestamps. */
@@ -27,19 +28,37 @@ function kvKeyByteLength(key) {
 	return KV_KEY_ENCODER.encode(key).length;
 }
 /**
+* Digest an entry key that is too long to store verbatim. Logical keys can
+* carry request input, so the digest must be collision resistant: two keys
+* sharing a digest would share an entry.
+*/
+function digestEntryKey(key) {
+	return createHash("sha256").update(key).digest("hex");
+}
+/**
+* Digest a tag that is too long or unsafe to store verbatim. Tags sharing a
+* digest share one invalidation marker, which can only invalidate extra
+* entries. Markers are permanent, so a new digest would drop the
+* invalidations already recorded for entries still in KV.
+*/
+function digestTag(tag) {
+	return fnv1a64(tag);
+}
+/**
 * Keep short app prefixes readable, but bound the namespace portion so a
 * hashed entry or tag key is always able to fit within Cloudflare KV's limit.
 */
 function normalizeAppPrefix(appPrefix) {
 	if (!appPrefix) return "";
 	const prefix = `${appPrefix}:`;
-	if (kvKeyByteLength(`${prefix}cache:${HASHED_KEY_PREFIX}${fnv1a64("")}`) <= KV_KEY_MAX_BYTES) return prefix;
+	if (kvKeyByteLength(`${prefix}cache:${HASHED_KEY_PREFIX}${digestEntryKey("")}`) <= KV_KEY_MAX_BYTES) return prefix;
 	return `__app:${fnv1a64(appPrefix)}:`;
 }
 function buildStorageKey(prefix, categoryPrefix, logicalKey) {
 	const key = `${prefix}${categoryPrefix}${logicalKey}`;
 	if (!(categoryPrefix === TAG_PREFIX && logicalKey.includes(":")) && kvKeyByteLength(key) <= KV_KEY_MAX_BYTES) return key;
-	return `${prefix}${categoryPrefix}${HASHED_KEY_PREFIX}${fnv1a64(logicalKey)}`;
+	const digest = categoryPrefix === TAG_PREFIX ? digestTag(logicalKey) : digestEntryKey(logicalKey);
+	return `${prefix}${categoryPrefix}${HASHED_KEY_PREFIX}${digest}`;
 }
 /** Create the deterministic key namespace for runtime cache operations. */
 function createKvKeySpace(appPrefix) {

package/dist/cache/response-store-adapter.worker.js

@@ -2,10 +2,11 @@ import { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse } from "./browser
 import { captureResponseStoreDataRegeneration, runWithResponseStoreInvocation, setResponseStore } from "./response-store-data.runtime.js";
 import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "vinext/internal/server/headers";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER as VINEXT_RSC_VARY_HEADER$1, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl } from "vinext/internal/server/app-rsc-cache-busting";
-import { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
+import { hasSharedCacheCredentials, isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
 import { loadVinextRequestStage } from "vinext/server/request-stage";
 import { loadVinextResponseStage } from "vinext/server/response-stage";
 import { traceCachedResponseStart } from "vinext/internal/server/response-start-tracing";
+import { isPageNotModified } from "vinext/internal/server/http-conditional";
 //#region src/cache/response-store-adapter.worker.ts
 const ROUTE_REVALIDATOR_ID = "vinext:response";
 const RESPONSE_STORE_KEY_PARAM = "__workers_response_store";
@@ -41,7 +42,7 @@ function replayHeaders(request) {
 function isReplayableInvocation(request, props) {
 	const method = request.method.toUpperCase();
 	if (method !== "GET" && method !== "HEAD") return false;
-	if (request.headers.has("authorization") || request.headers.has("cookie")) return false;
+	if (hasSharedCacheCredentials(request.headers)) return false;
 	return !(props && typeof props === "object" && ["draftModeCookie", "middlewareCookieOverlay"].some((name) => name in props && Reflect.get(props, name) !== null));
 }
 function prepareInvocation(request, props) {
@@ -96,6 +97,7 @@ function createVinextResponseStoreOptions(configuration) {
 				const invocation = parseInvocation(input.args.at(-1));
 				const response = await invokeResponseStage(restoreRequest(invocation), invocation.props, env, ctx, {
 					cache: "shared",
+					regeneratesStoredEntry: true,
 					renderWholeDocument: true
 				});
 				if (!isCacheable(response)) {
@@ -160,7 +162,59 @@ function isStoredErrorStatus(status) {
 }
 function isCacheable(response) {
 	const policy = response.headers.get("Cloudflare-CDN-Cache-Control") ?? response.headers.get("CDN-Cache-Control") ?? response.headers.get("Cache-Control");
-	return response.status >= 200 && (response.status < 400 || isStoredErrorStatus(response.status)) && policy !== null && !isNonCacheableCacheControl(policy);
+	return response.status >= 200 && response.status !== 304 && (response.status < 400 || isStoredErrorStatus(response.status)) && policy !== null && !isNonCacheableCacheControl(policy);
+}
+/**
+* A page's 304 headers. Next.js sends the 304 before it sets the payload's
+* headers, so it carries no representation or body framing headers.
+*/
+function notModifiedHeaders(source) {
+	const headers = new Headers(source);
+	for (const name of [
+		"Content-Encoding",
+		"Content-Length",
+		"Content-Type",
+		"Transfer-Encoding"
+	]) headers.delete(name);
+	return headers;
+}
+/** Send the 304 for a page whose ETag matched the request's If-None-Match. */
+function notModifiedResponse(response) {
+	response.body?.cancel().catch(() => {});
+	return new Response(null, {
+		headers: notModifiedHeaders(response.headers),
+		status: 304
+	});
+}
+/**
+* Whether Next.js sends this stored response through `sendRenderResult`, which
+* answers a conditional request by the page's ETag. It sends every App page
+* that way. A Pages redirect, and a Pages data request's notFound, are sent
+* without an ETag, as is a route handler's response. A Pages API response is
+* never stored.
+*/
+function answersConditionalRequest(responseStageProps, status) {
+	if (responseStageProps === null || typeof responseStageProps !== "object") return false;
+	const kind = Reflect.get(responseStageProps, "kind");
+	if (kind === "app-page" || kind === "app-not-found") return true;
+	let isDataRequest;
+	if (kind === "hybrid-pages") {
+		if (Reflect.get(responseStageProps, "resourceKind") !== "page") return false;
+		isDataRequest = Reflect.get(responseStageProps, "isDataRequest") === true;
+	} else if (kind === "pages-page") {
+		const renderOptions = Reflect.get(responseStageProps, "renderOptions");
+		isDataRequest = renderOptions !== null && typeof renderOptions === "object" && Reflect.get(renderOptions, "isDataReq") === true;
+	} else return false;
+	return status >= 200 && status < 300 || status === 404 && !isDataRequest;
+}
+/** Answer a stored page's conditional request as Next.js does for a cached page. */
+function storedForRequest(stored, request, responseStageProps) {
+	const etag = stored.headers.get("ETag");
+	return etag && answersConditionalRequest(responseStageProps, stored.status) && isPageNotModified({
+		cacheControl: request.headers.get("Cache-Control") ?? void 0,
+		ifModifiedSince: request.headers.get("If-Modified-Since") ?? void 0,
+		ifNoneMatch: request.headers.get("If-None-Match") ?? void 0
+	}, etag) ? notModifiedResponse(stored) : stored;
 }
 async function readStoredResponse(key) {
 	try {
@@ -235,11 +289,11 @@ const handler = { async fetch(request, env, ctx) {
 		const key = await cacheRequest(invocation);
 		const stored = await readStoredResponse(key);
 		if (stored) {
-			if (!rscKey) return publicResponse(stored, "HIT", props);
+			if (!rscKey) return publicResponse(storedForRequest(stored, stageRequest, props), "HIT", props);
 			const storedRsc = await readStoredResponse(rscKey);
 			if (storedRsc) {
 				storedRsc.body?.cancel().catch(() => {});
-				return publicResponse(stored, "HIT", props);
+				return publicResponse(storedForRequest(stored, stageRequest, props), "HIT", props);
 			}
 			stored.body?.cancel().catch(() => {});
 		}
@@ -252,6 +306,7 @@ const handler = { async fetch(request, env, ctx) {
 			replayable: isReplayableInvocation(stageRequest, props),
 			serialized: options.cacheIdentity ? serializeInvocation(stageRequest, props) : serializedInvocation
 		});
+		const foreground = (response) => capture.notModified ? notModifiedResponse(response) : response;
 		if (capture.admittedResponse) {
 			ctx.waitUntil(capture.admittedResponse.then(async (admitted) => {
 				if (!isCacheable(admitted)) {
@@ -271,17 +326,23 @@ const handler = { async fetch(request, env, ctx) {
 					error: error instanceof Error ? error.message : String(error)
 				}));
 			}));
-			return publicResponse(rendered, "MISS", props, true);
+			if (!capture.notModified) return publicResponse(rendered, "MISS", props, true);
+			const notModified = notModifiedResponse(rendered);
+			const admitted = await capture.admittedResponse.catch(() => null);
+			return admitted ? publicResponse(new Response(null, {
+				headers: notModifiedHeaders(admitted.headers),
+				status: 304
+			}), "MISS", props) : publicResponse(notModified, "MISS", props, true);
 		}
 		if (!isCacheable(rendered)) {
 			capture?.rscData?.catch(() => {});
-			return publicResponse(rendered, "BYPASS", props);
+			return publicResponse(foreground(rendered), "BYPASS", props);
 		}
 		if (rscSeed && !capture?.rscData) {
 			await rendered.body?.cancel();
 			throw new Error("Vinext response-store warmup did not capture the App page RSC payload");
 		}
-		const [foreground, cacheBody] = rendered.body ? rendered.body.tee() : [null, null];
+		const [foregroundBody, cacheBody] = rendered.body ? rendered.body.tee() : [null, null];
 		const cacheResponse = withoutRequestScopedHeaders(new Response(cacheBody, rendered), props);
 		try {
 			await responseStore.put(key, cacheResponse, {
@@ -324,7 +385,7 @@ const handler = { async fetch(request, env, ctx) {
 				}
 			});
 		}
-		return publicResponse(new Response(foreground, rendered), "MISS", props);
+		return publicResponse(foreground(new Response(foregroundBody, rendered)), "MISS", props);
 	};
 	const { handleRequestStage } = await loadVinextRequestStage();
 	const sharedResponses = /* @__PURE__ */ new Map();

package/dist/cache/response-store-cdn.runtime.js

@@ -1,5 +1,5 @@
 import createCloudflareCdnCacheAdapter from "./cdn-adapter.runtime.js";
-import { captureResponseStoreRscData, deferResponseStoreAdmission } from "./response-store-data.runtime.js";
+import { captureResponseStoreRscData, deferResponseStoreAdmission, deferResponseStoreNotModified } from "./response-store-data.runtime.js";
 //#region src/cache/response-store-cdn.runtime.ts
 /** Response Store owns page serving and SWR; vinext only emits admitted response policy. */
 var ResponseStoreCdnCacheAdapter = class {
@@ -33,6 +33,9 @@ var ResponseStoreCdnCacheAdapter = class {
 	captureAppPageRscData(rscData) {
 		captureResponseStoreRscData(rscData);
 	}
+	deferNotModifiedResponse() {
+		return deferResponseStoreNotModified();
+	}
 	async revalidateTag() {}
 };
 function createResponseStoreCdnCacheAdapter(context) {

package/dist/cache/response-store-data.runtime.d.ts

@@ -4,6 +4,8 @@ import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "vinext/s
 export type ResponseStoreInvocationCapture = {
   admittedResponse?: Promise<Response>;
   captureRscData?: boolean;
+  /** The render matched the request's If-None-Match; the adapter sends the 304. */
+  notModified?: boolean;
   rscData?: Promise<ArrayBuffer>;
   streamResponse?: boolean;
 };
@@ -15,6 +17,8 @@ export declare function setResponseStore(store: WorkersResponseStore): void;
 export declare function runWithResponseStoreInvocation<T>(serialized: string, replayable: boolean, callback: () => T, capture?: ResponseStoreInvocationCapture): T;
 /** Retain the RSC side stream only when the outer response-store invocation requested it. */
 export declare function captureResponseStoreRscData(rscData: Promise<ArrayBuffer>): void;
+/** A shared invocation stores the page, so its adapter sends the page's 304. */
+export declare function deferResponseStoreNotModified(): boolean;
 /** Stream the foreground body while retaining an independent admission branch. */
 export declare function deferResponseStoreAdmission(response: Response, complete: (response: Response) => Promise<Response>): Response | null;
 /** Re-render an invocation and return the exact rewritten data-cache entry. */

package/dist/cache/response-store-data.runtime.js

@@ -33,6 +33,13 @@ function captureResponseStoreRscData(rscData) {
 	if (capture?.captureRscData) capture.rscData = rscData;
 	else rscData.catch(() => {});
 }
+/** A shared invocation stores the page, so its adapter sends the page's 304. */
+function deferResponseStoreNotModified() {
+	const capture = invocationStorage.getStore()?.capture;
+	if (!capture) return false;
+	capture.notModified = true;
+	return true;
+}
 /** Stream the foreground body while retaining an independent admission branch. */
 function deferResponseStoreAdmission(response, complete) {
 	const capture = invocationStorage.getStore()?.capture;
@@ -328,4 +335,4 @@ function createResponseStoreDataCacheAdapter() {
 	return new WorkersResponseStoreCacheHandler();
 }
 //#endregion
-export { CACHE_FUNCTION_REVALIDATOR_ID, DATA_REVALIDATOR_ID, WorkersResponseStoreCacheHandler, captureResponseStoreDataRegeneration, captureResponseStoreRscData, createResponseStoreDataCacheAdapter as default, deferResponseStoreAdmission, runWithResponseStoreInvocation, setResponseStore };
+export { CACHE_FUNCTION_REVALIDATOR_ID, DATA_REVALIDATOR_ID, WorkersResponseStoreCacheHandler, captureResponseStoreDataRegeneration, captureResponseStoreRscData, createResponseStoreDataCacheAdapter as default, deferResponseStoreAdmission, deferResponseStoreNotModified, runWithResponseStoreInvocation, setResponseStore };

package/dist/cache/static-assets-adapter.build.js

@@ -2,8 +2,8 @@ import { STATIC_ASSET_CACHE_PATH } from "./static-assets-adapter.shared.js";
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { readPrerenderManifest } from "vinext/internal/server/prerender-manifest";
-import { appIsrCacheKey, pagesIsrCacheKey } from "vinext/internal/server/isr-cache";
+import { isFallbackShellArtifactPath, readPrerenderManifest } from "vinext/internal/server/prerender-manifest";
+import { appIsrCacheKey, appIsrFallbackShellKey, pagesIsrCacheKey } from "vinext/internal/server/isr-cache";
 import { extractVinextNextDataJson } from "vinext/internal/client/vinext-next-data";
 import { normalizePregeneratedPathname } from "vinext/internal/server/pregenerated-concrete-paths";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "vinext/internal/utils/prerender-output-paths";
@@ -67,8 +67,9 @@ function finalizeStaticAssetsPrerenderOutput(root, options = {}) {
 		const pathname = route.path ?? route.route;
 		const cachePathname = normalizePregeneratedPathname(pathname);
 		if (route.router === "app") {
-			count += Number(writeCacheAsset(outputDir, index, appIsrCacheKey(cachePathname, "html", manifest.buildId), "html", path.join(prerenderDir, getOutputPath(pathname, manifest.trailingSlash ?? false)), route));
-			count += Number(writeCacheAsset(outputDir, index, appIsrCacheKey(cachePathname, "rsc", manifest.buildId), "rsc", path.join(prerenderDir, getRscOutputPath(pathname)), route));
+			const appKey = isFallbackShellArtifactPath(pathname, route) ? appIsrFallbackShellKey : appIsrCacheKey;
+			count += Number(writeCacheAsset(outputDir, index, appKey(cachePathname, "html", manifest.buildId), "html", path.join(prerenderDir, getOutputPath(pathname, manifest.trailingSlash ?? false)), route));
+			count += Number(writeCacheAsset(outputDir, index, appKey(cachePathname, "rsc", manifest.buildId), "rsc", path.join(prerenderDir, getRscOutputPath(pathname)), route));
 		} else if (route.router === "pages") {
 			const sourcePath = path.join(prerenderDir, getOutputPath(pathname, manifest.trailingSlash ?? false));
 			if (!fs.existsSync(sourcePath)) continue;

package/dist/cache/static-assets-adapter.runtime.d.ts

@@ -9,9 +9,11 @@ export declare class StaticAssetsCacheAdapter implements CdnCacheAdapter {
   readonly assets: AssetFetcher;
   readonly hasPrerenderedPages = true;
   readonly ownsBackgroundRevalidation = false;
-  private indexPromise;
+  private index;
+  private pendingIndex;
   constructor(assets: AssetFetcher);
   private loadIndex;
+  private fetchIndex;
   get(key: string): Promise<CacheHandlerValue | null>;
   set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;

package/dist/cache/static-assets-adapter.runtime.js

@@ -1,5 +1,6 @@
 import { STATIC_ASSET_CACHE_PATH } from "./static-assets-adapter.shared.js";
 import { DefaultCdnCacheAdapter } from "vinext/shims/cdn-cache";
+import { getRequestExecutionContext } from "vinext/shims/request-context";
 //#region src/cache/static-assets-adapter.runtime.ts
 async function cacheAssetId(key) {
 	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key));
@@ -12,12 +13,32 @@ var StaticAssetsCacheAdapter = class {
 	assets;
 	hasPrerenderedPages = true;
 	ownsBackgroundRevalidation = false;
-	indexPromise;
+	index;
+	pendingIndex;
 	constructor(assets) {
 		this.assets = assets;
 	}
 	loadIndex() {
-		return this.indexPromise ??= this.assets.fetch(`https://vinext.invalid${STATIC_ASSET_CACHE_PATH}/index.json`).then(async (response) => response.ok ? await response.json() : null).then((value) => value !== null && typeof value === "object" ? value : null);
+		if (this.index !== void 0) return Promise.resolve(this.index);
+		if (this.pendingIndex) return this.pendingIndex;
+		const ctx = getRequestExecutionContext();
+		if (!ctx) return this.fetchIndex();
+		const pending = this.fetchIndex().finally(() => {
+			if (this.pendingIndex === pending) this.pendingIndex = void 0;
+		});
+		this.pendingIndex = pending;
+		ctx.waitUntil(pending.catch(() => {}));
+		return pending;
+	}
+	async fetchIndex() {
+		const response = await this.assets.fetch(`https://vinext.invalid${STATIC_ASSET_CACHE_PATH}/index.json`);
+		if (!response.ok) {
+			response.body?.cancel().catch(() => {});
+			if (response.status === 404) this.index = null;
+			return null;
+		}
+		const value = await response.json();
+		return this.index = value !== null && typeof value === "object" ? value : null;
 	}
 	async get(key) {
 		const id = await cacheAssetId(key);

package/dist/cdn-warm.d.ts

@@ -43,7 +43,6 @@ export declare const DEFAULT_STAGED_READINESS_INTERVAL_MS = 1000;
 export declare const DEFAULT_STAGED_READINESS_PHASE_TIMEOUT_MS = 120000;
 export type PrerenderCdnWarmOptions = Omit<CdnWarmOptions, "paths"> & {
   root: string;
-  includeFallbackShells?: boolean;
   /** Use the manifest build identity unless the configured adapter cannot expose it. */
   validateBuildIdentity?: boolean;
 };
@@ -92,13 +91,11 @@ export type PrerenderWarmPlan = {
 };
 type PrerenderWarmPlanOptions = {
   includeCanonicalRsc?: boolean;
-  includeFallbackShells?: boolean;
   strict?: boolean;
 };
 export declare function createPrerenderWarmPlan(root: string, manifest: PrerenderPathManifest, options?: PrerenderWarmPlanOptions): PrerenderWarmPlan;
 export declare function readPrerenderWarmPlan(root: string, options?: PrerenderWarmPlanOptions): PrerenderWarmPlan;
 export declare function readPrerenderWarmPaths(root: string, options?: {
-  includeFallbackShells?: boolean;
   strict?: boolean;
 }): string[];
 export declare function getWarmPathsFromPrerenderManifest(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];

package/dist/cdn-warm.js

@@ -6,7 +6,7 @@ import { randomUUID } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { VINEXT_CACHE_HEADER, VINEXT_PRERENDER_READINESS_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_PRERENDER_SECRET_HEADER } from "vinext/internal/server/headers";
 import { PRERENDER_PATHS_MANIFEST } from "vinext/internal/build/prerender-paths";
-import { getPrerenderedConcretePaths, readPrerenderManifest } from "vinext/internal/server/prerender-manifest";
+import { getPrerenderedConcretePaths } from "vinext/internal/server/prerender-manifest";
 import { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER as VINEXT_RSC_VARY_HEADER$1, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRequestUrl } from "vinext/internal/server/app-rsc-cache-busting";
 import { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
 import { normalizePathTrailingSlash } from "vinext/shims/url-utils";
@@ -73,17 +73,7 @@ function createPrerenderWarmPlan(root, manifest, options) {
 	const supportsCanonicalRsc = (manifest.responseVary === "verbatim" || options?.includeCanonicalRsc === true) && manifest.rscPaths !== void 0 && manifest.rscBuildId !== void 0;
 	const applyConfig = (pathname) => applyWarmPathConfig(pathname, manifest);
 	const routePatterns = manifest.routePatterns ? Object.fromEntries(Object.entries(manifest.routePatterns).map(([pathname, route]) => [pathname.includes("/_next/data/") ? pathname : applyConfig(pathname), route])) : void 0;
-	let htmlPaths = pathPlan.paths;
-	if (options?.includeFallbackShells === true) {
-		const prerenderManifest = readPrerenderManifest(path.join(root, "dist", "server", "vinext-prerender.json"));
-		if (!prerenderManifest) console.warn("[vinext] CDN warmup fallback shells requested, but prerender manifest not found; warming build-discovered paths only.");
-		else if (!prerenderManifest.buildId || prerenderManifest.buildId !== manifest.buildId) {
-			const message = "[vinext] CDN warmup skipped: prerender manifest buildId does not match dist/server/BUILD_ID.";
-			if (options.strict) throw new Error(message);
-			console.warn(message);
-			htmlPaths = [];
-		} else htmlPaths = getPrerenderedConcretePaths(prerenderManifest, { includeFallbackShells: true }).filter((pathname) => pathname.startsWith("/")).filter((pathname) => !manifest.excludedWarmPaths?.includes(pathname)).map(applyConfig);
-	}
+	const htmlPaths = pathPlan.paths;
 	return {
 		...manifest.appPaths ? { appPaths: manifest.appPaths.map(applyConfig) } : {},
 		buildId: manifest.buildId,
@@ -959,10 +949,7 @@ async function warmCdnCache(options) {
 	return result;
 }
 async function warmCdnCacheFromPrerender(options) {
-	const plan = readPrerenderWarmPlan(options.root, {
-		includeFallbackShells: options.includeFallbackShells,
-		strict: options.strict
-	});
+	const plan = readPrerenderWarmPlan(options.root, { strict: options.strict });
 	const warmPlan = {
 		deploymentId: plan.deploymentId,
 		loadingShellPaths: plan.loadingShellPaths,

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { deploy, parseDeployArgs } from "./deploy.js";
-import { printDeployHelp } from "./deploy-help.js";
+import { printDeployHelp, printPreviewsDeployHelp } from "./deploy-help.js";
+import { parsePreviewsDeployArgs } from "./previews-deploy.js";
 import fs from "node:fs";
 //#region src/cli.ts
 const VERSION = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
@@ -11,6 +12,10 @@ function printHelp(commandName) {
 		printDeployHelp();
 		return;
 	}
+	if (commandName === "previews") {
+		printPreviewsDeployHelp();
+		return;
+	}
 	console.log(`
   vinext-cloudflare v${VERSION}
 
@@ -21,7 +26,8 @@ function printHelp(commandName) {
     vp exec vinext-cloudflare <command>    Run the locally installed bin
 
   Commands:
-    deploy   Deploy to Cloudflare Workers
+    deploy                          Deploy to Cloudflare Workers
+    previews deploy [preview-name]  Deploy a Cloudflare Worker Preview
 
   Options:
     -h, --help     Show this help
@@ -62,13 +68,36 @@ async function deployCommand() {
 		dangerouslyPromoteOnCdnWarmError: parsed.dangerouslyPromoteOnCdnWarmError,
 		warmCdnPromote: parsed.warmCdnPromote,
 		warmCdnPromotionDelay: parsed.warmCdnPromotionDelay,
-		warmCdnIncludeFallbacks: parsed.warmCdnIncludeFallbacks,
 		experimentalTPR: parsed.experimentalTPR,
 		tprCoverage: parsed.tprCoverage,
 		tprLimit: parsed.tprLimit,
 		tprWindow: parsed.tprWindow
 	});
 }
+async function previewsCommand() {
+	const subcommand = rawArgs[0];
+	if (subcommand !== "deploy") {
+		if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+			printHelp("previews");
+			return;
+		}
+		throw new Error(`Unknown previews command: ${subcommand}`);
+	}
+	const options = parsePreviewsDeployArgs(rawArgs.slice(1));
+	if (options.help) {
+		printHelp("previews");
+		return;
+	}
+	await deploy({
+		root: process.cwd(),
+		env: options.mode,
+		skipBuild: options.skipBuild,
+		target: {
+			type: "preview",
+			name: options.name
+		}
+	});
+}
 if (command === "--version" || command === "-v") {
 	console.log(`vinext-cloudflare v${VERSION}`);
 	process.exit(0);
@@ -84,6 +113,12 @@ switch (command) {
 			process.exit(1);
 		});
 		break;
+	case "previews":
+		previewsCommand().catch((error) => {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		});
+		break;
 	default:
 		console.error(`Unknown command: ${command}`);
 		printHelp();

package/dist/deploy-help.d.ts

@@ -1,4 +1,6 @@
 //#region src/deploy-help.d.ts
 export declare function formatDeployHelp(): string;
 export declare function printDeployHelp(): void;
+export declare function formatPreviewsDeployHelp(): string;
+export declare function printPreviewsDeployHelp(): void;
 //#endregion

package/dist/deploy-help.js

@@ -67,8 +67,6 @@ function formatDeployHelp() {
                              verified (never bypasses --warm-cache-certify)
     --warm-cache-promotion-delay <ms>
                              Delay before promotion after warmup (default: 15000)
-    --warm-cache-include-fallbacks
-                             Also warm PPR fallback-shell placeholder paths
     -h, --help               Show this help
 
   Traffic-aware warming:
@@ -89,11 +87,14 @@ function formatDeployHelp() {
   be reused outside the data center reached by the warmup request after cache
   propagation, but the deploy does not wait for every edge location to fill.
 
+  --preview is an alias for --env preview. It selects a mode/environment,
+  not a Preview deployment. Use previews deploy to deploy a Worker Preview.
+
   Examples:
     npx @vinext/cloudflare deploy                                      Build and deploy to production
     vpx @vinext/cloudflare deploy                                      Build and deploy with Vite+
     vp exec vinext-cloudflare deploy                                   Run the locally installed Vite+ bin
-    vinext-cloudflare deploy --preview                                 Deploy to a preview URL
+    vinext-cloudflare deploy --preview                                 Deploy using mode/environment preview
     vinext-cloudflare deploy --env staging                             Deploy using Cloudflare mode/environment staging
     vinext-cloudflare deploy --config dist/server/wrangler.json        Deploy using a generated Wrangler config
     vinext-cloudflare deploy --dry-run                                 Validate setup without building or deploying
@@ -115,5 +116,32 @@ function formatDeployHelp() {
 function printDeployHelp() {
 	console.log(formatDeployHelp());
 }
+function formatPreviewsDeployHelp() {
+	return `
+  vinext-cloudflare previews deploy - Deploy a Cloudflare Worker Preview
+
+  Usage: vinext-cloudflare previews deploy [preview-name] [options]
+
+  Builds the app with isPreview=true, then deploys its Preview Build Output
+  using cf previews deploy. Requires cloudflare.config.ts and the cf CLI.
+
+  Arguments:
+    preview-name    Optional Preview name (cf uses the CI or Git branch if omitted)
+
+  Options:
+    --mode <mode>   Vite mode to build and deploy in (default: production)
+    --skip-build    Deploy existing Preview Build Output without rebuilding
+    -h, --help      Show this help
+
+  Examples:
+    vinext-cloudflare previews deploy
+    vinext-cloudflare previews deploy pr-123
+    vinext-cloudflare previews deploy pr-123 --mode staging
+    vinext-cloudflare previews deploy pr-123 --skip-build
+`;
+}
+function printPreviewsDeployHelp() {
+	console.log(formatPreviewsDeployHelp());
+}
 //#endregion
-export { formatDeployHelp, printDeployHelp };
+export { formatDeployHelp, formatPreviewsDeployHelp, printDeployHelp, printPreviewsDeployHelp };

package/dist/deploy.d.ts

@@ -12,6 +12,11 @@ export type DeployOptions = {
   root: string;
   /** Deploy to preview environment (default: production) */
   preview?: boolean;
+  /** Deploy to Preview deployment, supported only by cf. */
+  target?: {
+    type: "preview";
+    name?: string;
+  };
   /** Wrangler environment name from wrangler.jsonc env.<name> */
   env?: string;
   /** Custom project name for the Worker */
@@ -62,8 +67,6 @@ export type DeployOptions = {
   warmCdnPromote?: boolean;
   /** Delay between successful warmup and promotion in milliseconds */
   warmCdnPromotionDelay?: number;
-  /** Include PPR fallback-shell placeholder paths during CDN warmup */
-  warmCdnIncludeFallbacks?: boolean;
   /** Select CDN pre-warm routes using traffic analytics */
   experimentalTPR?: boolean;
   /** TPR: traffic coverage percentage target (0–100, default: 90) */
@@ -104,7 +107,6 @@ export declare function parseDeployArgs(args: string[]): {
   dangerouslyPromoteOnCdnWarmError: boolean;
   warmCdnPromote: boolean;
   warmCdnPromotionDelay: number | undefined;
-  warmCdnIncludeFallbacks: boolean;
   experimentalTPR: boolean;
   tprCoverage: number | undefined;
   tprLimit: number | undefined;
@@ -123,6 +125,8 @@ export declare function parseDeployArgs(args: string[]): {
  * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
  */
 export declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
+/** Cloudflare Vite Plugin reads this flag when evaluating the typed config and emitting Build Output. */
+export declare function withCloudflarePreviewBuild<T>(fn: () => Promise<T>): Promise<T>;
 export declare function resolveViteBuildMode(deploymentTool: DeploymentTool, env: string | undefined): string;
 type WranglerDeployArgs = {
   args: string[];
@@ -136,7 +140,7 @@ export declare function validateWranglerEnvName(env: string): string;
 export declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerDeployArgs;
 export declare function resolveDeploymentTool(root: string): DeploymentTool;
 export declare function isCfCliInstalled(root: string, resolvePackageJson?: (root: string) => string | null): boolean;
-export declare function buildCfDeployArgs(options: Pick<DeployOptions, "preview" | "env">): CfDeployArgs;
+export declare function buildCfDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "target">): CfDeployArgs;
 /**
  * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
@@ -157,7 +161,7 @@ export declare function buildWranglerInvocation(root: string, options: Pick<Depl
 export declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
   promote?: boolean;
 }, execute?: typeof spawn): Promise<string>;
-export declare function runCfDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof spawn): Promise<string>;
+export declare function runCfDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "target">, execute?: typeof spawn): Promise<string>;
 export declare function hasCdnWarmRequests(plan: Omit<CdnWarmRequestPlan, "pagesDataPaths"> & {
   pagesDataPaths?: readonly string[];
 }): boolean;

package/dist/deploy.js

@@ -16,7 +16,7 @@ import { setTimeout } from "node:timers/promises";
 import { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, discoverPrerenderPathManifest, emitPrerenderPathManifest } from "vinext/internal/build/prerender-paths";
 import { normalizePathTrailingSlash } from "vinext/shims/url-utils";
 import { spawn } from "node:child_process";
-import { parseArgs } from "node:util";
+import { parseArgs, stripVTControlCharacters } from "node:util";
 import { pathToFileURL } from "node:url";
 import { VINEXT_BUILD_LIFECYCLE_CONFIG } from "vinext/internal/build/lifecycle";
 import { runPrerender } from "vinext/internal/build/run-prerender";
@@ -228,7 +228,7 @@ function parseDeployArgs(args) {
 	values["warm-cache-readiness-probe-delay"] ??= values["warm-cdn-readiness-probe-delay"];
 	values["warm-cache-no-promote"] ||= values["warm-cdn-no-promote"];
 	values["warm-cache-promotion-delay"] ??= values["warm-cdn-promotion-delay"];
-	values["warm-cache-include-fallbacks"] ||= values["warm-cdn-include-fallbacks"];
+	if (values["warm-cache-include-fallbacks"] || values["warm-cdn-include-fallbacks"]) console.warn("[vinext] --warm-cache-include-fallbacks is deprecated and has no effect.");
 	values["traffic-aware-warm-cache"] ||= values["experimental-traffic-aware-warm-cache"];
 	const trafficAwareWarmCache = values["traffic-aware-warm-cache"] || values["experimental-tpr"];
 	const warming = values["warm-cache"] || trafficAwareWarmCache;
@@ -271,7 +271,6 @@ function parseDeployArgs(args) {
 		dangerouslyPromoteOnCdnWarmError: values["dangerously-promote-on-warm-cache-error"],
 		warmCdnPromote: !values["no-promote"] && !values["warm-cache-no-promote"],
 		warmCdnPromotionDelay: values["warm-cache-promotion-delay"] === void 0 ? void 0 : validatePromotionDelay(parseNonNegativeIntegerArg(values["warm-cache-promotion-delay"], "--warm-cache-promotion-delay"), values["warm-cache-promotion-delay"]),
-		warmCdnIncludeFallbacks: values["warm-cache-include-fallbacks"],
 		experimentalTPR: trafficAwareWarmCache,
 		tprCoverage: parseIntArg("traffic-aware-coverage", values["traffic-aware-coverage"] ?? values["tpr-coverage"]),
 		tprLimit: parseIntArg("traffic-aware-limit", values["traffic-aware-limit"] ?? values["tpr-limit"]),
@@ -302,6 +301,18 @@ async function withCloudflareEnv(env, fn) {
 		else delete process.env.CLOUDFLARE_ENV;
 	}
 }
+/** Cloudflare Vite Plugin reads this flag when evaluating the typed config and emitting Build Output. */
+async function withCloudflarePreviewBuild(fn) {
+	const hadPrevious = "CLOUDFLARE_PREVIEW_BUILD" in process.env;
+	const previous = process.env.CLOUDFLARE_PREVIEW_BUILD;
+	process.env.CLOUDFLARE_PREVIEW_BUILD = "true";
+	try {
+		return await fn();
+	} finally {
+		if (hadPrevious) process.env.CLOUDFLARE_PREVIEW_BUILD = previous;
+		else delete process.env.CLOUDFLARE_PREVIEW_BUILD;
+	}
+}
 async function loadProjectViteApi(root) {
 	let vitePath;
 	try {
@@ -385,7 +396,10 @@ function isCfCliInstalled(root, resolvePackageJson = (projectRoot) => {
 }
 function buildCfDeployArgs(options) {
 	const mode = options.env || (options.preview ? "preview" : void 0);
-	const args = ["deploy", "--prebuilt"];
+	const isPreviewDeploy = options.target?.type === "preview";
+	const args = isPreviewDeploy ? ["previews", "deploy"] : ["deploy"];
+	if (isPreviewDeploy && options.target?.name) args.push(options.target.name);
+	args.push("--prebuilt");
 	if (mode) args.push("--mode", validateWranglerEnvName(mode));
 	return {
 		args,
@@ -483,7 +497,8 @@ async function runWranglerDeploy(root, options, execute = spawn) {
 }
 async function runCfDeploy(root, options, execute = spawn) {
 	const { args, mode } = buildCfDeployArgs(options);
-	console.log(mode ? `\n  Deploying Build Output in mode: ${mode}...` : "\n  Deploying Build Output...");
+	const isPreview = options.target?.type === "preview";
+	console.log(mode ? `\n  Deploying ${isPreview ? "Preview " : ""}Build Output in mode: ${mode}...` : "\n  Deploying Build Output...");
 	const child = execute(process.execPath, [resolveCfBin(root), ...args], {
 		cwd: root,
 		stdio: [
@@ -494,9 +509,11 @@ async function runCfDeploy(root, options, execute = spawn) {
 		shell: false
 	});
 	let output = "";
+	let stdout = "";
 	child.stdout?.on("data", (chunk) => {
 		const text = chunk.toString();
 		output += text;
+		stdout += text;
 		process.stdout.write(text);
 	});
 	child.stderr?.on("data", (chunk) => {
@@ -508,11 +525,27 @@ async function runCfDeploy(root, options, execute = spawn) {
 		child.once("error", reject);
 		child.once("close", (code, signal) => {
 			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`cf deploy failed with ${signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`}.`));
+			else reject(/* @__PURE__ */ new Error(`cf ${isPreview ? "previews deploy" : "deploy"} failed with ${signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`}.`));
 		});
 	});
+	if (isPreview) return parseCfPreviewUrl(stdout) ?? parseWorkerDeploymentUrl(output) ?? "(Preview URL not detected in cf output)";
 	return parseWorkerDeploymentUrl(output) ?? "(URL not detected in cf output)";
 }
+/** `cf previews deploy` prints a JSON result; prefer the named Preview URL over the deployment URL. */
+function parseCfPreviewUrl(stdout) {
+	const text = stripVTControlCharacters(stdout);
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start === -1 || end < start) return null;
+	let result;
+	try {
+		result = JSON.parse(text.slice(start, end + 1));
+	} catch {
+		return null;
+	}
+	for (const urls of [result.preview_urls, result.deployment_urls]) if (Array.isArray(urls) && typeof urls[0] === "string") return urls[0];
+	return null;
+}
 function hasCdnWarmRequests(plan) {
 	return plan.paths.length + (plan.pagesDataPaths?.length ?? 0) + (plan.routeHandlerPaths?.length ?? 0) + plan.rscPaths.length + plan.loadingShellPaths.length > 0;
 }
@@ -1131,13 +1164,30 @@ function withPromotedVersionWarmupNote(error) {
 	const message = error instanceof Error ? error.message : String(error);
 	return new Error(`${message} The uploaded version is already promoted to 100% and its Worker triggers/routes were updated; rerun deploy to retry cache warming or create a deployment for the previous version.`, { cause: error });
 }
+/** Worker Previews skip production-only steps, so reject options that would otherwise be ignored. */
+function assertPreviewDeployOptions(options) {
+	const unsupported = Object.entries({
+		preview: options.preview,
+		name: options.name !== void 0,
+		config: options.config !== void 0,
+		warmCdnCache: options.warmCdnCache,
+		warmCdnTarget: options.warmCdnTarget !== void 0,
+		warmCdnCertify: options.warmCdnCertify,
+		warmCdnPromote: options.warmCdnPromote === false,
+		experimentalTPR: options.experimentalTPR
+	}).filter(([, isSet]) => isSet).map(([option]) => option);
+	if (unsupported.length > 0) throw new Error(`Worker Preview deployments do not support: ${unsupported.join(", ")}.`);
+}
 async function deploy(options) {
+	const isPreview = options.target?.type === "preview";
+	if (isPreview) assertPreviewDeployOptions(options);
 	if (options.warmCdnTarget !== void 0 && !options.warmCdnCache && !options.experimentalTPR) throw new Error("--warm-cache-target requires --warm-cache or --traffic-aware-warm-cache.");
 	const warmCdnTarget = options.warmCdnTarget === void 0 ? void 0 : validateCdnWarmTarget(options.warmCdnTarget);
 	const deployEnv = options.env || (options.preview ? "preview" : void 0);
 	if (deployEnv) validateWranglerEnvName(deployEnv);
 	const root = path.resolve(options.root);
 	const deploymentTool = resolveDeploymentTool(root);
+	if (isPreview && deploymentTool !== "cf") throw new Error("Worker Previews require a cloudflare.config.ts project and the cf CLI.");
 	if (deploymentTool === "cf" && options.name) throw new Error("--name is not supported for cloudflare.config.ts projects. Set `name` in cloudflare.config.ts instead.");
 	const viteMode = resolveViteBuildMode(deploymentTool, deployEnv);
 	const wranglerFallbackEnv = deploymentTool === "cf" ? void 0 : deployEnv;
@@ -1145,7 +1195,9 @@ async function deploy(options) {
 		root,
 		mode: viteMode
 	});
-	console.log("\n  vinext-cloudflare deploy\n");
+	const cloudflareEnv = isPreview ? void 0 : deployEnv;
+	const withBuildContext = (fn) => withCloudflareEnv(cloudflareEnv, () => isPreview ? withCloudflarePreviewBuild(fn) : fn());
+	console.log(isPreview ? "\n  vinext-cloudflare previews deploy\n" : "\n  vinext-cloudflare deploy\n");
 	const info = detectProject(root);
 	if (!info.isAppRouter && !info.isPagesRouter) {
 		console.error("  Error: No app/ or pages/ directory found.");
@@ -1172,9 +1224,17 @@ async function deploy(options) {
 		console.log("\n  Dry run complete. No build or deploy performed.\n");
 		return;
 	}
-	const viteConfigMetadata = await withCloudflareEnv(deployEnv, () => loadDeployViteConfigMetadata(info.root, viteMode));
+	if (isPreview && options.skipBuild) {
+		console.log("\n  Skipping build (--skip-build)");
+		printDeployUrl("Preview URL", await runCfDeploy(root, {
+			env: viteMode,
+			target: options.target
+		}));
+		return;
+	}
+	const viteConfigMetadata = await withBuildContext(() => loadDeployViteConfigMetadata(info.root, viteMode));
 	const cdnAdapterConfig = resolveCdnAdapterConfig(viteConfigMetadata.cacheConfig);
-	const nextConfig = await withCloudflareEnv(deployEnv, async () => {
+	const nextConfig = await withBuildContext(async () => {
 		const inlineNextConfig = viteConfigMetadata.nextConfig;
 		const rawNextConfig = inlineNextConfig ? await resolveNextConfigInput(inlineNextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(info.root, PHASE_PRODUCTION_BUILD);
 		return resolveNextConfig(rawNextConfig, info.root);
@@ -1195,10 +1255,10 @@ async function deploy(options) {
 	const shouldEmitPrerenderPathManifest = !options.skipBuild && shouldPrerenderLocally;
 	if (prerenderDecision && !shouldPrerenderLocally) {
 		const trigger = prerenderDecision.reason === "flag" ? "--prerender-all" : "vinext prerender config";
-		const replacement = options.warmCdnCache ? "Routes will be rendered and warmed through the staged Worker instead." : "Use --warm-cache to render and warm routes through the deployed Worker instead.";
+		const replacement = isPreview ? "Preview deployments render these routes on request." : options.warmCdnCache ? "Routes will be rendered and warmed through the staged Worker instead." : "Use --warm-cache to render and warm routes through the deployed Worker instead.";
 		console.warn(`\n  Warning: ${trigger} is ignored by Cloudflare deploy. ${replacement}`);
 	}
-	if (!options.skipBuild) await runBuild(info, deployEnv, viteMode);
+	if (!options.skipBuild) await withBuildContext(() => runBuild(info, cloudflareEnv, viteMode));
 	else console.log("\n  Skipping build (--skip-build)");
 	const prerenderOutputDirs = resolvePrerenderOutputDirs(info.root, deploymentTool, viteConfigMetadata.routeRootConfig);
 	const canWarmTpr = options.experimentalTPR && !shouldPrerenderLocally && hasBuildIdentityHeader;
@@ -1328,7 +1388,6 @@ async function deploy(options) {
 				};
 				return createPrerenderWarmPlan(root, discovery, {
 					includeCanonicalRsc: hasCanonicalRscWarmup,
-					includeFallbackShells: options.warmCdnIncludeFallbacks,
 					strict: options.warmCdnCertify === true || !options.dangerouslyPromoteOnCdnWarmError
 				});
 			},
@@ -1357,15 +1416,21 @@ async function deploy(options) {
 	}
 	if (url === void 0) {
 		if (deploymentTool === "cf" && options.warmCdnPromote === false) url = runCfVersionUpload(root, wranglerOptions).previewUrl ?? "(Preview URL not detected in cf output)";
-		else if (deploymentTool === "cf") url = await runCfDeploy(root, wranglerOptions);
+		else if (deploymentTool === "cf") url = await runCfDeploy(root, {
+			...wranglerOptions,
+			target: options.target
+		});
 		else url = await runWranglerDeploy(root, {
 			...wranglerOptions,
 			promote: options.warmCdnPromote
 		});
 	}
+	printDeployUrl(isPreview ? "Preview URL" : options.warmCdnPromote === false ? "Version URL" : "Deployed to", url);
+}
+function printDeployUrl(label, url) {
 	console.log("\n  ─────────────────────────────────────────");
-	console.log(`  ${options.warmCdnPromote === false ? "Version URL" : "Deployed to"}: ${url}`);
+	console.log(`  ${label}: ${url}`);
 	console.log("  ─────────────────────────────────────────\n");
 }
 //#endregion
-export { DEFAULT_CDN_WARM_PROMOTION_DELAY_MS, buildCfDeployArgs, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, isCfCliInstalled, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveCfBin, resolveDeploymentControlPlaneOptions, resolveDeploymentTool, resolvePrerenderOutputDirs, resolveViteBuildMode, resolveWorkerNameForVersionOverride, resolveWranglerBin, runCfDeploy, runWranglerDeploy, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv };
+export { DEFAULT_CDN_WARM_PROMOTION_DELAY_MS, buildCfDeployArgs, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, isCfCliInstalled, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveCfBin, resolveDeploymentControlPlaneOptions, resolveDeploymentTool, resolvePrerenderOutputDirs, resolveViteBuildMode, resolveWorkerNameForVersionOverride, resolveWranglerBin, runCfDeploy, runWranglerDeploy, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv, withCloudflarePreviewBuild };

package/dist/previews-deploy.d.ts

@@ -0,0 +1,9 @@
+//#region src/previews-deploy.d.ts
+/** CLI options for `vinext-cloudflare previews deploy`. */
+export declare function parsePreviewsDeployArgs(args: string[]): {
+  help: boolean;
+  name: string | undefined;
+  mode: string | undefined;
+  skipBuild: boolean;
+};
+//#endregion

package/dist/previews-deploy.js

@@ -0,0 +1,43 @@
+import { parseArgs } from "node:util";
+//#region src/previews-deploy.ts
+function validatePreviewName(name) {
+	const trimmed = name.trim();
+	if (!trimmed) throw new Error("Preview name must not be empty.");
+	if (trimmed.includes("\0")) throw new Error("Preview names cannot contain null bytes.");
+	if (trimmed.startsWith("-")) throw new Error("Preview name must not start with '-'.");
+	return trimmed;
+}
+function validateMode(mode) {
+	const trimmed = mode.trim();
+	if (!trimmed) throw new Error("--mode requires a non-empty value.");
+	return trimmed;
+}
+/** CLI options for `vinext-cloudflare previews deploy`. */
+function parsePreviewsDeployArgs(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		allowPositionals: true,
+		strict: true,
+		options: {
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			},
+			mode: { type: "string" },
+			"skip-build": {
+				type: "boolean",
+				default: false
+			}
+		}
+	});
+	if (positionals.length > 1) throw new Error("Expected at most one Preview name: previews deploy [preview-name].");
+	return {
+		help: values.help,
+		name: positionals[0] === void 0 ? void 0 : validatePreviewName(positionals[0]),
+		mode: values.mode === void 0 ? void 0 : validateMode(values.mode),
+		skipBuild: values["skip-build"]
+	};
+}
+//#endregion
+export { parsePreviewsDeployArgs };

package/dist/worker-deployment-url.d.ts

@@ -3,7 +3,9 @@ export declare function parseWorkerDeploymentUrl(output: string): string | null;
 /**
  * Parse the concrete hostname that Wrangler reports after applying Worker
  * triggers. Catch-all routes are valid warmup targets even though they are not
- * canonical deployment URLs for general CLI reporting.
+ * canonical deployment URLs for general CLI reporting. Warmup requests carry the
+ * prerender secret, so an `http://`-only route (which Cloudflare does not match
+ * for HTTPS requests) is never used as a target.
  */
 export declare function parseCdnWarmupDeploymentUrl(output: string): string | null;
 //#endregion

package/dist/worker-deployment-url.js

@@ -6,7 +6,9 @@ function parseWorkerDeploymentUrl(output) {
 /**
 * Parse the concrete hostname that Wrangler reports after applying Worker
 * triggers. Catch-all routes are valid warmup targets even though they are not
-* canonical deployment URLs for general CLI reporting.
+* canonical deployment URLs for general CLI reporting. Warmup requests carry the
+* prerender secret, so an `http://`-only route (which Cloudflare does not match
+* for HTTPS requests) is never used as a target.
 */
 function parseCdnWarmupDeploymentUrl(output) {
 	return parseCustomDomainUrl(output) ?? parseCatchAllWorkerRouteOrigin(output) ?? parseWorkersDevUrl(output);
@@ -17,7 +19,7 @@ function parseCatchAllWorkerRouteOrigin(output) {
 		if (!route || !route.endsWith("/*")) continue;
 		try {
 			const url = new URL(route.includes("://") ? route : `https://${route}`);
-			if (url.protocol !== "https:" && url.protocol !== "http:" || url.hostname.includes("*") || url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/*" || url.search !== "" || url.hash !== "") continue;
+			if (url.protocol !== "https:" || url.hostname.includes("*") || url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/*" || url.search !== "" || url.hash !== "") continue;
 			return url.origin;
 		} catch {
 			continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vinext/cloudflare",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Cloudflare cache and image adapters for vinext.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -48,7 +48,7 @@
     }
   },
   "dependencies": {
-    "@cloudflare/workers-response-store": "1.1.0"
+    "@cloudflare/workers-response-store": "1.1.2"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",
@@ -57,12 +57,12 @@
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
     "vite-plus": "1.1.0",
     "vitest": "5.0.3",
-    "vinext": "1.1.0"
+    "vinext": "1.3.0"
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "*",
     "cf": "*",
-    "vinext": "^1.1.0"
+    "vinext": "^1.3.0"
   },
   "peerDependenciesMeta": {
     "@cloudflare/vite-plugin": {