vinext 1.1.0 → 1.2.1

package/dist/init.js

@@ -1,6 +1,6 @@
 import path, { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, findViteConfigPath, hasViteConfig, renameCJSConfigs } from "./utils/project.js";
-import { compactResourceName, cssModulesConfigSource, setupCloudflarePlatform, updateViteConfigForCssModules, usesCommonJsViteConfig, validateCloudflarePlatformSetup } from "./init-cloudflare.js";
+import { compactResourceName, cssModulesConfigSource, findConfigKeepingWorkerName, setupCloudflarePlatform, updateViteConfigForCssModules, usesCommonJsViteConfig, validateCloudflarePlatformSetup } from "./init-cloudflare.js";
 import { getReactUpgradeDeps } from "./utils/react-version.js";
 import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
@@ -14,7 +14,8 @@ import { spawn, spawnSync } from "node:child_process";
 *   2. Add "type": "module" to package.json
 *   3. Rename CJS config files to .cjs
 *   4. Add vinext scripts to package.json
-*   5. Generate vite.config.ts and platform files
+*   5. Generate vite.config.ts and platform files, plus a Tailwind PostCSS
+*      config when Tailwind is only set up as a Turbopack loader
 *   6. Update .gitignore to include /dist/ and .vinext/
 *   7. Install dependencies (vite, @vitejs/plugin-react, and App Router deps)
 *   8. Print summary
@@ -94,6 +95,77 @@ function scanCssModuleFiles(root) {
 		exclude: (entry) => entry.isDirectory() && (CSS_MODULE_IGNORES.has(entry.name) || toSlash(entry.parentPath) === canonicalRoot && CSS_MODULE_ROOT_IGNORES.has(entry.name))
 	}).some((entry) => /\.module\.(css|scss|sass)$/.test(entry.name));
 }
