vinext 0.1.2 → 0.1.4

package/dist/deploy.d.ts

@@ -1,4 +1,5 @@
 import { ensureESModule as ensureESModule$1, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
+import { execFileSync } from "node:child_process";
 
 //#region src/deploy.d.ts
 type DeployOptions = {
@@ -151,21 +152,39 @@ type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
 };
+declare function validateWranglerEnvName(env: string): string;
 declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env">): WranglerDeployArgs;
 /**
- * Resolve the wrangler executable in node_modules.
+ * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
- * Walks up ancestor directories so the binary is found even when node_modules
- * is hoisted to the workspace root in a monorepo.
+ * Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
+ * shim and command shell that package managers create on Windows.
+ */
+declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
+  file: string;
+  args: string[];
+};
+declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env">, nodeExecutable?: string): {
+  file: string;
+  args: string[];
+  env: string | undefined;
+};
+declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof execFileSync): string;
+/**
+ * Read the prerender manifest and inject pregenerated concrete paths into the
+ * App Router Worker bundle so the PPR fallback-shell guard is populated at
+ * module init time without calling `seedMemoryCacheFromPrerender`.
+ *
+ * The paths are injected as `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`
+ * wrapped in replaceable marker comments, and consumed by
+ * `initPregeneratedPathsFromGlobals` in the generated RSC entry.
  *
- * On Windows, `node_modules/.bin/` contains both a Unix shebang script (no
- * extension) and a `.CMD` shim. Node's `execFileSync` uses CreateProcess(),
- * which only resolves PATHEXT extensions (`.cmd`, `.exe`, ...) — spawning the
- * bare-name shebang file fails with ENOENT even though the file exists. So on
- * Windows we prefer the `.CMD` shim and only fall back to the bare name for a
- * clearer error message if neither is present.
+ * Idempotent: repeated calls strip the previous injection before writing the
+ * new one. If the manifest is missing, corrupt, or empty, any prior injection
+ * is stripped and nothing new is written — failing closed to empty.
  */
-declare function resolveWranglerBin(root: string, platform?: NodeJS.Platform): string;
+declare function injectPregeneratedConcretePaths(root: string): void;
 declare function deploy(options: DeployOptions): Promise<void>;
 //#endregion
-export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };
+export { buildNodeCliInvocation, buildWranglerDeployArgs, buildWranglerInvocation, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, injectPregeneratedConcretePaths, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, runWranglerDeploy, validateWranglerEnvName, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };

package/dist/deploy.js

