vinext 1.2.0 → 1.3.0

package/dist/init.d.ts

@@ -70,7 +70,7 @@ export type InitDependencyGroups = {
   dependencies: string[];
   devDependencies: string[];
 };
-export declare function getInitDependencyGroups(isAppRouter: boolean, platform: InitPlatform, cloudflare?: CloudflareInitOptions, hasCssModules?: boolean): InitDependencyGroups;
+export declare function getInitDependencyGroups(isAppRouter: boolean, platform: InitPlatform, cloudflare?: CloudflareInitOptions, hasCssModules?: boolean, tailwindPostcss?: boolean): InitDependencyGroups;
 export declare function getInitDeps(isAppRouter: boolean, platform: InitPlatform, cloudflare?: CloudflareInitOptions, hasCssModules?: boolean): string[];
 export declare function isDepInstalled(root: string, dep: string): boolean;
 /**

package/dist/init.js

@@ -2,6 +2,7 @@ import path, { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/
 import { detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, findViteConfigPath, hasViteConfig, renameCJSConfigs } from "./utils/project.js";
 import { compactResourceName, cssModulesConfigSource, findConfigKeepingWorkerName, setupCloudflarePlatform, updateViteConfigForCssModules, usesCommonJsViteConfig, validateCloudflarePlatformSetup } from "./init-cloudflare.js";
 import { getReactUpgradeDeps } from "./utils/react-version.js";
+import { getPluginReactUpgradeDeps } from "./utils/plugin-react-version.js";
 import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 //#region src/init.ts
@@ -14,7 +15,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 +96,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.
@@ -133,7 +206,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 +222,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 +301,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.
 *
@@ -445,6 +519,7 @@ 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);
@@ -495,15 +570,19 @@ async function init(options) {
 	};
 	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$/, "")), "    "));
@@ -520,6 +599,22 @@ async function init(options) {
 			}
 		}
 	}
+	const pluginReactUpgrade = getPluginReactUpgradeDeps(root);
+	if (pluginReactUpgrade.length > 0) {
+		console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Upgrading devDependencies:"))}`);
+		console.log(formatList(pluginReactUpgrade.map((dep) => dep.replace(/@latest$/, "")), "    "));
+		try {
+			if (shouldInstall) {
+				if (isApproveBuildsError(await installDeps(root, pluginReactUpgrade, exec))) dependencyInstallNeedsApproval = true;
+			} else {
+				const added = addDependencyEntries(root, pluginReactUpgrade, { dev: true });
+				devDependencyEntriesAdded.push(...added);
+			}
+		} catch (error) {
+			if (pmName !== "pnpm" || !isApproveBuildsError(error)) throw error;
+			dependencyInstallNeedsApproval = true;
+		}
+	}
 	if (missingDependencies.length > 0) {
 		console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Installing dependencies:"))}`);
 		console.log(formatList(missingDependencies, "    "));
@@ -576,6 +671,8 @@ 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];

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