+const NEXT_CONFIG_FILES = [
+	"next.config.ts",
+	"next.config.mts",
+	"next.config.mjs",
+	"next.config.js",
+	"next.config.cjs"
+];
+const TAILWIND_LOADERS = ["@tailwindcss/turbopack", "@tailwindcss/webpack"];
+const TAILWIND_POSTCSS_CONFIG = `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;
+`;
+/**
+* Whether the project gets Tailwind from a Turbopack loader (as create-next-app
+* 16.4+ sets up in `turbopack.rules`) rather than from PostCSS, which is the
+* only way vinext compiles Tailwind. The config is not evaluated: a Next config
+* that names the loader, or a declared loader package, is enough.
+*/
+function usesTailwindTurbopackLoader(root) {
+	for (const file of NEXT_CONFIG_FILES) {
+		const configPath = path.join(root, file);
+		if (!fs.existsSync(configPath)) continue;
+		const source = fs.readFileSync(configPath, "utf-8");
+		if (TAILWIND_LOADERS.some((loader) => source.includes(loader))) return true;
+	}
+	return TAILWIND_LOADERS.some((loader) => isDepInstalled(root, loader));
+}
+const POSTCSS_CONFIG_SEARCH_ORDER = [
+	".postcssrc",
+	".postcssrc.json",
+	".postcssrc.yaml",
+	".postcssrc.yml",
+	".postcssrc.ts",
+	".postcssrc.cts",
+	".postcssrc.mts",
+	".postcssrc.js",
+	".postcssrc.cjs",
+	".postcssrc.mjs",
+	"postcss.config.ts",
+	"postcss.config.cts",
+	"postcss.config.mts",
+	"postcss.config.js",
+	"postcss.config.cjs",
+	"postcss.config.mjs"
+];
+/** The source of the PostCSS config Vite would load, which init never replaces. */
+function readPostcssConfig(root) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
+		if (pkg.postcss) return JSON.stringify(pkg.postcss);
+	} catch {}
+	for (const file of POSTCSS_CONFIG_SEARCH_ORDER) {
+		const configPath = path.join(root, file);
+		if (!fs.existsSync(configPath)) continue;
+		const source = fs.readFileSync(configPath, "utf-8");
+		if (source.trim() !== "") return source;
+	}
+}
+function getTailwindPostcssSetup(root, viteConfigPath) {
+	if (!usesTailwindTurbopackLoader(root)) return "none";
+	const viteConfig = viteConfigPath ? fs.readFileSync(viteConfigPath, "utf-8") : "";
+	const config = /postcss|lightningcss|tailwindcss/.test(viteConfig) ? viteConfig : readPostcssConfig(root);
+	if (config === void 0) return "generate";
+	if (/lightningcss/.test(config) && !config.includes("@tailwindcss/vite")) return "manual";
+	if (config.includes("@tailwindcss/postcss")) return "install";
+	return config.includes("tailwindcss") ? "none" : "manual";
+}
 /**
 * Add Vite scripts to package.json without overwriting custom scripts.
 * Exact scripts generated by older vinext versions are migrated in place.
@@ -123,7 +195,7 @@ function addScripts(root, port, platform = "node", options = {}) {
 		if (platform === "cloudflare") {
 			addScript("deploy", !options.legacyWrangler ? options.warmCdnCache ? "vinext-cloudflare deploy --warm-cache" : "vinext-cloudflare deploy" : options.warmCdnCache ? "vinext-cloudflare deploy --config dist/server/wrangler.json --warm-cache" : "vinext-cloudflare deploy --config dist/server/wrangler.json");
 			if (options.deployResponseStore && !pkg.scripts["deploy:response-store"]) {
-				pkg.scripts["deploy:response-store"] = !options.legacyWrangler ? `cf deploy --prebuilt --mode production --worker ${compactResourceName(detectProject(root).projectName, "-response-store", 63)}` : "wrangler deploy --config wrangler.response-store.jsonc";
+				pkg.scripts["deploy:response-store"] = !options.legacyWrangler ? `cf deploy --prebuilt --mode production --worker ${compactResourceName(options.workerName ?? detectProject(root).projectName, "-response-store", 63)}` : "wrangler deploy --config wrangler.response-store.jsonc";
 				added.push("deploy:response-store");
 			}
 		}
@@ -133,7 +205,7 @@ function addScripts(root, port, platform = "node", options = {}) {
 		return [];
 	}
 }
-function getInitDependencyGroups(isAppRouter, platform, cloudflare, hasCssModules = false) {
+function getInitDependencyGroups(isAppRouter, platform, cloudflare, hasCssModules = false, tailwindPostcss = false) {
 	const dependencies = ["vinext"];
 	const devDependencies = ["vite", "@vitejs/plugin-react"];
 	if (isAppRouter) {
@@ -149,6 +221,7 @@ function getInitDependencyGroups(isAppRouter, platform, cloudflare, hasCssModule
 		} else devDependencies.push("@cloudflare/vite-plugin@1", "wrangler");
 	}
 	if (hasCssModules) devDependencies.push("vite-css-modules", "postcss");
+	if (tailwindPostcss) devDependencies.push("@tailwindcss/postcss");
 	return {
 		dependencies,
 		devDependencies
@@ -227,7 +300,7 @@ function addDependencyEntries(root, deps, { dev }) {
 * Check if react/react-dom need upgrading for react-server-dom-webpack compatibility.
 *
 * react-server-dom-webpack versions are pinned to match their React version
-* (e.g. rsdw@19.2.6 requires react@^19.2.6). When a project has an older
+* (e.g. rsdw@19.3.1 requires react@^19.3.1). When a project has an older
 * React (e.g. create-next-app ships react@19.2.3), we need to upgrade
 * react/react-dom BEFORE installing rsdw to avoid peer-dep conflicts.
 *
@@ -302,6 +375,64 @@ function updateGitignore(root, platform = "node", legacyWrangler = false) {
 	fs.writeFileSync(gitignorePath, content + separator + missingEntries.join("\n") + "\n", "utf-8");
 	return true;
 }
+/**
+* Read `output` from the Next.js config as `vinext build` does: an inline
+* `vinext({ nextConfig })` in the Vite config wins over next.config, and both
+* are evaluated with NODE_ENV set to production and `.env.production` loaded as
+* the build loads it. The Vite config is read as written, without running
+* plugin `config` hooks, so a plugin that changes `root`, `envDir` or `mode` is
+* not seen. A config that cannot load here keeps the Worker-first default.
+* The loader is imported lazily because it needs Vite, which create-vinext-app
+* runs without.
+*/
+async function resolvesToStaticExport(root, viteConfigPath) {
+	let configModule;
+	let dotenvModule;
+	try {
+		[configModule, dotenvModule] = await Promise.all([import("./config/next-config.js"), import("./config/dotenv.js")]);
+	} catch {
+		return false;
+	}
+	const { findVinextNextConfigInPlugins, loadNextConfig, PHASE_PRODUCTION_BUILD, resolveNextConfigInput } = configModule;
+	const savedEnv = { ...process.env };
+	Reflect.set(process.env, "NODE_ENV", "production");
+	try {
+		dotenvModule.loadDotenv({
+			root,
+			mode: "production"
+		});
+		let mode = "production";
+		let inline = null;
+		let configRoot = root;
+		let envDir;
+		if (viteConfigPath) try {
+			const { loadConfigFromFile } = await import("vite");
+			const loaded = await loadConfigFromFile({
+				command: "build",
+				mode: "production",
+				isSsrBuild: false,
+				isPreview: false
+			}, viteConfigPath, root, "silent");
+			if (typeof loaded?.config.mode === "string") mode = loaded.config.mode;
+			if (typeof loaded?.config.root === "string") configRoot = path.resolve(root, loaded.config.root);
+			const configuredEnvDir = loaded?.config.envDir;
+			if (configuredEnvDir === false) envDir = false;
+			else if (typeof configuredEnvDir === "string") envDir = path.resolve(root, configuredEnvDir);
+			inline = await findVinextNextConfigInPlugins(loaded?.config.plugins);
+		} catch {}
+		if (envDir !== false) dotenvModule.loadDotenv({
+			root: envDir ?? configRoot,
+			mode
+		});
+		Reflect.set(process.env, "NODE_ENV", "production");
+		return (inline ? await resolveNextConfigInput(inline, PHASE_PRODUCTION_BUILD) : await loadNextConfig(configRoot, PHASE_PRODUCTION_BUILD))?.output === "export";
+	} catch {
+		return false;
+	} finally {
+		for (const key of Object.keys(process.env)) if (!Object.hasOwn(savedEnv, key)) delete process.env[key];
+		Object.assign(process.env, savedEnv);
+	}
+}
 function setupNodePlatform(context) {
 	if (context.viteConfigExists && !context.force) {
 		if (context.hasCssModules && context.existingViteConfigPath) {
@@ -387,16 +518,20 @@ async function init(options) {
 	const viteConfigExists = hasViteConfig(root);
 	const isApp = detectProject(root).isAppRouter;
 	const hasCssModules = !options.skipCssModules && scanCssModuleFiles(root);
+	const tailwindPostcssSetup = getTailwindPostcssSetup(root, platform === "node" && options.force ? void 0 : existingViteConfigPath);
 	const pmName = detectPackageManagerName(root);
 	const shouldInstall = options.install ?? true;
+	const isStaticExport = platform === "cloudflare" && await resolvesToStaticExport(root, existingViteConfigPath);
 	if (platform === "cloudflare") validateCloudflarePlatformSetup({
 		root,
 		isAppRouter: isApp,
 		existingViteConfigPath,
 		hasCssModules,
+		isStaticExport,
 		today: options._today
 	}, cloudflareOptions);
 	else if (hasCssModules && existingViteConfigPath && !options.force) updateViteConfigForCssModules(existingViteConfigPath, fs.readFileSync(existingViteConfigPath, "utf-8"));
+	const configKeepingWorkerName = platform === "cloudflare" ? findConfigKeepingWorkerName(root, cloudflareOptions) : void 0;
 	if (!options.skipCheck) {
 		console.log("  Running compatibility check...\n");
 		const { runCheck, formatReport } = await import("./check.js");
@@ -417,7 +552,8 @@ async function init(options) {
 		deployResponseStore,
 		warmCdnCache: options.cloudflare?.warmCdnCache ?? false,
 		legacyWrangler: options.cloudflare?.legacyWrangler,
-		scriptNames: options.scriptNames
+		scriptNames: options.scriptNames,
+		workerName: configKeepingWorkerName ? void 0 : options.cloudflare?.name
 	});
 	const setupContext = {
 		root,
@@ -428,19 +564,24 @@ async function init(options) {
 		force: options.force ?? false,
 		prerender: options.prerender,
 		hasCssModules,
+		isStaticExport,
 		today: options._today
 	};
 	const platformSetup = platform === "cloudflare" ? setupCloudflarePlatform(setupContext, cloudflareOptions) : setupNodePlatform(setupContext);
 	const { generatedViteConfig, skippedViteConfig, generatedPlatformFiles } = platformSetup;
+	if (tailwindPostcssSetup === "generate") fs.writeFileSync(path.join(root, "postcss.config.mjs"), TAILWIND_POSTCSS_CONFIG, "utf-8");
 	const updatedGitignore = updateGitignore(root, platform, options.cloudflare?.legacyWrangler);
-	const neededDeps = getInitDependencyGroups(isApp, platform, options.cloudflare, hasCssModules);
+	const neededDeps = getInitDependencyGroups(isApp, platform, options.cloudflare, hasCssModules, tailwindPostcssSetup === "generate" || tailwindPostcssSetup === "install");
 	const missingDependencies = neededDeps.dependencies.filter((dep) => !isDepInstalled(root, dep));
 	const missingDevDependencies = neededDeps.devDependencies.filter((dep) => !isDepInstalled(root, dep));
 	let dependencyInstallNeedsApproval = false;
 	const dependencyEntriesAdded = [];
 	const devDependencyEntriesAdded = [];
-	if (isApp && (!shouldInstall || missingDependencies.includes("react-server-dom-webpack"))) {
-		const reactUpgrade = getReactUpgradeDeps(root, { fromManifest: !shouldInstall });
+	if (isApp) {
+		const reactUpgrade = shouldInstall ? [.../* @__PURE__ */ new Set([...getReactUpgradeDeps(root), ...getReactUpgradeDeps(root, {
+			fromManifest: true,
+			installing: true
+		})])] : getReactUpgradeDeps(root, { fromManifest: true });
 		if (reactUpgrade.length > 0) {
 			console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Upgrading dependencies:"))}`);
 			console.log(formatList(reactUpgrade.map((dep) => dep.replace(/@latest$/, "")), "    "));
@@ -513,6 +654,9 @@ async function init(options) {
 	if (skippedViteConfig) console.log(`    ${terminalStyle.yellow("-")} Skipped vite.config.ts (already exists, use --force to overwrite)`);
 	if (updatedGitignore) console.log(`    ${terminalStyle.green("✓")} Added vinext output directories to .gitignore`);
 	if (hasCssModules) console.log(`    ${terminalStyle.green("✓")} Configured vite-css-modules for CSS Modules`);
+	if (tailwindPostcssSetup === "generate") console.log(`    ${terminalStyle.green("✓")} Generated postcss.config.mjs for Tailwind CSS (vinext does not run turbopack.rules loaders)`);
+	else if (tailwindPostcssSetup === "manual") console.log(`    ${terminalStyle.yellow("!")} Tailwind CSS is set up as a Turbopack loader, which vinext does not run; set up "@tailwindcss/postcss" or "@tailwindcss/vite" for vinext`);
+	if (configKeepingWorkerName) console.log(`    ${terminalStyle.yellow("!")} Kept the Worker name in the existing ${configKeepingWorkerName}; --name was not applied, so update it there if it should be "${cloudflareOptions.name}"`);
 	if (platformSetup.preservedExistingGenerateScopedName) console.log(`    ${terminalStyle.yellow("!")} Preserved existing css.modules.generateScopedName; verify it produces identical class names in SSR and client builds`);
 	const nextSteps = [...platformSetup.nextSteps];
 	if (dependencyInstallNeedsApproval) nextSteps.push("Dependency installation is incomplete because pnpm blocked dependency build scripts:", "1. Review and approve the required build scripts:", "   pnpm approve-builds", "2. Finish installing dependencies:", "   pnpm install");

package/dist/plugins/ast-scope.d.ts

@@ -11,4 +11,11 @@ export declare function collectDirectScopeBindings(node: ESTree.Node, scope: Ast
 export declare function collectLoopScopeBindings(node: ESTree.ForStatement | ESTree.ForInStatement | ESTree.ForOfStatement, scope: AstScope, onVariableDeclarator?: (declaration: ESTree.VariableDeclaration, declarator: ESTree.VariableDeclarator) => void): void;
 export declare function collectSwitchScopeBindings(node: ESTree.SwitchStatement, scope: AstScope, onVariableDeclarator?: (declaration: ESTree.VariableDeclaration, declarator: ESTree.VariableDeclarator) => void): void;
 export declare function collectVarScopeBindings(node: ESTree.Node, scope: AstScope, root?: boolean): void;
+/** The nearest scope declaring `name`, or `null` for an unbound (global) name. */
+export declare function findAstBindingScope(scope: AstScope, name: string): AstScope | null;
+/**
+ * Visit every node with the scope it is evaluated in. The root scope holds the
+ * program's own bindings, including every `var` outside a function.
+ */
+export declare function walkAstScopes(root: ESTree.Program, visitor: (node: ESTree.Node, scope: AstScope) => void): AstScope;
 //#endregion

package/dist/plugins/ast-scope.js

@@ -23,7 +23,7 @@ function collectDirectScopeBindings(node, scope, onVariableDeclarator) {
 			for (const specifier of declaration.specifiers) if (specifier.type !== "ImportSpecifier" || specifier.importKind !== "type") collectBindingNames(specifier.local, scope.bindings);
 		} else if (declaration.type === "TSImportEqualsDeclaration" && declaration.importKind !== "type") collectBindingNames(declaration.id, scope.bindings);
 		else if (declaration.type === "VariableDeclaration" && declaration.declare !== true) for (const declarator of declaration.declarations) {
-			collectBindingNames(declarator.id, scope.bindings);
+			if (declaration.kind !== "var") collectBindingNames(declarator.id, scope.bindings);
 			onVariableDeclarator?.(declaration, declarator);
 		}
 		else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.declare !== true) collectBindingNames(declaration.id, scope.bindings);
@@ -34,7 +34,7 @@ function collectLoopScopeBindings(node, scope, onVariableDeclarator) {
 	const declarationValue = node.type === "ForStatement" ? node.init : node.left;
 	if (!declarationValue || declarationValue.type !== "VariableDeclaration" || declarationValue.declare === true) return;
 	for (const declarator of declarationValue.declarations) {
-		collectBindingNames(declarator.id, scope.bindings);
+		if (declarationValue.kind !== "var") collectBindingNames(declarator.id, scope.bindings);
 		onVariableDeclarator?.(declarationValue, declarator);
 	}
 }
@@ -46,5 +46,61 @@ function collectVarScopeBindings(node, scope, root = true) {
 	if (node.type === "VariableDeclaration" && node.kind === "var" && node.declare !== true) for (const declarator of node.declarations) collectBindingNames(declarator.id, scope.bindings);
 	forEachAstChild(node, (child) => collectVarScopeBindings(child, scope, false));
 }
+/** The nearest scope declaring `name`, or `null` for an unbound (global) name. */
+function findAstBindingScope(scope, name) {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return current;
+	return null;
+}
+/**
+* Visit every node with the scope it is evaluated in. The root scope holds the
+* program's own bindings, including every `var` outside a function.
+*/
+function walkAstScopes(root, visitor) {
+	const rootScope = createAstScope(null);
+	collectDirectScopeBindings(root, rootScope);
+	collectVarScopeBindings(root, rootScope);
+	function visit(node, parentScope) {
+		visitor(node, parentScope);
+		let scope = parentScope;
+		if (isFunctionNode(node)) {
+			const parameterScope = createAstScope(parentScope);
+			if (node.type === "FunctionExpression") collectBindingNames(node.id, parameterScope.bindings);
+			for (const parameter of node.params) collectBindingNames(parameter, parameterScope.bindings);
+			if (node.id) visit(node.id, node.type === "FunctionExpression" ? parameterScope : parentScope);
+			for (const parameter of node.params) visit(parameter, parameterScope);
+			if (!node.body) return;
+			const bodyScope = createAstScope(parameterScope);
+			collectDirectScopeBindings(node.body, bodyScope);
+			collectVarScopeBindings(node.body, bodyScope);
+			if (node.body.type === "BlockStatement") for (const statement of node.body.body) visit(statement, bodyScope);
+			else visit(node.body, bodyScope);
+			return;
+		}
+		if (node.type === "SwitchStatement") {
+			visit(node.discriminant, parentScope);
+			const switchScope = createAstScope(parentScope);
+			collectSwitchScopeBindings(node, switchScope);
+			for (const switchCase of node.cases) visit(switchCase, switchScope);
+			return;
+		}
+		if (node.type === "BlockStatement" || node.type === "StaticBlock" || node.type === "TSModuleBlock") {
+			scope = createAstScope(parentScope);
+			collectDirectScopeBindings(node, scope);
+			if (node.type === "StaticBlock" || node.type === "TSModuleBlock") collectVarScopeBindings(node, scope);
+		} else if (node.type === "CatchClause") {
+			scope = createAstScope(parentScope);
+			collectBindingNames(node.param, scope.bindings);
+		} else if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+			scope = createAstScope(parentScope);
+			collectLoopScopeBindings(node, scope);
+		} else if (node.type === "ClassExpression" && node.id) {
+			scope = createAstScope(parentScope);
+			collectBindingNames(node.id, scope.bindings);
+		}
+		forEachAstChild(node, (child) => visit(child, scope));
+	}
+	for (const statement of root.body) visit(statement, rootScope);
+	return rootScope;
+}
 //#endregion
-export { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, hasAstBinding, isFunctionNode };
+export { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, findAstBindingScope, hasAstBinding, isFunctionNode, walkAstScopes };

package/dist/plugins/ast-utils.d.ts

@@ -1,4 +1,4 @@
-import { ESTree } from "vite";
+import { ESTree, ParseResult, ParserOptions } from "vite";
 //#region src/plugins/ast-utils.d.ts
 export type ScriptParserLanguage = "js" | "jsx" | "ts" | "tsx";
 export declare const SCRIPT_MODULE_ID_RE: RegExp;
@@ -8,7 +8,7 @@ export declare const SCRIPT_MODULE_ID_RE: RegExp;
  * Static imports — `import x from "..."`, `import { ... } from "..."`,
  * `import "..."` — never place a `(` (nor a comment leading to one) immediately
  * after the `import` keyword. Plugins that act only on dynamic `import(...)` use
- * this to skip `parseAst` for the overwhelming majority of modules in a large
+ * this to skip parsing for the overwhelming majority of modules in a large
  * app: at ~5k routes, where almost every module is a static-import-only page,
  * it removes most of the build's AST-parse/GC cost. This is a deliberate,
  * measured performance filter — keep it a regex, never a parse.
@@ -36,6 +36,57 @@ export declare function mayContainDynamicImport(code: string): boolean;
  * necessarily been lowered.
  */
 export declare function scriptParserLanguage(id: string): ScriptParserLanguage | null;
+/** The import/export record oxc builds alongside the AST. */
+export type ModuleRecord = ParseResult["module"];
+/**
+ * Parse `code` into an ESTree program, throwing on syntax errors.
+ *
+ * Replaces Vite's deprecated `parseAst` with the same defaults and contract.
+ * Callers that only need import/export declarations should use
+ * {@link parseModuleRecord}, which skips building the JS AST.
+ */
+export declare function parseProgram(code: string, options?: ParserOptions): ESTree.Program;
+/** Async {@link parseProgram}; replaces Vite's deprecated `parseAstAsync`. */
+export declare function parseProgramAsync(code: string, options?: ParserOptions): Promise<ESTree.Program>;
+/**
+ * Parse `code` and return only its static import/export and dynamic import
+ * record, or `null` when it has syntax errors.
+ *
+ * Reading the record never deserializes the JS AST, which is most of the cost
+ * of a parse (about 4x cheaper than {@link parseProgram} on large modules).
+ * The record omits import attributes; see {@link hasImportAttributes}.
+ */
+export declare function parseModuleRecord(code: string, lang: ParserOptions["lang"]): ModuleRecord | null;
+/**
+ * One whitespace character or comment. Each alternative can only match one
+ * way (a block comment stops at the first `*\/`, a line comment runs to the
+ * line end), so repeating it cannot backtrack exponentially.
+ */
+export declare const TRIVIA_PATTERN: string;
+/** Leading whitespace and comments. */
+export declare const LEADING_TRIVIA_RE: RegExp;
+/**
+ * Whether the static import/export statement ending at `statementEnd` has
+ * `with { ... }` (or legacy `assert { ... }`) attributes after its source
+ * string, which ends at `sourceEnd`. The module record does not report
+ * attributes.
+ */
+export declare function hasImportAttributes(code: string, sourceEnd: number, statementEnd: number): boolean;
+/**
+ * Whether a static import is erased by TypeScript: every binding is
+ * type-only, or it is `import type {} from "x"`, which the module record
+ * reports with no entries (like a runtime `import {} from "x"`).
+ */
+export declare function isTypeOnlyImport(code: string, statement: ModuleRecord["staticImports"][number]): boolean;
+/**
+ * The value of the string literal or expression-free template literal spanning
+ * `span`, or `null` for any other expression. The module record gives only the
+ * span of a dynamic import's source.
+ */
+export declare function quotedStringAt(code: string, span: {
+  start: number;
+  end: number;
+}): string | null;
 export declare function isIdentifierNamed(value: ESTree.Node | null | undefined, name: string): boolean;
 export declare function getAstName(node: ESTree.Node | null | undefined): string | null;
 /** Remove syntax-only wrappers while preserving the underlying expression. */

package/dist/plugins/ast-utils.js

@@ -1,3 +1,4 @@
+import { parse, parseSync } from "vite";
 //#region src/plugins/ast-utils.ts
 const SCRIPT_MODULE_EXTENSION_RE = /^\.(?:[cm]?[jt]s|[jt]sx)$/i;
 const SCRIPT_MODULE_ID_RE = /\.(?:[cm]?[jt]s|[jt]sx)(?:[?#].*)?$/i;
@@ -7,7 +8,7 @@ const SCRIPT_MODULE_ID_RE = /\.(?:[cm]?[jt]s|[jt]sx)(?:[?#].*)?$/i;
 * Static imports — `import x from "..."`, `import { ... } from "..."`,
 * `import "..."` — never place a `(` (nor a comment leading to one) immediately
 * after the `import` keyword. Plugins that act only on dynamic `import(...)` use
-* this to skip `parseAst` for the overwhelming majority of modules in a large
+* this to skip parsing for the overwhelming majority of modules in a large
 * app: at ~5k routes, where almost every module is a static-import-only page,
 * it removes most of the build's AST-parse/GC cost. This is a deliberate,
 * measured performance filter — keep it a regex, never a parse.
@@ -46,6 +47,93 @@ function scriptParserLanguage(id) {
 	if (extension === ".tsx") return "tsx";
 	return "jsx";
 }
+const PROGRAM_PARSER_DEFAULTS = {
+	lang: "js",
+	preserveParens: false
+};
+const PARSE_FILENAME = "file.js";
+function programOrThrow(result) {
+	if (result.errors.length > 0) {
+		const frames = result.errors.slice(0, 5).map((error) => error.codeframe ?? error.message);
+		throw new SyntaxError(`Parse failed with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}:\n${frames.join("\n")}`);
+	}
+	return result.program;
+}
+/**
+* Parse `code` into an ESTree program, throwing on syntax errors.
+*
+* Replaces Vite's deprecated `parseAst` with the same defaults and contract.
+* Callers that only need import/export declarations should use
+* {@link parseModuleRecord}, which skips building the JS AST.
+*/
+function parseProgram(code, options) {
+	return programOrThrow(parseSync(PARSE_FILENAME, code, {
+		...PROGRAM_PARSER_DEFAULTS,
+		...options
+	}));
+}
+/** Async {@link parseProgram}; replaces Vite's deprecated `parseAstAsync`. */
+async function parseProgramAsync(code, options) {
+	return programOrThrow(await parse(PARSE_FILENAME, code, {
+		...PROGRAM_PARSER_DEFAULTS,
+		...options
+	}));
+}
+/**
+* Parse `code` and return only its static import/export and dynamic import
+* record, or `null` when it has syntax errors.
+*
+* Reading the record never deserializes the JS AST, which is most of the cost
+* of a parse (about 4x cheaper than {@link parseProgram} on large modules).
+* The record omits import attributes; see {@link hasImportAttributes}.
+*/
+function parseModuleRecord(code, lang) {
+	const result = parseSync(PARSE_FILENAME, code, { lang });
+	return result.errors.length > 0 ? null : result.module;
+}
+/**
+* One whitespace character or comment. Each alternative can only match one
+* way (a block comment stops at the first `*\/`, a line comment runs to the
+* line end), so repeating it cannot backtrack exponentially.
+*/
+const TRIVIA_PATTERN = String.raw`(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/|\/\/[^\n\r\u2028\u2029]*(?![^\n\r\u2028\u2029]))`;
+/** Leading whitespace and comments. */
+const LEADING_TRIVIA_RE = new RegExp(`^${TRIVIA_PATTERN}*`);
+/**
+* Whether the static import/export statement ending at `statementEnd` has
+* `with { ... }` (or legacy `assert { ... }`) attributes after its source
+* string, which ends at `sourceEnd`. The module record does not report
+* attributes.
+*/
+function hasImportAttributes(code, sourceEnd, statementEnd) {
+	const afterSource = code.slice(sourceEnd, statementEnd);
+	const triviaLength = LEADING_TRIVIA_RE.exec(afterSource)?.[0].length ?? 0;
+	return /^(?:with|assert)\b/.test(afterSource.slice(triviaLength));
+}
+const EMPTY_TYPE_IMPORT_RE = new RegExp(String.raw`^import${TRIVIA_PATTERN}*type${TRIVIA_PATTERN}*\{`);
+/**
+* Whether a static import is erased by TypeScript: every binding is
+* type-only, or it is `import type {} from "x"`, which the module record
+* reports with no entries (like a runtime `import {} from "x"`).
+*/
+function isTypeOnlyImport(code, statement) {
+	if (statement.entries.length > 0) return statement.entries.every((entry) => entry.isType);
+	return EMPTY_TYPE_IMPORT_RE.test(code.slice(statement.start, statement.moduleRequest.start));
+}
+/**
+* The value of the string literal or expression-free template literal spanning
+* `span`, or `null` for any other expression. The module record gives only the
+* span of a dynamic import's source.
+*/
+function quotedStringAt(code, span) {
+	const text = code.slice(span.start, span.end);
+	const match = /^(?:"([^"\\\r\n]*)"|'([^'\\\r\n]*)'|`([^`\\$]*)`)$/.exec(text);
+	if (match) return match[1] ?? match[2] ?? match[3];
+	if (!/^["'`]/.test(text)) return null;
+	const result = parseSync(PARSE_FILENAME, `(${text})`, PROGRAM_PARSER_DEFAULTS);
+	const statement = result.errors.length > 0 ? void 0 : result.program.body[0];
+	return statement?.type === "ExpressionStatement" ? staticStringValue(statement.expression) : null;
+}
 const SKIP_CHILD_KEYS = /* @__PURE__ */ new Set([
 	"type",
 	"parent",
@@ -137,4 +225,4 @@ function collectBindingNames(node, target) {
 	}
 }
 //#endregion
-export { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, booleanLiteralValue, collectBindingNames, forEachAstChild, getAstName, isIdentifierNamed, mayContainDynamicImport, scriptParserLanguage, staticStringValue, stringLiteralValue, unwrapExpression, walkAst };
+export { DYNAMIC_IMPORT_PRESCAN, LEADING_TRIVIA_RE, SCRIPT_MODULE_ID_RE, TRIVIA_PATTERN, booleanLiteralValue, collectBindingNames, forEachAstChild, getAstName, hasImportAttributes, isIdentifierNamed, isTypeOnlyImport, mayContainDynamicImport, parseModuleRecord, parseProgram, parseProgramAsync, quotedStringAt, scriptParserLanguage, staticStringValue, stringLiteralValue, unwrapExpression, walkAst };

package/dist/plugins/cloudflare-dev-module-urls.d.ts

@@ -0,0 +1,41 @@
+import { Plugin } from "vite";
+//#region src/plugins/cloudflare-dev-module-urls.d.ts
+/**
+ * Vite's internal middlewares that serve module requests (`/@vite/client`,
+ * `/@id/*`, JS and CSS source files) and `/@fs/*` paths, preceded by the one
+ * that strips a non-root `base` from the URL and the one that answers the HMR
+ * client's reconnect ping (`Accept: text/x-vite-ping`) with a 204 instead of
+ * the Worker rendering a page for it. If Vite renames them, none are found and
+ * every request falls through, which is the behavior without this plugin.
+ *
+ * `viteServePublicMiddleware` is deliberately excluded so that `public/` files
+ * reach the Worker and middleware, as they do in production. Without it, the
+ * transform middleware reports a public `.js` or `.css` file as an
+ * `ERR_LOAD_PUBLIC_URL` error, which is treated as a fall-through.
+ */
+export declare const VITE_MODULE_MIDDLEWARE_NAMES: Set<string>;
+/**
+ * Vite's internal middleware that serves files under the project root. Vite
+ * gives imported assets root-relative URLs (`import logo from "./logo.svg"`
+ * and CSS `url(./bg.png)` both resolve to paths like `/app/logo.svg`), and only
+ * this middleware serves them. It also serves every other project file, and a
+ * Worker route can share its path with one (e.g. an `api/` directory and an
+ * `/api/*` route handler), so it only runs for referenced assets. See
+ * `isReferencedAsset`. Navigations to a referenced asset
+ * are served too: in production its URL is under `/_next/static/`, which never
+ * reaches the Worker.
+ */
+export declare const VITE_STATIC_MIDDLEWARE_NAME = "viteServeStaticMiddleware";
+type CloudflareDevModuleUrlsOptions = {
+  /** Whether the Cloudflare Vite plugin is present. Read when the dev server starts. */
+  isEnabled: () => boolean;
+};
+/**
+ * Creates the plugin that lets Vite serve its module URLs before the Cloudflare
+ * plugin's `runWorkerFirst` routing in dev.
+ *
+ * @param options - Plugin options
+ * @returns The Vite plugin
+ */
+export declare function createCloudflareDevModuleUrlsPlugin(options: CloudflareDevModuleUrlsOptions): Plugin;
+//#endregion