@@ -1,8 +1,10 @@
 import { detectPackageManager as detectPackageManager$1, ensureESModule as ensureESModule$1, findInNodeModules, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
 import { parsePositiveIntegerArg } from "./cli-args.js";
+import { escapeRegExp } from "./utils/regex.js";
 import { loadNextConfig, resolveNextConfig } from "./config/next-config.js";
 import { getReactUpgradeDeps } from "./init.js";
 import { runTPR } from "./cloudflare/tpr.js";
+import { buildPregeneratedConcretePathTable, readPrerenderManifest } from "./server/prerender-manifest.js";
 import { runPrerender } from "./build/run-prerender.js";
 import { loadDotenv } from "./config/dotenv.js";
 import { createRequire } from "node:module";
@@ -123,14 +125,33 @@ function detectProject(root) {
 	} catch {}
 	let projectName = path.basename(root);
 	if (pkg?.name && typeof pkg.name === "string") projectName = pkg.name.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-	const hasISR = detectISR(root, isAppRouter);
 	const hasTypeModule = pkg?.type === "module";
-	const hasMDX = detectMDX(root, isAppRouter, hasPages);
-	const hasCodeHike = "codehike" in {
+	let hasISR = false;
+	let hasMDX = detectMDXFromConfig(root);
+	if (isAppRouter) {
+		const appDir = resolveProjectDir(root, "app");
+		if (appDir) {
+			const found = scanTreeForDetection(appDir, {
+				isr: true,
+				mdx: !hasMDX
+			});
+			hasISR = found.isr;
+			hasMDX = hasMDX || found.mdx;
+		}
+	}
+	if (hasPages && !hasMDX) {
+		const pagesDir = resolveProjectDir(root, "pages");
+		if (pagesDir) hasMDX = scanTreeForDetection(pagesDir, {
+			isr: false,
+			mdx: true
+		}).mdx;
+	}
+	const allDeps = {
 		...pkg?.dependencies,
 		...pkg?.devDependencies
 	};
-	const nativeModulesToStub = detectNativeModules(root);
+	const hasCodeHike = "codehike" in allDeps;
+	const nativeModulesToStub = detectNativeModules(allDeps);
 	return {
 		root,
 		isAppRouter,
@@ -149,35 +170,69 @@ function detectProject(root) {
 		nativeModulesToStub
 	};
 }
-function detectISR(root, isAppRouter) {
-	if (!isAppRouter) return false;
-	try {
-		let appDir = path.join(root, "app");
-		if (!fs.existsSync(appDir)) appDir = path.join(root, "src", "app");
-		if (!fs.existsSync(appDir)) return false;
-		return scanDirForPattern(appDir, /export\s+const\s+revalidate\s*=/);
-	} catch {
-		return false;
-	}
+/** Matches `export const revalidate = …` (ISR opt-in) in App Router source. */
+const ISR_REVALIDATE_PATTERN = /export\s+const\s+revalidate\s*=/;
+/** Source extensions whose contents are scanned for the ISR pattern. */
+const ISR_SCANNABLE_EXTENSION = /\.(ts|tsx|js|jsx)$/;
+/**
+* Resolve a project subdirectory (`app`/`pages`), preferring the root-level
+* location and falling back to the `src/` variant. Returns null when neither
+* exists.
+*/
+function resolveProjectDir(root, name) {
+	const rootDir = path.join(root, name);
+	if (fs.existsSync(rootDir)) return rootDir;
+	const srcDir = path.join(root, "src", name);
+	if (fs.existsSync(srcDir)) return srcDir;
+	return null;
 }
-function scanDirForPattern(dir, pattern) {
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name);
-		if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-			if (scanDirForPattern(fullPath, pattern)) return true;
-		} else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) try {
-			const content = fs.readFileSync(fullPath, "utf-8");
-			if (pattern.test(content)) return true;
-		} catch {}
-	}
-	return false;
+/**
+* Recursively walk `dir` once, evaluating the requested detection predicates
+* per entry. Each flag short-circuits independently: an `.mdx` file sets `mdx`;
+* a scannable source file containing `export const revalidate` sets `isr`. The
+* walk stops as soon as every requested flag is satisfied, so callers that only
+* want one signal don't pay for the other.
+*
+* Replaces the previous pair of single-purpose recursive walkers
+* (`scanDirForPattern` + `scanDirForExtension`) that traversed the same tree
+* twice. Detection semantics are unchanged: same dirs skipped (dotfiles,
+* node_modules), same extension and content tests.
+*/
+function scanTreeForDetection(dir, want) {
+	const found = {
+		isr: false,
+		mdx: false
+	};
+	const walk = (current) => {
+		let entries;
+		try {
+			entries = fs.readdirSync(current, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if ((!want.isr || found.isr) && (!want.mdx || found.mdx)) return;
+			const fullPath = path.join(current, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+				walk(fullPath);
+			} else if (entry.isFile()) {
+				if (want.mdx && !found.mdx && entry.name.endsWith(".mdx")) found.mdx = true;
+				if (want.isr && !found.isr && ISR_SCANNABLE_EXTENSION.test(entry.name)) try {
+					if (ISR_REVALIDATE_PATTERN.test(fs.readFileSync(fullPath, "utf-8"))) found.isr = true;
+				} catch {}
+			}
+		}
+	};
+	walk(dir);
+	return found;
 }
 /**
-* Detect .mdx files in the project's app/ or pages/ directory,
-* or `pageExtensions` including "mdx" in next.config.
+* Detect MDX usage declared in next.config (`pageExtensions` including "mdx" or
+* an `@next/mdx` import). Filesystem `.mdx` detection is handled separately by
+* the shared app/pages tree walk in `detectProject`.
 */
-function detectMDX(root, isAppRouter, hasPages) {
+function detectMDXFromConfig(root) {
 	for (const f of [
 		"next.config.ts",
 		"next.config.mts",
@@ -191,26 +246,6 @@ function detectMDX(root, isAppRouter, hasPages) {
 			if (/pageExtensions.*mdx/i.test(content) || /@next\/mdx/.test(content)) return true;
 		} catch {}
 	}
-	const dirs = [];
-	if (isAppRouter) {
-		const appDir = fs.existsSync(path.join(root, "app")) ? path.join(root, "app") : path.join(root, "src", "app");
-		dirs.push(appDir);
-	}
-	if (hasPages) {
-		const pagesDir = fs.existsSync(path.join(root, "pages")) ? path.join(root, "pages") : path.join(root, "src", "pages");
-		dirs.push(pagesDir);
-	}
-	for (const dir of dirs) if (fs.existsSync(dir) && scanDirForExtension(dir, ".mdx")) return true;
-	return false;
-}
-function scanDirForExtension(dir, ext) {
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name);
-		if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-			if (scanDirForExtension(fullPath, ext)) return true;
-		} else if (entry.isFile() && entry.name.endsWith(ext)) return true;
-	}
 	return false;
 }
 /** Known native Node modules that can't run in Workers */
