@qzsy/vinext 0.1.7

package/dist/deploy.js

@@ -0,0 +1,1033 @@
+import { detectPackageManager as detectPackageManager$1, ensureESModule as ensureESModule$1, findDir, findInNodeModules, hasAppDir, 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";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { execFileSync } from "node:child_process";
+//#region src/deploy.ts
+/**
+* vinext deploy — one-command Cloudflare Workers deployment.
+*
+* Takes any Next.js app and deploys it to Cloudflare Workers:
+*
+*   1. Detects App Router vs Pages Router
+*   2. Auto-generates missing config files (wrangler.jsonc, worker/index.ts, vite.config.ts)
+*   3. Ensures dependencies are installed (@cloudflare/vite-plugin, wrangler, @vitejs/plugin-react, App Router deps)
+*   4. Runs the Vite build
+*   5. Deploys to Cloudflare Workers via wrangler
+*
+* Design: Everything is auto-generated into a `.vinext/` directory (not the
+* project root) to avoid cluttering the user's project. If the user already
+* has these files, we use theirs.
+*/
+/** Deploy command flag definitions for util.parseArgs. */
+const deployArgOptions = {
+	help: {
+		type: "boolean",
+		short: "h",
+		default: false
+	},
+	preview: {
+		type: "boolean",
+		default: false
+	},
+	env: { type: "string" },
+	name: { type: "string" },
+	"skip-build": {
+		type: "boolean",
+		default: false
+	},
+	"dry-run": {
+		type: "boolean",
+		default: false
+	},
+	"prerender-all": {
+		type: "boolean",
+		default: false
+	},
+	"prerender-concurrency": { type: "string" },
+	"experimental-tpr": {
+		type: "boolean",
+		default: false
+	},
+	"tpr-coverage": { type: "string" },
+	"tpr-limit": { type: "string" },
+	"tpr-window": { type: "string" }
+};
+function parseDeployArgs(args) {
+	const { values } = parseArgs({
+		args,
+		options: deployArgOptions,
+		strict: true
+	});
+	function parseIntArg(name, raw) {
+		if (!raw) return void 0;
+		const n = parseInt(raw, 10);
+		if (isNaN(n)) {
+			console.error(`  --${name} must be a number (got: ${raw})`);
+			process.exit(1);
+		}
+		return n;
+	}
+	return {
+		help: values.help,
+		preview: values.preview,
+		env: values.env?.trim() || void 0,
+		name: values.name?.trim() || void 0,
+		skipBuild: values["skip-build"],
+		dryRun: values["dry-run"],
+		prerenderAll: values["prerender-all"],
+		prerenderConcurrency: values["prerender-concurrency"] === void 0 ? void 0 : parsePositiveIntegerArg(values["prerender-concurrency"], "--prerender-concurrency"),
+		experimentalTPR: values["experimental-tpr"],
+		tprCoverage: parseIntArg("tpr-coverage", values["tpr-coverage"]),
+		tprLimit: parseIntArg("tpr-limit", values["tpr-limit"]),
+		tprWindow: parseIntArg("tpr-window", values["tpr-window"])
+	};
+}
+/** Check whether a wrangler config file exists in the given directory. */
+function hasWranglerConfig(root) {
+	return fs.existsSync(path.join(root, "wrangler.jsonc")) || fs.existsSync(path.join(root, "wrangler.json")) || fs.existsSync(path.join(root, "wrangler.toml"));
+}
+/**
+* Build the error message thrown when cloudflare() is missing from the Vite config.
+* Shared between the build-time guard (index.ts configResolved) and the
+* deploy-time guard (deploy.ts deploy()).
+*/
+function formatMissingCloudflarePluginError(options) {
+	const cfArg = options.isAppRouter ? "{\n      viteEnvironment: { name: \"rsc\", childEnvironments: [\"ssr\"] },\n    }" : "";
+	const configRef = options.configFile ? options.configFile : "your Vite config";
+	return `[vinext] Missing @cloudflare/vite-plugin in ${configRef}.\n\n  Cloudflare Workers builds require the cloudflare() plugin.\n  Add it to ${configRef}:\n\n    import { cloudflare } from "@cloudflare/vite-plugin";\n\n    export default defineConfig({\n      plugins: [\n        vinext(),\n        cloudflare(${cfArg}),\n      ],\n    });\n\n  Or delete ${configRef} and re-run \`vinext deploy\` to auto-generate it.`;
+}
+function detectProject(root) {
+	const hasApp = hasAppDir(root);
+	const hasPages = findDir(root, "pages", path.join("src", "pages")) !== null;
+	const isAppRouter = hasApp;
+	const isPagesRouter = !hasApp && hasPages;
+	const hasViteConfig = fs.existsSync(path.join(root, "vite.config.ts")) || fs.existsSync(path.join(root, "vite.config.js")) || fs.existsSync(path.join(root, "vite.config.mjs"));
+	const wranglerConfigExists = hasWranglerConfig(root);
+	const hasWorkerEntry = fs.existsSync(path.join(root, "worker", "index.ts")) || fs.existsSync(path.join(root, "worker", "index.js"));
+	const hasCloudflarePlugin = findInNodeModules(root, "@cloudflare/vite-plugin") !== null;
+	const hasRscPlugin = findInNodeModules(root, "@vitejs/plugin-rsc") !== null;
+	const hasWrangler = findInNodeModules(root, ".bin/wrangler") !== null;
+	const pkgPath = path.join(root, "package.json");
+	let pkg = null;
+	if (fs.existsSync(pkgPath)) try {
+		pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	} 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 hasTypeModule = pkg?.type === "module";
+	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 hasCodeHike = "codehike" in allDeps;
+	const nativeModulesToStub = detectNativeModules(allDeps);
+	return {
+		root,
+		isAppRouter,
+		isPagesRouter,
+		hasViteConfig,
+		hasWranglerConfig: wranglerConfigExists,
+		hasWorkerEntry,
+		hasCloudflarePlugin,
+		hasRscPlugin,
+		hasWrangler,
+		projectName,
+		hasISR,
+		hasTypeModule,
+		hasMDX,
+		hasCodeHike,
+		nativeModulesToStub
+	};
+}
+/** 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;
+}
+/**
+* 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 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 detectMDXFromConfig(root) {
+	for (const f of [
+		"next.config.ts",
+		"next.config.mts",
+		"next.config.mjs",
+		"next.config.js",
+		"next.config.cjs"
+	]) {
+		const p = path.join(root, f);
+		if (fs.existsSync(p)) try {
+			const content = fs.readFileSync(p, "utf-8");
+			if (/pageExtensions.*mdx/i.test(content) || /@next\/mdx/.test(content)) return true;
+		} catch {}
+	}
+	return false;
+}
+/** Known native Node modules that can't run in Workers */
+const NATIVE_MODULES_TO_STUB = [
+	"@resvg/resvg-js",
+	"satori",
+	"lightningcss",
+	"@napi-rs/canvas",
+	"sharp"
+];
+/**
+* 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(allDeps) {
+	return NATIVE_MODULES_TO_STUB.filter((mod) => mod in allDeps);
+}
+/** @see {@link _ensureESModule} */
+const ensureESModule = ensureESModule$1;
+/** @see {@link _renameCJSConfigs} */
+const renameCJSConfigs = renameCJSConfigs$1;
+/** Generate wrangler.jsonc content */
+function generateWranglerConfig(info) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const config = {
+		$schema: "node_modules/wrangler/config-schema.json",
+		name: info.projectName,
+		compatibility_date: today,
+		compatibility_flags: ["nodejs_compat"],
+		main: "./worker/index.ts",
+		assets: {
+			directory: "dist/client",
+			not_found_handling: "none",
+			binding: "ASSETS"
+		},
+		images: { binding: "IMAGES" }
+	};
+	if (info.hasISR) config.kv_namespaces = [{
+		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() {
+	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";
+
+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: {
+    input(stream: ReadableStream): {
+      transform(options: Record<string, unknown>): {
+        output(options: { format: string; quality: number }): Promise<{ response(): Response }>;
+      };
+    };
+  };
+}
+
+interface ExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+}
+
+// Image security config. SVG sources with .svg extension auto-skip the
+// optimization endpoint on the client side (served directly, no proxy).
+// To route SVGs through the optimizer (with security headers), set
+// dangerouslyAllowSVG: true in next.config.js and uncomment below:
+// const imageConfig: ImageConfig = { dangerouslyAllowSVG: true };
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    const url = new URL(request.url);
+
+    // Image optimization via Cloudflare Images binding.
+    // The parseImageParams validation inside handleImageOptimization
+    // normalizes backslashes and validates the origin hasn't changed.
+    if (isImageOptimizationPath(url.pathname)) {
+      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, imageConfig);
+    }
+
+    // Delegate everything else to vinext, forwarding ctx so that
+    // ctx.waitUntil() is available to background cache writes and
+    // other deferred work via getRequestExecutionContext().
+    return handler.fetch(request, env, ctx);
+  },
+};
+`;
+}
+/** Generate worker/index.ts for Pages Router */
+function generatePagesRouterWorkerEntry() {
+	return `/**
+ * Cloudflare Worker entry point -- auto-generated by vinext deploy.
+ * Edit freely or delete to regenerate on next deploy.
+ */
+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, 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, 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";
+
+interface Env {
+  ASSETS: Fetcher;
+  IMAGES: {
+    input(stream: ReadableStream): {
+      transform(options: Record<string, unknown>): {
+        output(options: { format: string; quality: number }): Promise<{ response(): Response }>;
+      };
+    };
+  };
+}
+
+interface ExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+}
+
+// Extract config values (embedded at build time in the server entry)
+const basePath: string = vinextConfig?.basePath ?? "";
+const assetPathPrefix: string = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
+const trailingSlash: boolean = vinextConfig?.trailingSlash ?? false;
+const i18nConfig = vinextConfig?.i18n ?? null;
+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,
+  contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy,
+} : undefined;
+
+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;
+
+      // Block protocol-relative URL open redirects in all shapes:
+      //   literal  //evil.com, /\\\\evil.com
+      //   encoded  /%5Cevil.com, /%2F/evil.com
+      // Browsers normalize backslash to forward slash, and they percent-decode
+      // Location headers, so an encoded backslash in a downstream 308 redirect
+      // would also navigate to the attacker's origin.
+      if (isOpenRedirectShaped(pathname)) {
+        return new Response("This page could not be found", { status: 404 });
+      }
+
+      // Invalid \`_next/static/*\` paths short-circuit with a plain-text 404
+      // instead of falling through to renderPage (which would render the full
+      // HTML 404 page with bootstrap scripts + CSS). Valid assets are served
+      // by Cloudflare's ASSETS binding BEFORE the worker runs; only misses
+      // reach this code. Matches Next.js (#1337):
+      //   packages/next/src/server/lib/router-server.ts
+      if (isNextStaticPath(pathname, basePath, assetPathPrefix)) {
+        return notFoundStaticAssetResponse();
+      }
+
+      // 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.
+      {
+        const filteredHeaders = filterInternalHeaders(request.headers);
+        request = cloneRequestWithHeaders(request, filteredHeaders);
+      }
+
+      // ── 1. Strip basePath ─────────────────────────────────────────
+      // Track basePath presence on the original request so the matcher
+      // gating below can distinguish requests inside basePath (default
+      // rules apply) from requests outside it (only opt-out rules apply).
+      const hadBasePath = !basePath || hasBasePath(pathname, basePath);
+      {
+        const stripped = stripBasePath(pathname, basePath);
+        if (stripped !== pathname) {
+          const strippedUrl = new URL(request.url);
+          strippedUrl.pathname = stripped;
+          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 = [
+          ...(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 }) => {
+            const result = await env.IMAGES.input(body).transform(width > 0 ? { width } : {}).output({ format, quality });
+            return result.response();
+          },
+        }, allowedWidths, imageConfig);
+      }
+
+      // Delegate the canonical 9-step Next.js pipeline to the shared owner.
+      // The worker adapter is responsible for: open-redirect guard, _next/static
+      // 404 short-circuit, header filtering, basePath stripping, and image
+      // optimization. runPagesRequest receives a clean, basePath-stripped request.
+      const deps: PagesPipelineDeps = {
+        basePath,
+        trailingSlash,
+        i18nConfig,
+        configRedirects,
+        configRewrites,
+        configHeaders,
+        hadBasePath,
+        isDataReq,
+        isDataRequest: isDataReq,
+        ctx,
+        matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
+        // Pass the original (pre-basePath-stripping) URL to middleware so that
+        // request.nextUrl.basePath reflects whether the URL actually had the
+        // basePath prefix. Matches Next.js behavior and the prod-server.ts
+        // equivalent (shared via wrapMiddlewareWithBasePath).
+        runMiddleware:
+          typeof runMiddleware === "function"
+            ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath)
+            : null,
+        renderPage: typeof renderPage === "function"
+          ? (req, resolvedUrl, options, stagedHeaders) =>
+              renderPage(req, resolvedUrl, null, ctx, stagedHeaders, options)
+          : null,
+        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);
+      if (result.type === "response") {
+        return result.response;
+      }
+      // Should not reach here for prod/worker (all callbacks supplied).
+      return new Response("This page could not be found", { status: 404 });
+
+    } catch (error) {
+      console.error("[vinext] Worker error:", error);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  },
+};
+
+`;
+}
+/** Generate vite.config.ts for App Router */
+function generateAppRouterViteConfig(info) {
+	const imports = [
+		`import { defineConfig } from "vite";`,
+		`import vinext from "vinext";`,
+		`import { cloudflare } from "@cloudflare/vite-plugin";`
+	];
+	if (info?.nativeModulesToStub && info.nativeModulesToStub.length > 0) imports.push(`import path from "node:path";`);
+	const plugins = [];
+	if (info?.hasMDX) plugins.push(`    // vinext auto-injects @mdx-js/rollup with plugins from next.config`);
+	plugins.push(`    vinext(),`);
+	plugins.push(`    cloudflare({
+      viteEnvironment: {
+        name: "rsc",
+        childEnvironments: ["ssr"],
+      },
+    }),`);
+	let resolveBlock = "";
+	const aliases = [];
+	if (info?.nativeModulesToStub && info.nativeModulesToStub.length > 0) for (const mod of info.nativeModulesToStub) aliases.push(`      "${mod}": path.resolve(__dirname, "empty-stub.js"),`);
+	if (aliases.length > 0) resolveBlock = `\n  resolve: {\n    alias: {\n${aliases.join("\n")}\n    },\n  },`;
+	return `${imports.join("\n")}
+
+export default defineConfig({
+  plugins: [
+${plugins.join("\n")}
+  ],${resolveBlock}
+});
+`;
+}
+/** Generate vite.config.ts for Pages Router */
+function generatePagesRouterViteConfig(info) {
+	const imports = [
+		`import { defineConfig } from "vite";`,
+		`import vinext from "vinext";`,
+		`import { cloudflare } from "@cloudflare/vite-plugin";`
+	];
+	if (info?.nativeModulesToStub && info.nativeModulesToStub.length > 0) imports.push(`import path from "node:path";`);
+	let resolveBlock = "";
+	const aliases = [];
+	if (info?.nativeModulesToStub && info.nativeModulesToStub.length > 0) for (const mod of info.nativeModulesToStub) aliases.push(`      "${mod}": path.resolve(__dirname, "empty-stub.js"),`);
+	if (aliases.length > 0) resolveBlock = `\n  resolve: {\n    alias: {\n${aliases.join("\n")}\n    },\n  },`;
+	return `${imports.join("\n")}
+
+export default defineConfig({
+  plugins: [
+    vinext(),
+    cloudflare(),
+  ],${resolveBlock}
+});
+`;
+}
+/**
+* Check if a package is resolvable from a given root directory using
+* Node's module resolution (createRequire). Handles hoisting, pnpm
+* symlinks, monorepos, and Yarn PnP correctly.
+*/
+function isPackageResolvable(root, packageName) {
+	try {
+		createRequire(path.join(root, "package.json")).resolve(packageName);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getMissingDeps(info, _isResolvable = isPackageResolvable) {
+	const missing = [];
+	if (!info.hasCloudflarePlugin) missing.push({
+		name: "@cloudflare/vite-plugin",
+		version: "latest"
+	});
+	if (!info.hasWrangler) missing.push({
+		name: "wrangler",
+		version: "latest"
+	});
+	if (!_isResolvable(info.root, "@vitejs/plugin-react")) missing.push({
+		name: "@vitejs/plugin-react",
+		version: "latest"
+	});
+	if (info.isAppRouter && !info.hasRscPlugin) missing.push({
+		name: "@vitejs/plugin-rsc",
+		version: "latest"
+	});
+	if (info.isAppRouter) {
+		if (!_isResolvable(info.root, "react-server-dom-webpack")) missing.push({
+			name: "react-server-dom-webpack",
+			version: "latest"
+		});
+	}
+	if (info.hasMDX) {
+		if (!_isResolvable(info.root, "@mdx-js/rollup")) missing.push({
+			name: "@mdx-js/rollup",
+			version: "latest"
+		});
+	}
+	return missing;
+}
+function installDeps(root, deps) {
+	if (deps.length === 0) return;
+	const depSpecs = deps.map((d) => `${d.name}@${d.version}`);
+	const [pm, ...pmArgs] = detectPackageManager(root).split(" ");
+	console.log(`  Installing: ${deps.map((d) => d.name).join(", ")}`);
+	execFileSync(pm, [...pmArgs, ...depSpecs], {
+		cwd: root,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	});
+}
+const detectPackageManager = detectPackageManager$1;
+/**
+* Check whether an existing vite.config file already imports and uses the
+* Cloudflare Vite plugin. This is a heuristic text scan — it doesn't execute
+* the config — so it may produce false negatives for unusual configurations.
+*
+* Returns true if `@cloudflare/vite-plugin` appears to be configured, false
+* if it is missing (meaning the build will fail with "could not resolve
+* virtual:vinext-rsc-entry").
+*/
+function viteConfigHasCloudflarePlugin(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)) try {
+		return fs.readFileSync(candidate, "utf-8").includes("@cloudflare/vite-plugin");
+	} catch {
+		return true;
+	}
+	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({
+		path: path.join(info.root, "wrangler.jsonc"),
+		content: generateWranglerConfig(info),
+		description: "wrangler.jsonc"
+	});
+	if (!info.hasWorkerEntry) {
+		const workerContent = info.isAppRouter ? generateAppRouterWorkerEntry() : generatePagesRouterWorkerEntry();
+		files.push({
+			path: path.join(info.root, "worker", "index.ts"),
+			content: workerContent,
+			description: "worker/index.ts"
+		});
+	}
+	if (!info.hasViteConfig) {
+		const viteContent = info.isAppRouter ? generateAppRouterViteConfig(info) : generatePagesRouterViteConfig(info);
+		files.push({
+			path: path.join(info.root, "vite.config.ts"),
+			content: viteContent,
+			description: "vite.config.ts"
+		});
+	}
+	return files;
+}
+function writeGeneratedFiles(files) {
+	for (const file of files) {
+		const dir = path.dirname(file.path);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(file.path, file.content, "utf-8");
+		console.log(`  Created ${file.description}`);
+	}
+}
+/**
+* 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 {
+		vitePath = createRequire(path.join(info.root, "package.json")).resolve("vite");
+	} catch {
+		vitePath = "vite";
+	}
+	const { createBuilder } = await (vitePath === "vite" ? import(vitePath) : import(pathToFileURL(vitePath).href));
+	await withCloudflareEnv(env, async () => {
+		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", validateWranglerEnvName(env));
+	return {
+		args,
+		env
+	};
+}
+/**
+* Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
+*
+* Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
+* shim and command shell that package managers create on Windows.
+*/
+function resolveWranglerBin(root, resolvePackageJson = (projectRoot) => {
+	try {
+		return createRequire(path.join(projectRoot, "package.json")).resolve("wrangler/package.json");
+	} catch {
+		return findInNodeModules(projectRoot, "wrangler/package.json");
+	}
+}) {
+	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 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: false
+	};
+	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 = 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,
+		mode: "production"
+	});
+	console.log("\n  vinext deploy\n");
+	const info = detectProject(root);
+	if (!info.isAppRouter && !info.isPagesRouter) {
+		console.error("  Error: No app/ or pages/ directory found.");
+		console.error("  vinext deploy requires a Next.js project with an app/ or pages/ directory");
+		console.error("  (also checks src/app/ and src/pages/).\n");
+		process.exit(1);
+	}
+	if (options.name) info.projectName = options.name;
+	console.log(`  Project: ${info.projectName}`);
+	console.log(`  Router:  ${info.isAppRouter ? "App Router" : "Pages Router"}`);
+	console.log(`  ISR:     ${info.hasISR ? "detected" : "none"}`);
+	if (info.isAppRouter) {
+		const reactUpgrade = getReactUpgradeDeps(root);
+		if (reactUpgrade.length > 0) {
+			const [pm, ...pmArgs] = detectPackageManager(root).replace(/ -D$/, "").split(" ");
+			console.log(`  Upgrading ${reactUpgrade.map((d) => d.replace(/@latest$/, "")).join(", ")}...`);
+			execFileSync(pm, [...pmArgs, ...reactUpgrade], {
+				cwd: root,
+				stdio: "inherit",
+				shell: process.platform === "win32"
+			});
+		}
+	}
+	const missingDeps = getMissingDeps(info);
+	if (missingDeps.length > 0) {
+		console.log();
+		installDeps(root, missingDeps);
+		const nameOverride = options.name ? info.projectName : void 0;
+		Object.assign(info, detectProject(root));
+		if (nameOverride) info.projectName = nameOverride;
+	}
+	if (!info.hasTypeModule) {
+		const renamedConfigs = renameCJSConfigs(root);
+		for (const [oldName, newName] of renamedConfigs) console.log(`  Renamed ${oldName} → ${newName} (CJS → .cjs)`);
+		if (ensureESModule(root)) {
+			console.log(`  Added "type": "module" to package.json`);
+			info.hasTypeModule = true;
+		}
+	}
+	const filesToGenerate = getFilesToGenerate(info);
+	if (filesToGenerate.length > 0) {
+		console.log();
+		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, 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);
+		const isStaticExport = nextConfig.output === "export";
+		if (options.prerenderAll || isStaticExport) {
+			const label = isStaticExport && !options.prerenderAll ? "Pre-rendering all routes (output: 'export')..." : "Pre-rendering all routes...";
+			console.log(`\n  ${label}`);
+			if (nextConfig.enablePrerenderSourceMaps) {
+				process.setSourceMapsEnabled(true);
+				Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 50);
+			}
+			await runPrerender({
+				root: info.root,
+				concurrency: options.prerenderConcurrency
+			});
+		}
+		injectPregeneratedConcretePaths(root);
+	}
+	if (options.experimentalTPR) {
+		console.log();
+		const tprResult = await runTPR({
+			root,
+			coverage: Math.max(1, Math.min(100, options.tprCoverage ?? 90)),
+			limit: Math.max(1, options.tprLimit ?? 1e3),
+			window: Math.max(1, options.tprWindow ?? 24)
+		});
+		if (tprResult.skipped) console.log(`  TPR: Skipped (${tprResult.skipped})`);
+	}
+	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 { 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 };