vinext 0.0.54 → 0.1.0

package/dist/config/tsconfig-paths.js

@@ -1,3 +1,4 @@
+import { isUnknownRecord } from "../utils/record.js";
 import { parseStaticObjectLiteral } from "../plugins/fonts.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -7,13 +8,15 @@ import path from "node:path";
 * tsconfig.json `compilerOptions.paths` loader.
 *
 * Used to make tsconfig path aliases (e.g. `@/foo` mapping to `./src/foo`)
-* available when vinext loads `next.config.ts` through Vite's `runnerImport`.
+* and `baseUrl` bare imports available when vinext loads `next.config.ts`
+* through Vite's `runnerImport`.
 *
 * Next.js's own `next.config.ts` loader (packages/next/src/build/next-config-ts/
-* transpile-config.ts) reads `compilerOptions.paths` from the project's
-* `tsconfig.json` and passes them to SWC so that imports like
-* `import { foo } from '@/foo'` resolve at config load time. We do the same
-* here, but as Vite `resolve.alias` entries.
+* transpile-config.ts) reads `compilerOptions.paths` and
+* `compilerOptions.baseUrl` from the project's `tsconfig.json` and passes them
+* to SWC so that imports like
+* `import { foo } from '@/foo'` and `import { bar } from 'bar'` resolve at
+* config load time. We do the same here with Vite resolver settings.
 *
 * The implementation is intentionally minimal:
 *   - Static JSON-style parse of tsconfig.json (handles trailing commas /
@@ -26,9 +29,6 @@ import path from "node:path";
 *     `runnerImport`'s inline environment (which has its own root).
 */
 const TSCONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
-function isRecord(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
 function resolveTsconfigPathCandidate(candidate) {
 	const candidates = candidate.endsWith(".json") ? [candidate] : [
 		candidate,
@@ -70,48 +70,75 @@ function materializeAliases(pathsConfig, baseUrl) {
 	}
 	return aliases;
 }
-function loadAliasesFromTsconfigFile(configPath, seen) {
-	if (seen.has(configPath)) return {};
+function emptyResolution() {
+	return {
+		aliases: {},
+		baseUrl: null
+	};
+}
+function loadResolutionFromTsconfigFile(configPath, seen) {
+	if (seen.has(configPath)) return emptyResolution();
 	seen.add(configPath);
 	let parsed = null;
 	try {
 		parsed = parseStaticObjectLiteral(fs.readFileSync(configPath, "utf-8"));
 	} catch {
-		return {};
+		return emptyResolution();
 	}
-	if (!parsed) return {};
-	let aliases = {};
-	if (typeof parsed.extends === "string") {
-		const extendedPath = resolveTsconfigExtends(configPath, parsed.extends);
-		if (extendedPath) aliases = loadAliasesFromTsconfigFile(extendedPath, seen);
+	if (!parsed) return emptyResolution();
+	let resolution = emptyResolution();
+	const extendsList = typeof parsed.extends === "string" ? [parsed.extends] : [];
+	for (const extendsSpecifier of extendsList) {
+		const extendedPath = resolveTsconfigExtends(configPath, extendsSpecifier);
+		if (extendedPath) {
+			const parent = loadResolutionFromTsconfigFile(extendedPath, seen);
+			resolution = {
+				aliases: {
+					...resolution.aliases,
+					...parent.aliases
+				},
+				baseUrl: parent.baseUrl ?? resolution.baseUrl
+			};
+		}
 	}
-	const compilerOptions = isRecord(parsed.compilerOptions) ? parsed.compilerOptions : null;
-	const pathsConfig = compilerOptions && isRecord(compilerOptions.paths) ? compilerOptions.paths : null;
-	if (!pathsConfig) return aliases;
-	const baseUrl = compilerOptions && typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : ".";
-	const resolvedBaseUrl = path.resolve(path.dirname(configPath), baseUrl);
+	const compilerOptions = isUnknownRecord(parsed.compilerOptions) ? parsed.compilerOptions : null;
+	const baseUrl = (compilerOptions && typeof compilerOptions.baseUrl === "string" ? path.resolve(path.dirname(configPath), compilerOptions.baseUrl) : null) ?? resolution.baseUrl;
+	const pathsConfig = compilerOptions && isUnknownRecord(compilerOptions.paths) ? compilerOptions.paths : null;
+	if (!pathsConfig) return {
+		aliases: resolution.aliases,
+		baseUrl
+	};
+	const pathsBaseUrl = baseUrl ?? path.dirname(configPath);
 	return {
-		...aliases,
-		...materializeAliases(pathsConfig, resolvedBaseUrl)
+		aliases: {
+			...resolution.aliases,
+			...materializeAliases(pathsConfig, pathsBaseUrl)
+		},
+		baseUrl
 	};
 }
 /**
 * Read the project's tsconfig.json (or jsconfig.json) and return its
-* `compilerOptions.paths` as absolute-path Vite `resolve.alias` entries.
+* path-resolution settings as absolute paths.
 *
-* Returns an empty object if no config is found or no paths are configured.
+* Returns an empty resolution if no config is found or no relevant compiler
+* options are configured.
 * Errors during parsing are swallowed — this is a best-effort helper that
 * must not break config loading.
 */
-function loadTsconfigPathAliasesForRoot(projectRoot) {
+function loadTsconfigResolutionForRoot(projectRoot) {
 	for (const name of TSCONFIG_FILES) {
 		const candidate = path.join(projectRoot, name);
 		if (!fs.existsSync(candidate)) continue;
-		return loadAliasesFromTsconfigFile(candidate, /* @__PURE__ */ new Set());
+		return loadResolutionFromTsconfigFile(candidate, /* @__PURE__ */ new Set());
 	}
-	return {};
+	return emptyResolution();
+}
+/**
+* Back-compat helper for call sites that only need `compilerOptions.paths`.
+*/
+function loadTsconfigPathAliasesForRoot(projectRoot) {
+	return loadTsconfigResolutionForRoot(projectRoot).aliases;
 }
 //#endregion
-export { loadTsconfigPathAliasesForRoot };
-
-//# sourceMappingURL=tsconfig-paths.js.map
+export { loadTsconfigPathAliasesForRoot, loadTsconfigResolutionForRoot };

package/dist/deploy.d.ts

@@ -65,7 +65,7 @@ declare const renameCJSConfigs: typeof renameCJSConfigs$1;
 /** Generate wrangler.jsonc content */
 declare function generateWranglerConfig(info: ProjectInfo): string;
 /** Generate worker/index.ts for App Router */
-declare function generateAppRouterWorkerEntry(hasISR?: boolean): string;
+declare function generateAppRouterWorkerEntry(): string;
 /** Generate worker/index.ts for Pages Router */
 declare function generatePagesRouterWorkerEntry(): string;
 /** Generate vite.config.ts for App Router */
@@ -100,7 +100,53 @@ type GeneratedFile = {
  * virtual:vinext-rsc-entry").
  */
 declare function viteConfigHasCloudflarePlugin(root: string): boolean;
+/**
+ * Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
+ * `cdn` or `data` field of the `vinext({ cache })` option is given a value.
+ * This is a source-level check on those exact object fields, not a fuzzy scan
+ * for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
+ * an unreadable or absent config is treated as configured so a deploy is never
+ * blocked on a false negative.
+ */
+declare function viteConfigHasCacheAdapter(root: string): boolean;
+/**
+ * Detect whether an existing user-authored Worker entry wires up a cache
+ * backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
+ * / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
+ * declarative `vinext({ cache })` option, but older apps that scaffolded a KV
+ * cache handler into their Worker entry must keep working — so a deploy should
+ * not be blocked when the Worker entry already configures a backend.
+ *
+ * This is a heuristic text scan (it doesn't execute the entry), mirroring
+ * {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
+ * treated as configured so a deploy is never blocked on a false negative. A
+ * missing Worker entry returns false (nothing to inspect — defer to other
+ * checks).
+ */
+declare function workerEntryHasCacheHandler(root: string): boolean;
+/**
+ * Build the error thrown when an ISR/cached app is deployed without a cache
+ * adapter configured in the Vite config. Production deployments need a
+ * persistent cache backend; vinext no longer scaffolds one into the Worker
+ * entry, so it must be declared via `vinext({ cache })`.
+ */
+declare function formatMissingCacheAdapterError(options: {
+  configFile?: string;
+}): string;
 declare function getFilesToGenerate(info: ProjectInfo): GeneratedFile[];
+/**
+ * Run a function with `process.env.CLOUDFLARE_ENV` set to the given value,
+ * restoring the previous state (whether set or absent) after the function
+ * resolves or throws.
+ *
+ * The `@cloudflare/vite-plugin` reads `CLOUDFLARE_ENV` from `process.env` to
+ * drive the multi-environment merge applied to the emitted `wrangler.json`.
+ * Without this propagation the `--env <name>` CLI flag is silently ignored at
+ * build time and the top-level config is emitted regardless. See issue #1210.
+ *
+ * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
+ */
+declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
 type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
@@ -122,5 +168,4 @@ declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview"
 declare function resolveWranglerBin(root: string, platform?: NodeJS.Platform): string;
 declare function deploy(options: DeployOptions): Promise<void>;
 //#endregion
-export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCloudflarePlugin };
-//# sourceMappingURL=deploy.d.ts.map
+export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };

package/dist/deploy.js

@@ -259,28 +259,29 @@ function generateWranglerConfig(info) {
 		images: { binding: "IMAGES" }
 	};
 	if (info.hasISR) config.kv_namespaces = [{
-		binding: "VINEXT_CACHE",
+		binding: "VINEXT_KV_CACHE",
 		id: "<your-kv-namespace-id>"
 	}];
 	return JSON.stringify(config, null, 2) + "\n";
 }
 /** Generate worker/index.ts for App Router */
-function generateAppRouterWorkerEntry(hasISR = false) {
+function generateAppRouterWorkerEntry() {
 	return `/**
  * Cloudflare Worker entry point — auto-generated by vinext deploy.
  * Edit freely or delete to regenerate on next deploy.
  *
+ * Cache backends (data + page ISR) are configured declaratively in
+ * vite.config via the vinext({ cache }) option.
+ *
  * For apps without image optimization, you can use vinext/server/app-router-entry
  * directly in wrangler.jsonc: "main": "vinext/server/app-router-entry"
  */
 import { handleImageOptimization, DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath } from "vinext/server/image-optimization";
 import type { ImageConfig } from "vinext/server/image-optimization";
 import handler from "vinext/server/app-router-entry";
-${hasISR ? `import { KVCacheHandler } from "vinext/cloudflare";
-import { setCacheHandler } from "vinext/shims/cache";
-` : ""}
+
 interface Env {
-  ASSETS: Fetcher;${hasISR ? `\n  VINEXT_CACHE: KVNamespace;` : ""}
+  ASSETS: Fetcher;
   IMAGES: {
     input(stream: ReadableStream): {
       transform(options: Record<string, unknown>): {
@@ -303,11 +304,7 @@ interface ExecutionContext {
 
 export default {
   async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-${hasISR ? `    // Wire up KV-backed ISR cache. The vinext RSC entry automatically
-    // registers ctx in ALS so background KV puts use waitUntil — without
-    // this every request would return MISS.
-    setCacheHandler(new KVCacheHandler(env.VINEXT_CACHE));
-` : ""}    const url = new URL(request.url);
+    const url = new URL(request.url);
 
     // Image optimization via Cloudflare Images binding.
     // The parseImageParams validation inside handleImageOptimization
@@ -355,13 +352,17 @@ import {
   isOpenRedirectShaped,
   normalizeTrailingSlash,
 } from "vinext/server/request-pipeline";
+import { mergeHeaders } from "vinext/server/worker-utils";
 import { notFoundStaticAssetResponse } from "vinext/server/http-error-responses";
 import { assetPrefixPathname, isNextStaticPath } from "vinext/utils/asset-prefix";
+import { hasBasePath, stripBasePath } from "vinext/utils/base-path";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "vinext/server/pages-i18n";
 import { mergeRewriteQuery } from "vinext/utils/query";
 
 // @ts-expect-error -- virtual module resolved by vinext at build time
 import { renderPage, handleApiRoute, runMiddleware, vinextConfig, matchPageRoute } from "virtual:vinext-server-entry";
+// @ts-expect-error -- virtual module resolved by vinext at build time
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 
 interface Env {
   ASSETS: Fetcher;
@@ -394,18 +395,10 @@ const imageConfig: ImageConfig | undefined = vinextConfig?.images ? {
   contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy,
 } : undefined;
 
-function hasBasePath(pathname: string, basePath: string): boolean {
-  if (!basePath) return false;
-  return pathname === basePath || pathname.startsWith(basePath + "/");
-}
-
-function stripBasePath(pathname: string, basePath: string): string {
-  if (!hasBasePath(pathname, basePath)) return pathname;
-  return pathname.slice(basePath.length) || "/";
-}
-
 export default {
   async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    // Pass the Worker \`env\` so binding-backed adapters (e.g. KV) resolve.
+    registerConfiguredCacheAdapters(env);
     try {
       const url = new URL(request.url);
       let pathname = url.pathname;
@@ -763,90 +756,6 @@ export default {
   },
 };
 
-/**
- * Merge middleware/config headers into a response.
- * Response headers take precedence over middleware headers for all headers
- * except Set-Cookie, which is additive (both middleware and response cookies
- * are preserved). Matches the behavior in prod-server.ts. Uses getSetCookie()
- * to preserve multiple Set-Cookie values. Keep this in sync with
- * prod-server.ts and server/worker-utils.ts.
- */
-function mergeHeaders(
-  response: Response,
-  extraHeaders: Record<string, string | string[]>,
-  statusOverride?: number,
-): Response {
-  const NO_BODY_RESPONSE_STATUSES = new Set([204, 205, 304]);
-  function isVinextStreamedHtmlResponse(response: Response): boolean {
-    return response.__vinextStreamedHtmlResponse === true;
-  }
-  function isContentLengthHeader(name: string): boolean {
-    return name.toLowerCase() === "content-length";
-  }
-  function cancelResponseBody(response: Response): void {
-    const body = response.body;
-    if (!body || body.locked) return;
-    void body.cancel().catch(() => {
-      /* ignore cancellation failures on discarded bodies */
-    });
-  }
-
-  const status = statusOverride ?? response.status;
-  const merged = new Headers();
-  // Middleware/config headers go in first (lower precedence)
-  for (const [k, v] of Object.entries(extraHeaders)) {
-    if (isContentLengthHeader(k)) continue;
-    if (Array.isArray(v)) {
-      for (const item of v) merged.append(k, item);
-    } else {
-      merged.set(k, v);
-    }
-  }
-  // Response headers overlay them (higher precedence), except Set-Cookie
-  // which is additive (both middleware and response cookies should be sent).
-  response.headers.forEach((v, k) => {
-    if (k === "set-cookie") return;
-    merged.set(k, v);
-  });
-  const responseCookies = response.headers.getSetCookie?.() ?? [];
-  for (const cookie of responseCookies) merged.append("set-cookie", cookie);
-
-  const shouldDropBody = NO_BODY_RESPONSE_STATUSES.has(status);
-  const shouldStripStreamLength =
-    isVinextStreamedHtmlResponse(response) && merged.has("content-length");
-
-  if (
-    !Object.keys(extraHeaders).some((key) => !isContentLengthHeader(key)) &&
-    statusOverride === undefined &&
-    !shouldDropBody &&
-    !shouldStripStreamLength
-  ) {
-    return response;
-  }
-
-  if (shouldDropBody) {
-    cancelResponseBody(response);
-    merged.delete("content-encoding");
-    merged.delete("content-length");
-    merged.delete("content-type");
-    merged.delete("transfer-encoding");
-    return new Response(null, {
-      status,
-      statusText: status === response.status ? response.statusText : undefined,
-      headers: merged,
-    });
-  }
-
-  if (shouldStripStreamLength) {
-    merged.delete("content-length");
-  }
-
-  return new Response(response.body, {
-    status,
-    statusText: status === response.status ? response.statusText : undefined,
-    headers: merged,
-  });
-}
 `;
 }
 /** Generate vite.config.ts for App Router */
@@ -980,6 +889,101 @@ function viteConfigHasCloudflarePlugin(root) {
 	}
 	return false;
 }
+/**
+* Extract the object-literal text of the `cache:` key (the `{ ... }` passed as
+* `vinext({ cache })`) from a Vite config source, via brace matching. Returns
+* null if there is no `cache:` object literal.
+*/
+function extractCacheBlock(content) {
+	const m = /\bcache\s*:\s*\{/.exec(content);
+	if (!m) return null;
+	const open = m.index + m[0].length - 1;
+	let depth = 0;
+	for (let i = open; i < content.length; i++) {
+		const ch = content[i];
+		if (ch === "{") depth++;
+		else if (ch === "}" && --depth === 0) return content.slice(open, i + 1);
+	}
+	return null;
+}
+/**
+* Whether a `cdn` / `data` field inside the cache object is assigned a real
+* value (not absent, `undefined`, or `null`). Reads the value up to the next
+* comma / closing brace / newline, which is enough to tell an assignment like
+* `data: kvDataAdapter()` from `data: undefined`.
+*/
+function cacheFieldAssigned(cacheBlock, field) {
+	const m = new RegExp(`\\b${field}\\s*:\\s*([^,}\\n]+)`).exec(cacheBlock);
+	if (!m) return false;
+	const value = m[1].trim();
+	return value.length > 0 && value !== "undefined" && value !== "null";
+}
+/**
+* Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
+* `cdn` or `data` field of the `vinext({ cache })` option is given a value.
+* This is a source-level check on those exact object fields, not a fuzzy scan
+* for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
+* an unreadable or absent config is treated as configured so a deploy is never
+* blocked on a false negative.
+*/
+function viteConfigHasCacheAdapter(root) {
+	const candidates = [
+		path.join(root, "vite.config.ts"),
+		path.join(root, "vite.config.js"),
+		path.join(root, "vite.config.mjs")
+	];
+	for (const candidate of candidates) {
+		if (!fs.existsSync(candidate)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(candidate, "utf-8");
+		} catch {
+			return true;
+		}
+		const block = extractCacheBlock(content);
+		if (!block) return false;
+		return cacheFieldAssigned(block, "cdn") || cacheFieldAssigned(block, "data");
+	}
+	return true;
+}
+/**
+* Detect whether an existing user-authored Worker entry wires up a cache
+* backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
+* / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
+* declarative `vinext({ cache })` option, but older apps that scaffolded a KV
+* cache handler into their Worker entry must keep working — so a deploy should
+* not be blocked when the Worker entry already configures a backend.
+*
+* This is a heuristic text scan (it doesn't execute the entry), mirroring
+* {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
+* treated as configured so a deploy is never blocked on a false negative. A
+* missing Worker entry returns false (nothing to inspect — defer to other
+* checks).
+*/
+function workerEntryHasCacheHandler(root) {
+	const candidates = [path.join(root, "worker", "index.ts"), path.join(root, "worker", "index.js")];
+	for (const candidate of candidates) {
+		if (!fs.existsSync(candidate)) continue;
+		let content;
+		try {
+			content = fs.readFileSync(candidate, "utf-8");
+		} catch {
+			return true;
+		}
+		return /\b(?:setCacheHandler|setDataCacheHandler|setCdnCacheAdapter)\s*\(/.test(content);
+	}
+	return false;
+}
+/**
+* Build the error thrown when an ISR/cached app is deployed without a cache
+* adapter configured in the Vite config. Production deployments need a
+* persistent cache backend; vinext no longer scaffolds one into the Worker
+* entry, so it must be declared via `vinext({ cache })`.
+*/
+function formatMissingCacheAdapterError(options) {
+	const configRef = options.configFile ? options.configFile : "your Vite config";
+	return `[vinext] This app uses ISR / caching but no cache adapter is configured in ${configRef}.\n\n  Production deployments need a persistent cache backend. Declare one on the\n  vinext() plugin in ${configRef}:\n\n    import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";\n\n    export default defineConfig({\n      plugins: [\n        vinext({\n          cache: {\n            data: kvDataAdapter(), // KV-backed data cache (binding: VINEXT_KV_CACHE)\n          },\n        }),\n        cloudflare(),\n      ],\n    });\n\n  The VINEXT_KV_CACHE namespace binding is added to wrangler.jsonc for you.\n  Create the namespace with:\n\n    npx wrangler kv namespace create VINEXT_KV_CACHE`;
+}
 function getFilesToGenerate(info) {
 	const files = [];
 	if (!info.hasWranglerConfig) files.push({
@@ -988,7 +992,7 @@ function getFilesToGenerate(info) {
 		description: "wrangler.jsonc"
 	});
 	if (!info.hasWorkerEntry) {
-		const workerContent = info.isAppRouter ? generateAppRouterWorkerEntry(info.hasISR) : generatePagesRouterWorkerEntry();
+		const workerContent = info.isAppRouter ? generateAppRouterWorkerEntry() : generatePagesRouterWorkerEntry();
 		files.push({
 			path: path.join(info.root, "worker", "index.ts"),
 			content: workerContent,
@@ -1013,7 +1017,31 @@ function writeGeneratedFiles(files) {
 		console.log(`  Created ${file.description}`);
 	}
 }
-async function runBuild(info) {
+/**
+* Run a function with `process.env.CLOUDFLARE_ENV` set to the given value,
+* restoring the previous state (whether set or absent) after the function
+* resolves or throws.
+*
+* The `@cloudflare/vite-plugin` reads `CLOUDFLARE_ENV` from `process.env` to
+* drive the multi-environment merge applied to the emitted `wrangler.json`.
+* Without this propagation the `--env <name>` CLI flag is silently ignored at
+* build time and the top-level config is emitted regardless. See issue #1210.
+*
+* Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
+*/
+async function withCloudflareEnv(env, fn) {
+	if (env === void 0 || env === "") return fn();
+	const hadPrev = "CLOUDFLARE_ENV" in process.env;
+	const prev = process.env.CLOUDFLARE_ENV;
+	process.env.CLOUDFLARE_ENV = env;
+	try {
+		return await fn();
+	} finally {
+		if (hadPrev) process.env.CLOUDFLARE_ENV = prev;
+		else delete process.env.CLOUDFLARE_ENV;
+	}
+}
+async function runBuild(info, env) {
 	console.log("\n  Building for Cloudflare Workers...\n");
 	let vitePath;
 	try {
@@ -1022,7 +1050,9 @@ async function runBuild(info) {
 		vitePath = "vite";
 	}
 	const { createBuilder } = await (vitePath === "vite" ? import(vitePath) : import(pathToFileURL(vitePath).href));
-	await (await createBuilder({ root: info.root })).buildApp();
+	await withCloudflareEnv(env, async () => {
+		await (await createBuilder({ root: info.root })).buildApp();
+	});
 }
 function buildWranglerDeployArgs(options) {
 	const args = ["deploy"];
@@ -1127,11 +1157,12 @@ async function deploy(options) {
 		writeGeneratedFiles(filesToGenerate);
 	}
 	if (info.hasViteConfig && !viteConfigHasCloudflarePlugin(root)) throw new Error(formatMissingCloudflarePluginError({ isAppRouter: info.isAppRouter }));
+	if (info.hasISR && !viteConfigHasCacheAdapter(root) && !workerEntryHasCacheHandler(root)) throw new Error(formatMissingCacheAdapterError({}));
 	if (options.dryRun) {
 		console.log("\n  Dry run complete. Files generated but no build or deploy performed.\n");
 		return;
 	}
-	if (!options.skipBuild) await runBuild(info);
+	if (!options.skipBuild) await runBuild(info, options.env || (options.preview ? "preview" : void 0));
 	else console.log("\n  Skipping build (--skip-build)");
 	{
 		const nextConfig = await resolveNextConfig(await loadNextConfig(info.root), info.root);
@@ -1168,6 +1199,4 @@ async function deploy(options) {
 	console.log("  ─────────────────────────────────────────\n");
 }
 //#endregion
-export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCloudflarePlugin };
-
-//# sourceMappingURL=deploy.js.map
+export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };

package/dist/entries/app-browser-entry.d.ts

@@ -20,5 +20,4 @@ declare function isLinkPrefetchRoute(route: AppRoute): boolean;
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
 declare function toLinkPrefetchRoute(route: AppRoute): VinextLinkPrefetchRoute;
 //#endregion
-export { generateBrowserEntry, isLinkPrefetchRoute, toLinkPrefetchRoute };
-//# sourceMappingURL=app-browser-entry.d.ts.map
+export { generateBrowserEntry, isLinkPrefetchRoute, toLinkPrefetchRoute };

package/dist/entries/app-browser-entry.js

@@ -63,5 +63,3 @@ function buildMapExpression(map) {
 }
 //#endregion
 export { generateBrowserEntry, isLinkPrefetchRoute, toLinkPrefetchRoute };
-
-//# sourceMappingURL=app-browser-entry.js.map

package/dist/entries/app-rsc-entry.d.ts

@@ -1,5 +1,5 @@
-import { AppRoute } from "../routing/app-route-graph.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { AppRoute } from "../routing/app-route-graph.js";
 import { MetadataFileRoute } from "../server/metadata-routes.js";
 
 //#region src/entries/app-rsc-entry.d.ts
@@ -34,8 +34,10 @@ type AppRouterConfig = {
    * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
    */
   assetPrefix?: string; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
-  expireTime?: number; /** Inline app CSS into production HTML (from experimental.inlineCss). */
-  inlineCss?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
+  expireTime?: number; /** Maximum in-memory cache size in bytes. 0 disables the default memory cache. */
+  cacheMaxMemorySize?: number; /** Inline app CSS into production HTML (from experimental.inlineCss). */
+  inlineCss?: boolean; /** Enables Next.js Cache Components semantics for App Router document HTML. */
+  cacheComponents?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
   i18n?: NextI18nConfig | null;
   /**
    * Absolute path to `app/global-not-found.{tsx,ts,js,jsx}` when present.
@@ -67,5 +69,4 @@ type AppRouterConfig = {
  */
 declare function generateRscEntry(appDir: string, routes: AppRoute[], middlewarePath?: string | null, metadataRoutes?: MetadataFileRoute[], globalErrorPath?: string | null, basePath?: string, trailingSlash?: boolean, config?: AppRouterConfig, instrumentationPath?: string | null): string;
 //#endregion
-export { generateRscEntry };
-//# sourceMappingURL=app-rsc-entry.d.ts.map
+export { generateRscEntry };