@@ -222,21 +257,12 @@ const NATIVE_MODULES_TO_STUB = [
 	"sharp"
 ];
 /**
-* Detect native Node modules in dependencies that need stubbing for Workers.
+* Detect native Node modules in the project's merged dependency map that need
+* stubbing for Workers. Accepts the already-built `allDeps` (dependencies +
+* devDependencies) so package.json is not re-read or re-parsed.
 */
-function detectNativeModules(root) {
-	const pkgPath = path.join(root, "package.json");
-	if (!fs.existsSync(pkgPath)) return [];
-	try {
-		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-		const allDeps = {
-			...pkg.dependencies,
-			...pkg.devDependencies
-		};
-		return NATIVE_MODULES_TO_STUB.filter((mod) => mod in allDeps);
-	} catch {
-		return [];
-	}
+function detectNativeModules(allDeps) {
+	return NATIVE_MODULES_TO_STUB.filter((mod) => mod in allDeps);
 }
 /** @see {@link _ensureESModule} */
 const ensureESModule = ensureESModule$1;
@@ -280,6 +306,17 @@ import { handleImageOptimization, DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isI
 import type { ImageConfig } from "vinext/server/image-optimization";
 import handler from "vinext/server/app-router-entry";
 
+const imageConfig: ImageConfig = {
+  deviceSizes: JSON.parse(
+    process.env.__VINEXT_IMAGE_DEVICE_SIZES ?? JSON.stringify(DEFAULT_DEVICE_SIZES),
+  ),
+  imageSizes: JSON.parse(
+    process.env.__VINEXT_IMAGE_SIZES ?? JSON.stringify(DEFAULT_IMAGE_SIZES),
+  ),
+  qualities: JSON.parse(process.env.__VINEXT_IMAGE_QUALITIES ?? "null") ?? undefined,
+  dangerouslyAllowSVG: process.env.__VINEXT_IMAGE_DANGEROUSLY_ALLOW_SVG === "true",
+};
+
 interface Env {
   ASSETS: Fetcher;
   IMAGES: {
@@ -310,14 +347,17 @@ export default {
     // The parseImageParams validation inside handleImageOptimization
     // normalizes backslashes and validates the origin hasn't changed.
     if (isImageOptimizationPath(url.pathname)) {
-      const allowedWidths = [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES];
+      const allowedWidths = [
+        ...(imageConfig.deviceSizes ?? DEFAULT_DEVICE_SIZES),
+        ...(imageConfig.imageSizes ?? DEFAULT_IMAGE_SIZES),
+      ];
       return handleImageOptimization(request, {
         fetchAsset: (path) => env.ASSETS.fetch(new Request(new URL(path, request.url))),
         transformImage: async (body, { width, format, quality }) => {
           const result = await env.IMAGES.input(body).transform(width > 0 ? { width } : {}).output({ format, quality });
           return result.response();
         },
-      }, allowedWidths);
+      }, allowedWidths, imageConfig);
     }
 
     // Delegate everything else to vinext, forwarding ctx so that
@@ -334,17 +374,17 @@ function generatePagesRouterWorkerEntry() {
  * Cloudflare Worker entry point -- auto-generated by vinext deploy.
  * Edit freely or delete to regenerate on next deploy.
  */
-import { runPagesRequest, wrapMiddlewareWithBasePath } from "vinext/server/pages-request-pipeline";
+import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "vinext/server/pages-request-pipeline";
 import type { PagesPipelineDeps } from "vinext/server/pages-request-pipeline";
 import { handleImageOptimization, DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath } from "vinext/server/image-optimization";
 import type { ImageConfig } from "vinext/server/image-optimization";
-import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "vinext/server/request-pipeline";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, isOpenRedirectShaped } from "vinext/server/request-pipeline";
 import { notFoundStaticAssetResponse } from "vinext/server/http-error-responses";
 import { assetPrefixPathname, isNextStaticPath } from "vinext/utils/asset-prefix";
 import { hasBasePath, stripBasePath } from "vinext/utils/base-path";
 
 // @ts-expect-error -- virtual module resolved by vinext at build time
-import { renderPage, handleApiRoute, runMiddleware, vinextConfig, matchPageRoute } from "virtual:vinext-server-entry";
+import { renderPage, handleApiRoute, runMiddleware, normalizeDataRequest, 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";
 
@@ -373,6 +413,7 @@ const configRedirects = vinextConfig?.redirects ?? [];
 const configRewrites = vinextConfig?.rewrites ?? { beforeFiles: [], afterFiles: [], fallback: [] };
 const configHeaders = vinextConfig?.headers ?? [];
 const imageConfig: ImageConfig | undefined = vinextConfig?.images ? {
+  qualities: vinextConfig.images.qualities,
   dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
   dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
   contentDispositionType: vinextConfig.images.contentDispositionType,
@@ -407,11 +448,6 @@ export default {
         return notFoundStaticAssetResponse();
       }
 
-      // Capture x-nextjs-data before filterInternalHeaders strips it -- the
-      // middleware redirect protocol needs to know whether the inbound request
-      // was a _next/data fetch to emit x-nextjs-redirect instead of a 3xx.
-      const isDataRequest = request.headers.get("x-nextjs-data") === "1";
-
       // Strip internal headers from inbound requests so they cannot be
       // forged to influence routing or impersonate internal state.
       // Request.headers is immutable in Workers, so build a clean copy.
@@ -430,15 +466,26 @@ export default {
         if (stripped !== pathname) {
           const strippedUrl = new URL(request.url);
           strippedUrl.pathname = stripped;
-          request = new Request(strippedUrl, request);
+          request = cloneRequestWithUrl(request, strippedUrl.toString());
           pathname = stripped;
         }
       }
 
+      const dataNorm = normalizeDataRequest(request);
+      if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
+      const isDataReq = dataNorm.isDataReq;
+      if (isDataReq) {
+        request = dataNorm.request;
+        pathname = dataNorm.normalizedPathname;
+      }
+
       // ── Image optimization via Cloudflare Images binding ──────────
       // Checked after basePath stripping so /<basePath>/_next/image works.
       if (isImageOptimizationPath(pathname)) {
-        const allowedWidths = [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES];
+        const allowedWidths = [
+          ...(vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES),
+          ...(vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES),
+        ];
         return handleImageOptimization(request, {
           fetchAsset: (path) => env.ASSETS.fetch(new Request(new URL(path, request.url))),
           transformImage: async (body, { width, format, quality }) => {
@@ -460,12 +507,8 @@ export default {
         configRewrites,
         configHeaders,
         hadBasePath,
-        // The worker adapter does not do _next/data URL normalization (no
-        // buildId available at request time). isDataReq is used by the pipeline
-        // only for renderPage options and shouldDeferErrorPageOnMiss -- false
-        // is correct here.
-        isDataReq: false,
-        isDataRequest,
+        isDataReq,
+        isDataRequest: isDataReq,
         ctx,
         matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
         // Pass the original (pre-basePath-stripping) URL to middleware so that
@@ -483,6 +526,14 @@ export default {
         handleApi: typeof handleApiRoute === "function"
           ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx)
           : null,
+        serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase) => {
+          return fetchWorkerFilesystemRoute(
+            request,
+            requestPathname,
+            phase,
+            (assetRequest) => env.ASSETS.fetch(assetRequest),
+          );
+        },
       };
 
       const result = await runPagesRequest(request, deps);
@@ -797,58 +848,97 @@ async function runBuild(info, env) {
 		await (await createBuilder({ root: info.root })).buildApp();
 	});
 }
+function validateWranglerEnvName(env) {
+	if (env.includes("\0")) throw new Error("Wrangler environment names cannot contain null bytes.");
+	return env;
+}
 function buildWranglerDeployArgs(options) {
 	const args = ["deploy"];
 	const env = options.env || (options.preview ? "preview" : void 0);
-	if (env) args.push("--env", env);
+	if (env) args.push("--env", validateWranglerEnvName(env));
 	return {
 		args,
 		env
 	};
 }
 /**
-* Resolve the wrangler executable in node_modules.
+* Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
 *
-* Walks up ancestor directories so the binary is found even when node_modules
-* is hoisted to the workspace root in a monorepo.
-*
-* On Windows, `node_modules/.bin/` contains both a Unix shebang script (no
-* extension) and a `.CMD` shim. Node's `execFileSync` uses CreateProcess(),
-* which only resolves PATHEXT extensions (`.cmd`, `.exe`, ...) — spawning the
-* bare-name shebang file fails with ENOENT even though the file exists. So on
-* Windows we prefer the `.CMD` shim and only fall back to the bare name for a
-* clearer error message if neither is present.
+* Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
+* shim and command shell that package managers create on Windows.
 */
-function resolveWranglerBin(root, platform = process.platform) {
-	const candidates = platform === "win32" ? [
-		".bin/wrangler.CMD",
-		".bin/wrangler.cmd",
-		".bin/wrangler"
-	] : [".bin/wrangler"];
-	for (const candidate of candidates) {
-		const found = findInNodeModules(root, candidate);
-		if (found) return found;
+function resolveWranglerBin(root, resolvePackageJson = (projectRoot) => {
+	try {
+		return createRequire(path.join(projectRoot, "package.json")).resolve("wrangler/package.json");
+	} catch {
+		return findInNodeModules(projectRoot, "wrangler/package.json");
 	}
-	return path.join(root, "node_modules", ...candidates[0].split("/"));
+}) {
+	const packageJsonPath = resolvePackageJson(root);
+	if (packageJsonPath) {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		const bin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.wrangler;
+		if (bin) return path.resolve(path.dirname(packageJsonPath), bin);
+	}
+	return path.join(root, "node_modules", "wrangler", "bin", "wrangler.js");
 }
-function runWranglerDeploy(root, options) {
+function buildNodeCliInvocation(scriptPath, args, nodeExecutable = process.execPath) {
+	return {
+		file: nodeExecutable,
+		args: [scriptPath, ...args]
+	};
+}
+function buildWranglerInvocation(root, options, nodeExecutable = process.execPath) {
 	const wranglerBin = resolveWranglerBin(root);
+	const { args, env } = buildWranglerDeployArgs(options);
+	return {
+		...buildNodeCliInvocation(wranglerBin, args, nodeExecutable),
+		env
+	};
+}
+function runWranglerDeploy(root, options, execute = execFileSync) {
 	const execOpts = {
 		cwd: root,
 		stdio: "pipe",
 		encoding: "utf-8",
-		shell: process.platform === "win32"
+		shell: false
 	};
-	const { args, env } = buildWranglerDeployArgs(options);
+	const { file, args, env } = buildWranglerInvocation(root, options);
 	if (env) console.log(`\n  Deploying to env: ${env}...`);
 	else console.log("\n  Deploying to production...");
-	const output = execFileSync(wranglerBin, args, execOpts);
+	const output = execute(file, args, execOpts);
 	const urlMatch = output.match(/https:\/\/[^\s]+\.workers\.dev[^\s]*/);
 	const deployedUrl = urlMatch ? urlMatch[0] : null;
 	if (output.trim()) for (const line of output.trim().split("\n")) console.log(`  ${line}`);
 	return deployedUrl ?? "(URL not detected in wrangler output)";
 }
+const VINEXT_PREGEN_START = "/* __VINEXT_PREGENERATED_CONCRETE_PATHS_START__ */";
+const VINEXT_PREGEN_END = "/* __VINEXT_PREGENERATED_CONCRETE_PATHS_END__ */";
+const VINEXT_PREGEN_RE = new RegExp(`${escapeRegExp(VINEXT_PREGEN_START)}[\\s\\S]*?${escapeRegExp(VINEXT_PREGEN_END)}\\n?`, "g");
+/**
+* Read the prerender manifest and inject pregenerated concrete paths into the
+* App Router Worker bundle so the PPR fallback-shell guard is populated at
+* module init time without calling `seedMemoryCacheFromPrerender`.
+*
+* The paths are injected as `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`
+* wrapped in replaceable marker comments, and consumed by
+* `initPregeneratedPathsFromGlobals` in the generated RSC entry.
+*
+* Idempotent: repeated calls strip the previous injection before writing the
+* new one. If the manifest is missing, corrupt, or empty, any prior injection
+* is stripped and nothing new is written — failing closed to empty.
+*/
+function injectPregeneratedConcretePaths(root) {
+	const workerEntry = path.resolve(root, "dist", "server", "index.js");
+	if (!fs.existsSync(workerEntry)) return;
+	let code = fs.readFileSync(workerEntry, "utf-8");
+	code = code.replace(VINEXT_PREGEN_RE, "");
+	const table = buildPregeneratedConcretePathTable(readPrerenderManifest(path.join(root, "dist", "server", "vinext-prerender.json")) ?? {});
+	if (table.length > 0) code = `${VINEXT_PREGEN_START}\nglobalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = ${JSON.stringify(table)};\n${VINEXT_PREGEN_END}\n` + code;
+	fs.writeFileSync(workerEntry, code);
+}
 async function deploy(options) {
+	const deployEnv = validateWranglerEnvName(options.env || (options.preview ? "preview" : "production"));
 	const root = path.resolve(options.root);
 	loadDotenv({
 		root,
@@ -905,7 +995,7 @@ async function deploy(options) {
 		console.log("\n  Dry run complete. Files generated but no build or deploy performed.\n");
 		return;
 	}
-	if (!options.skipBuild) await runBuild(info, options.env || (options.preview ? "preview" : void 0));
+	if (!options.skipBuild) await runBuild(info, deployEnv === "production" && !options.env ? void 0 : deployEnv);
 	else console.log("\n  Skipping build (--skip-build)");
 	{
 		const nextConfig = await resolveNextConfig(await loadNextConfig(info.root), info.root);
@@ -922,6 +1012,7 @@ async function deploy(options) {
 				concurrency: options.prerenderConcurrency
 			});
 		}
+		injectPregeneratedConcretePaths(root);
 	}
 	if (options.experimentalTPR) {
 		console.log();
@@ -933,13 +1024,10 @@ async function deploy(options) {
 		});
 		if (tprResult.skipped) console.log(`  TPR: Skipped (${tprResult.skipped})`);
 	}
-	const url = runWranglerDeploy(root, {
-		preview: options.preview ?? false,
-		env: options.env
-	});
+	const url = runWranglerDeploy(root, { env: deployEnv === "production" && !options.env ? void 0 : deployEnv });
 	console.log("\n  ─────────────────────────────────────────");
 	console.log(`  Deployed to: ${url}`);
 	console.log("  ─────────────────────────────────────────\n");
 }
 //#endregion
-export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };
+export { buildNodeCliInvocation, buildWranglerDeployArgs, buildWranglerInvocation, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, injectPregeneratedConcretePaths, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, runWranglerDeploy, validateWranglerEnvName, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };

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

@@ -1,5 +1,6 @@
+import { NextRewrite } from "../config/next-config.js";
 import { AppRoute, RouteManifest } from "../routing/app-route-graph.js";
-import { VinextLinkPrefetchRoute } from "../client/vinext-next-data.js";
+import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../client/vinext-next-data.js";
 
 //#region src/entries/app-browser-entry.d.ts
 /**
@@ -9,7 +10,11 @@ import { VinextLinkPrefetchRoute } from "../client/vinext-next-data.js";
  * embedded RSC payload and handles client-side navigation by re-fetching
  * RSC streams.
  */
-declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifest?: RouteManifest | null): string;
+declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifest?: RouteManifest | null, pagesPrefetchRoutes?: readonly VinextPagesLinkPrefetchRoute[], rewrites?: {
+  afterFiles: NextRewrite[];
+  beforeFiles: NextRewrite[];
+  fallback: NextRewrite[];
+}): string;
 /**
  * Filter for routes that should appear in the `__VINEXT_LINK_PREFETCH_ROUTES__`
  * manifest. Exported so the Pages Router client entry can reuse it when
@@ -17,7 +22,8 @@ declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifes
  * `pages-client-entry.ts`.
  */
 declare function isLinkPrefetchRoute(route: AppRoute): boolean;
+declare function toDocumentOnlyAppRoute(route: AppRoute): VinextLinkPrefetchRoute;
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
 declare function toLinkPrefetchRoute(route: AppRoute): VinextLinkPrefetchRoute;
 //#endregion
-export { generateBrowserEntry, isLinkPrefetchRoute, toLinkPrefetchRoute };
+export { generateBrowserEntry, isLinkPrefetchRoute, toDocumentOnlyAppRoute, toLinkPrefetchRoute };

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

@@ -7,13 +7,23 @@ import { resolveClientRuntimeModule, resolveRuntimeEntryModule } from "./runtime
 * embedded RSC payload and handles client-side navigation by re-fetching
 * RSC streams.
 */
-function generateBrowserEntry(routes = [], routeManifest = null) {
+function generateBrowserEntry(routes = [], routeManifest = null, pagesPrefetchRoutes = [], rewrites = {
+	afterFiles: [],
+	beforeFiles: [],
+	fallback: []
+}) {
 	const entryPath = resolveRuntimeEntryModule("app-browser-entry");
 	const navigationRuntimePath = resolveClientRuntimeModule("navigation-runtime");
-	const prefetchRoutes = routes.filter(isLinkPrefetchRoute).map(toLinkPrefetchRoute);
+	const prefetchRoutes = routes.map((route) => isLinkPrefetchRoute(route) ? toLinkPrefetchRoute(route) : toDocumentOnlyAppRoute(route));
 	return `import { registerNavigationRuntimeBootstrap } from ${JSON.stringify(navigationRuntimePath)};
 
 window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(prefetchRoutes)};
+// Pages route manifest for hybrid ownership decisions. In a hybrid
+// app+pages build the user can land on an App page, so the App browser
+// entry must also expose the Pages manifest (the Pages client entry does
+// the same — whichever entry runs first emits both globals).
+window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
+window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(rewrites)};
 registerNavigationRuntimeBootstrap({
     routeManifest: ${buildRouteManifestExpression(routeManifest)}
 });
@@ -29,6 +39,14 @@ function isLinkPrefetchRoute(route) {
 	if (route.pagePath !== null) return true;
 	return route.routePath === null && route.layouts.length > 0;
 }
+function toDocumentOnlyAppRoute(route) {
+	return {
+		canPrefetchLoadingShell: false,
+		documentOnly: true,
+		patternParts: [...route.patternParts],
+		isDynamic: route.isDynamic
+	};
+}
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
 function toLinkPrefetchRoute(route) {
 	return {
@@ -62,4 +80,4 @@ function buildMapExpression(map) {
 	return `new Map(${JSON.stringify(Array.from(map.entries()))})`;
 }
 //#endregion
-export { generateBrowserEntry, isLinkPrefetchRoute, toLinkPrefetchRoute };
+export { generateBrowserEntry, isLinkPrefetchRoute, toDocumentOnlyAppRoute, toLinkPrefetchRoute };

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

@@ -1,6 +1,7 @@
 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";
+import { ImageConfig } from "../server/image-optimization.js";
 
 //#region src/entries/app-rsc-entry.d.ts
 /**
@@ -45,6 +46,7 @@ type AppRouterConfig = {
   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;
+  imageConfig?: ImageConfig;
   /**
    * Absolute path to `app/global-not-found.{tsx,ts,js,jsx}` when present.
    * When provided, route-miss 404s render this module standalone (it owns its