devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/vite-CGtVNf5E.js

@@ -0,0 +1,1267 @@
+import { d as resolveConfigEnvVars } from "./preview-C3Cdr8an.js";
+import { i as resolveConfigPath, o as loadResolvedConfig, r as loadConfig, s as resolveResources, u as resolveConfigForEnvironment } from "./loader-Cr0_OWPy.js";
+import { o as normalizeDOBinding } from "./schema-normalization-BCwTLTGp.js";
+import { c as writeWranglerConfig, i as isolateViteBuildOutputPaths, n as compileConfig, o as rebaseWranglerConfigPaths, r as compileToProgrammaticConfig, t as compileBuildConfig } from "./compiler-Zw16C9Pi.js";
+import { h as resolveFetchHandler, i as assertExplicit2ArgStyle } from "./runtime-DL-Nz3k8.js";
+import { s as resolveServiceBindings, t as discoverRoutes } from "./routes-BFYCqHb-.js";
+import { n as findDurableObjectClasses } from "./durable-object-DMtH0XYX.js";
+import { r as SUPPORTED_WORKER_EXTENSIONS } from "./worker-entrypoint-CQW77lG8.js";
+import { i as findFiles, t as DEFAULT_DO_PATTERN } from "./glob-CmQOvunB.js";
+import { dirname, isAbsolute, relative, resolve } from "pathe";
+//#region src/worker-entry/durable-object-discovery.ts
+/**
+* Walk the glob `pattern` under `cwd` and return a map of file path →
+* Durable Object class names declared in that file. Files that fail to read
+* or contain no DO classes are omitted. Respects `.gitignore` automatically
+* (via `findFiles`).
+*/
+async function discoverDurableObjectFiles(cwd, pattern) {
+	const result = /* @__PURE__ */ new Map();
+	const matchedFiles = await findFiles(pattern, { cwd });
+	const fs = await import("node:fs/promises");
+	for (const filePath of matchedFiles) try {
+		const classNames = findDurableObjectClasses(await fs.readFile(filePath, "utf-8"));
+		if (classNames.length > 0) result.set(filePath, classNames);
+	} catch (error) {
+		console.warn(`[devflare] Failed to read DO file: ${filePath}`, error);
+	}
+	return result;
+}
+/**
+* Vite-plugin-shaped wrapper around `discoverDurableObjectFiles`. Returns a
+* `DODiscoveryResult` carrying the discovered file map plus the auxiliary
+* worker name.
+*/
+async function discoverDurableObjects(projectRoot, pattern, workerName) {
+	return {
+		files: await discoverDurableObjectFiles(projectRoot, pattern),
+		workerName
+	};
+}
+//#endregion
+//#region src/vite/plugin-config-hook.ts
+/**
+* Try to load the devflare config without throwing. Returns `null` if the
+* config does not exist (the plugin still works without one).
+*/
+async function tryLoadDevflareConfig(cwd, configPath, command) {
+	try {
+		return await loadConfig({
+			cwd,
+			configFile: configPath
+		});
+	} catch (error) {
+		if (command === "build") console.warn("[devflare] Could not load config:", error);
+		return null;
+	}
+}
+/**
+* Build the `define` map injecting `__DEVFLARE_WORKER_NAME__` as a build-time
+* constant. Caller is responsible for merging this into any existing `define`.
+*/
+function buildWorkerNameDefine(lfConfig, existing) {
+	const workerNameValue = lfConfig.name ?? "unknown";
+	return {
+		...existing,
+		__DEVFLARE_WORKER_NAME__: JSON.stringify(workerNameValue)
+	};
+}
+/**
+* Build the `server.proxy` config that forwards WebSocket upgrades to the
+* Miniflare bridge. Returns `null` when no patterns are configured.
+*/
+function buildWebSocketProxyConfig(lfConfig, bridgePort, wsProxyPatterns) {
+	const patterns = [...wsProxyPatterns];
+	if (lfConfig.wsRoutes && lfConfig.wsRoutes.length > 0) {
+		for (const route of lfConfig.wsRoutes) if (!patterns.includes(route.pattern)) patterns.push(route.pattern);
+	}
+	if (patterns.length === 0) return null;
+	const proxyConfig = {};
+	for (const pattern of patterns) proxyConfig[pattern] = {
+		target: `http://127.0.0.1:${bridgePort}`,
+		changeOrigin: true,
+		ws: true,
+		configure: (proxy) => {
+			proxy.on("error", (err) => {
+				console.error(`[devflare] Proxy error: ${err.message}`);
+			});
+		}
+	};
+	if (Object.keys(proxyConfig).length === 0) return null;
+	console.log(`[devflare] WebSocket proxy configured for: ${patterns.join(", ")}`);
+	return proxyConfig;
+}
+/**
+* Build the additional Vite config returned by the plugin's `config()` hook.
+* Loads the devflare config, derives `define` and (in dev under
+* `DEVFLARE_DEV`) `server.proxy`. Returns `undefined` when there is nothing
+* to merge.
+*/
+async function buildPluginConfigHookResult(cwd, options, command, existingDefine) {
+	const lfConfig = await tryLoadDevflareConfig(cwd, options.configPath, command);
+	const returnConfig = {};
+	if (lfConfig) returnConfig.define = buildWorkerNameDefine(lfConfig, existingDefine);
+	if (command === "serve" && process.env.DEVFLARE_DEV && lfConfig) {
+		const proxyConfig = buildWebSocketProxyConfig(lfConfig, options.bridgePort ?? 8787, options.wsProxyPatterns);
+		if (proxyConfig) returnConfig.server = { proxy: proxyConfig };
+	}
+	return Object.keys(returnConfig).length > 0 ? returnConfig : void 0;
+}
+//#endregion
+//#region src/worker-entry/surface-paths.ts
+const defaultEntriesFor = (surface) => SUPPORTED_WORKER_EXTENSIONS.map((ext) => `src/${surface}${ext}`);
+const DEFAULT_FETCH_ENTRY_FILES = defaultEntriesFor("fetch");
+const DEFAULT_QUEUE_ENTRY_FILES = defaultEntriesFor("queue");
+const DEFAULT_SCHEDULED_ENTRY_FILES = defaultEntriesFor("scheduled");
+const DEFAULT_EMAIL_ENTRY_FILES = defaultEntriesFor("email");
+const DEFAULT_TAIL_ENTRY_FILES = defaultEntriesFor("tail");
+/**
+* Path prefixes that are known framework / bundler build outputs.
+* A handler path that lives under one of these will not exist on disk
+* until the framework's own build (e.g. `vite build`, `svelte-kit build`)
+* has run, which happens AFTER devflare resolves surface paths.
+*/
+const BUILD_OUTPUT_PATH_PREFIXES = [
+	".svelte-kit/",
+	".adapter-cloudflare/",
+	".next/",
+	".nuxt/",
+	".output/",
+	".vercel/",
+	"dist/",
+	"build/",
+	".vinxi/",
+	".solid/"
+];
+/** Returns true when the path looks like a framework build output. */
+function looksLikeBuildArtifactPath(configuredPath) {
+	const normalised = configuredPath.replace(/\\/g, "/").replace(/^\.\//, "");
+	return BUILD_OUTPUT_PATH_PREFIXES.some((prefix) => normalised.startsWith(prefix));
+}
+async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries, surfaceName = "worker") {
+	if (configuredPath === false) return null;
+	const fs = await import("node:fs/promises");
+	if (typeof configuredPath === "string" && configuredPath) {
+		const absolutePath = resolve(cwd, configuredPath);
+		try {
+			await fs.access(absolutePath);
+			return absolutePath;
+		} catch {
+			if (looksLikeBuildArtifactPath(configuredPath)) throw new Error(`Configured ${surfaceName} handler "${configuredPath}" was not found.\n\nThis path looks like a framework build output (e.g. SvelteKit / Vite / Next).\nDevflare resolves handler paths BEFORE your framework runs its build, so the file\ndoes not exist yet at this stage.\n\nRecommended fix — point devflare at the build artifact via wrangler passthrough\ninstead of files.${surfaceName}, so devflare skips composition and lets your\nframework write the worker entry that wrangler/vite then picks up:\n\n    files: { ${surfaceName}: false },\n    wrangler: {\n        passthrough: { main: '${configuredPath}' }\n    }\n\nAlternatively, run your framework build (e.g. \`vite build\`) before \`devflare build\`,\nor move the handler to a source file that exists at config time.`);
+			throw new Error(`Configured ${surfaceName} handler "${configuredPath}" was not found`);
+		}
+	}
+	for (const defaultEntry of defaultEntries) {
+		const absolutePath = resolve(cwd, defaultEntry);
+		try {
+			await fs.access(absolutePath);
+			return absolutePath;
+		} catch {}
+	}
+	return null;
+}
+async function resolveWorkerSurfacePaths(cwd, config) {
+	return {
+		fetch: await resolveWorkerHandlerPath(cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES, "fetch"),
+		queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES, "queue"),
+		scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES, "scheduled"),
+		email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES, "email"),
+		tail: await resolveWorkerHandlerPath(cwd, config.files?.tail, DEFAULT_TAIL_ENTRY_FILES, "tail")
+	};
+}
+function hasWorkerSurfacePaths(surfacePaths) {
+	return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
+}
+//#endregion
+//#region src/worker-entry/validate-fetch-style.ts
+/**
+* Validate the resolved fetch surface module's calling-convention style.
+*
+* `fetchSurfacePath` is the absolute, on-disk path devflare resolved for the
+* fetch surface (`WorkerSurfacePaths.fetch`). When it is `null` there is no
+* fetch surface to check.
+*
+* Throws the same `[devflare] Ambiguous 2-argument fetch handler …` error as
+* the request-time check when the export is an unmarked 2-arg handler.
+*/
+async function validateFetchHandlerStyle(fetchSurfacePath) {
+	if (!fetchSurfacePath) return;
+	if (looksLikeBuildArtifactPath(fetchSurfacePath)) return;
+	let surfaceModule;
+	try {
+		surfaceModule = await import(fetchSurfacePath);
+	} catch {
+		return;
+	}
+	let handler;
+	try {
+		handler = resolveFetchHandler(surfaceModule);
+	} catch {
+		return;
+	}
+	if (!handler) return;
+	assertExplicit2ArgStyle(handler);
+}
+//#endregion
+//#region src/worker-entry/composed-worker.ts
+/**
+* Minimal structured codegen helper used to emit the composed worker module.
+* Each method appends a discrete "section" to the output; sections are joined
+* by a single newline when rendered, which matches the shape previously
+* produced by the hand-written template literal.
+*/
+var CodeBuilder = class {
+	sections = [];
+	importStatement(specifiers, from) {
+		this.sections.push(`import { ${specifiers.join(", ")} } from '${from}'`);
+		return this;
+	}
+	importNamespace(identifier, from) {
+		this.sections.push(`import * as ${identifier} from '${from}'`);
+		return this;
+	}
+	reExport(names, from) {
+		this.sections.push(`export { ${names.join(", ")} } from '${from}'`);
+		return this;
+	}
+	constDeclaration(name, value) {
+		this.sections.push(`const ${name} = ${value}`);
+		return this;
+	}
+	classDeclaration(body) {
+		this.sections.push(body);
+		return this;
+	}
+	exportDefault(body) {
+		this.sections.push(`export default ${body}`);
+		return this;
+	}
+	raw(text) {
+		this.sections.push(text);
+		return this;
+	}
+	blank() {
+		this.sections.push("");
+		return this;
+	}
+	toString() {
+		return this.sections.join("\n");
+	}
+};
+const DEV_ONLY_EMAIL_HOOKS_SOURCE = `
+function __devflareCreateEmailHeaders(rawBody) {
+	const headers = new Headers()
+	const lines = rawBody.split(/\\r?\\n/)
+
+	for (const line of lines) {
+		if (line.trim() === '') {
+			break
+		}
+
+		const colonIndex = line.indexOf(':')
+		if (colonIndex <= 0) {
+			continue
+		}
+
+		headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim())
+	}
+
+	return headers
+}
+
+function __devflareCreateEmailRawStream(rawBody) {
+	return new ReadableStream({
+		start(controller) {
+			controller.enqueue(new TextEncoder().encode(rawBody))
+			controller.close()
+		}
+	})
+}
+
+async function __devflareHandleInternalEmail(request, env, ctx) {
+	if (!__devflareEmailHandler) {
+		return new Response('Email handler not configured', { status: 501 })
+	}
+
+	const from = request.headers.get('x-devflare-email-from') || 'unknown@example.com'
+	const to = request.headers.get('x-devflare-email-to') || 'worker@example.com'
+	const rawBody = await request.text()
+	const emailMessage = {
+		from,
+		to,
+		headers: __devflareCreateEmailHeaders(rawBody),
+		raw: __devflareCreateEmailRawStream(rawBody),
+		rawSize: rawBody.length,
+		setReject(reason) {
+			console.warn('[Devflare email rejected]', reason)
+		},
+		async forward(rcptTo) {
+			console.log('[Devflare email forwarded]', rcptTo)
+			return Promise.resolve()
+		},
+		async reply(message) {
+			console.log('[Devflare email reply sent]', message?.from)
+			return Promise.resolve()
+		}
+	}
+
+	const __devflareEvent = createEmailEvent(emailMessage, env, ctx)
+
+	await runWithEventContext(
+		__devflareEvent,
+		() => __devflareEmailHandler(__devflareEvent, env, ctx)
+	)
+
+	return new Response(JSON.stringify({ ok: true, from, to }), {
+		headers: { 'Content-Type': 'application/json' }
+	})
+}
+`;
+function emitDevOnlyEmailHooks(builder, options) {
+	if (!options.enabled) return;
+	builder.raw(DEV_ONLY_EMAIL_HOOKS_SOURCE);
+}
+const RESOLVE_HANDLER_DECLARATION = `const __devflareResolveHandler = (module, namedExport) => {
+	const defaultExport = module.default
+
+	if (typeof defaultExport === 'function') {
+		return defaultExport
+	}
+
+	if (defaultExport && typeof defaultExport[namedExport] === 'function') {
+		return defaultExport[namedExport].bind(defaultExport)
+	}
+
+	if (typeof module[namedExport] === 'function') {
+		return module[namedExport]
+	}
+
+	return null
+}`;
+function buildDefaultExportBody(options) {
+	const devOnlyEmailEntry = options.includeDevOnlyHooks ? `const url = new URL(request.url)
+
+				if (
+					request.headers.get('x-devflare-event') === 'email'
+					&& url.pathname === '/_devflare/internal/email'
+				) {
+					return __devflareHandleInternalEmail(request, env, ctx)
+				}
+
+				` : "";
+	return `{
+	...(${options.hasFetchDispatch ? "true" : "false"}
+		? {
+			async fetch(request, env, ctx) {
+				${devOnlyEmailEntry}const __devflareInitialRouteMatch = __devflareHasRoutes ? matchFetchRoute(__devflareRoutes, request) : null
+				const __devflareEvent = createFetchEvent(request, env, ctx, {
+					params: __devflareInitialRouteMatch?.params ?? {}
+				})
+				return runWithEventContext(
+					__devflareEvent,
+					() => invokeFetchModule(
+						__devflareFetchModule,
+						__devflareEvent,
+						__devflareHasRoutes
+							? createRouteResolve(__devflareRoutes, __devflareEvent)
+							: undefined
+					)
+				)
+			}
+		}
+		: {}),
+	...(__devflareQueueHandler
+		? {
+			async queue(batch, env, ctx) {
+				assertExplicitQueueHandlerStyle(__devflareQueueHandler)
+				const __devflareEvent = createQueueEvent(batch, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareQueueHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareScheduledHandler
+		? {
+			async scheduled(controller, env, ctx) {
+				assertExplicitScheduledHandlerStyle(__devflareScheduledHandler)
+				const __devflareEvent = createScheduledEvent(controller, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareScheduledHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareEmailHandler
+		? {
+			async email(message, env, ctx) {
+				const __devflareEvent = createEmailEvent(message, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareEmailHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareTailHandler
+		? {
+			async tail(events, env, ctx) {
+				const __devflareEvent = createTailEvent(events, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareTailHandler.length >= 2
+						? __devflareTailHandler(events, env, ctx)
+						: __devflareTailHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {})
+}`;
+}
+function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, durableObjectExports = [], routeImports = [], options = {}) {
+	const includeDevOnlyHooks = options.includeDevOnlyHooks ?? options.devInternalEmail === true;
+	const importsBuilder = new CodeBuilder();
+	importsBuilder.importStatement([
+		"assertExplicitQueueHandlerStyle",
+		"assertExplicitScheduledHandlerStyle",
+		"createEmailEvent",
+		"createFetchEvent",
+		"createQueueEvent",
+		"createRouteResolve",
+		"createScheduledEvent",
+		"createTailEvent",
+		"invokeFetchModule",
+		"matchFetchRoute",
+		"runWithEventContext",
+		"setLocalSendEmailBindings"
+	], "devflare/runtime");
+	const fallbackModules = [
+		{
+			identifier: "__devflareFetchModule",
+			importPath: surfaceImportPaths.fetch
+		},
+		{
+			identifier: "__devflareQueueModule",
+			importPath: surfaceImportPaths.queue
+		},
+		{
+			identifier: "__devflareScheduledModule",
+			importPath: surfaceImportPaths.scheduled
+		},
+		{
+			identifier: "__devflareEmailModule",
+			importPath: surfaceImportPaths.email
+		},
+		{
+			identifier: "__devflareTailModule",
+			importPath: surfaceImportPaths.tail
+		}
+	];
+	const fallbacksBuilder = new CodeBuilder();
+	for (const { identifier, importPath } of fallbackModules) if (importPath) importsBuilder.importNamespace(identifier, importPath);
+	else fallbacksBuilder.constDeclaration(identifier, "{}");
+	for (const routeImport of routeImports) importsBuilder.importNamespace(routeImport.identifier, routeImport.importPath);
+	const reExportsBuilder = new CodeBuilder();
+	for (const { classNames, importPath } of durableObjectExports) reExportsBuilder.reExport(classNames, importPath);
+	const routeManifestEntries = routeImports.map(({ identifier, filePath, routePath, segmentsJson }) => {
+		return `\t{ filePath: ${JSON.stringify(filePath)}, routePath: ${JSON.stringify(routePath)}, segments: ${segmentsJson}, module: ${identifier} }`;
+	});
+	const builder = new CodeBuilder();
+	builder.raw(importsBuilder.toString());
+	builder.raw(fallbacksBuilder.toString());
+	builder.raw(reExportsBuilder.toString());
+	builder.blank();
+	builder.raw(`setLocalSendEmailBindings(${JSON.stringify(configuredLocalSendEmailBindings)})`);
+	builder.blank();
+	builder.constDeclaration("__devflareHasFetchModule", surfaceImportPaths.fetch ? "true" : "false");
+	builder.raw(`const __devflareRoutes = [\n${routeManifestEntries.join(",\n")}\n]`);
+	builder.constDeclaration("__devflareHasRoutes", "__devflareRoutes.length > 0");
+	builder.blank();
+	builder.raw(RESOLVE_HANDLER_DECLARATION);
+	builder.blank();
+	builder.constDeclaration("__devflareQueueHandler", "__devflareResolveHandler(__devflareQueueModule, 'queue')");
+	builder.constDeclaration("__devflareScheduledHandler", "__devflareResolveHandler(__devflareScheduledModule, 'scheduled')");
+	builder.constDeclaration("__devflareEmailHandler", "__devflareResolveHandler(__devflareEmailModule, 'email')");
+	builder.constDeclaration("__devflareTailHandler", "__devflareResolveHandler(__devflareTailModule, 'tail')");
+	emitDevOnlyEmailHooks(builder, { enabled: includeDevOnlyHooks });
+	builder.blank();
+	builder.exportDefault(buildDefaultExportBody({
+		hasFetchDispatch: Boolean(surfaceImportPaths.fetch) || routeImports.length > 0 || includeDevOnlyHooks,
+		includeDevOnlyHooks
+	}));
+	builder.raw("");
+	return builder.toString();
+}
+function toImportSpecifier(fromFilePath, toFilePath) {
+	const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
+	return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
+	if (!routeDiscovery) return [];
+	return routeDiscovery.routes.map((route, index) => ({
+		identifier: `__devflareRouteModule${index}`,
+		importPath: toImportSpecifier(entryPath, route.absolutePath),
+		filePath: route.filePath,
+		routePath: route.routePath,
+		segmentsJson: JSON.stringify(route.segments)
+	}));
+}
+async function createGeneratedDurableObjectExports(entryPath, cwd, config) {
+	if (config.files?.durableObjects === false || !config.bindings?.durableObjects) return [];
+	const localClassNames = new Set(Object.values(config.bindings.durableObjects).map((binding) => normalizeDOBinding(binding)).filter((binding) => binding.kind === "local").map((binding) => binding.className));
+	if (localClassNames.size === 0) return [];
+	const discoveredFiles = await discoverDurableObjectFiles(cwd, typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN);
+	const exports = [];
+	const discoveredClassNames = /* @__PURE__ */ new Set();
+	for (const [filePath, allClassNames] of discoveredFiles) {
+		const classNames = allClassNames.filter((className) => localClassNames.has(className));
+		if (classNames.length === 0) continue;
+		for (const className of classNames) discoveredClassNames.add(className);
+		exports.push({
+			importPath: toImportSpecifier(entryPath, filePath),
+			filePath,
+			classNames
+		});
+	}
+	const missingClassNames = Array.from(localClassNames).filter((className) => !discoveredClassNames.has(className));
+	if (missingClassNames.length > 0) throw new Error(`Failed to discover local Durable Object class${missingClassNames.length === 1 ? "" : "es"} ${missingClassNames.join(", ")} for worker composition. Ensure files.durableObjects matches the source file pattern for your do.* files.`);
+	return exports;
+}
+/**
+* Returns true when the resolved config has any composition signal other than
+* `files.fetch` (queue / scheduled / email handler files, durable-object
+* bindings, sendEmail bindings, or routes). Used to decide whether a missing
+* build-artifact fetch path can be safely deferred to wrangler/vite.
+*/
+function mayRequireCompositionBesidesFetch(config) {
+	const files = config.files ?? {};
+	if (typeof files.queue === "string" && files.queue) return true;
+	if (typeof files.scheduled === "string" && files.scheduled) return true;
+	if (typeof files.email === "string" && files.email) return true;
+	if (typeof files.tail === "string" && files.tail) return true;
+	if (files.durableObjects) return true;
+	if (files.routes) return true;
+	const bindings = config.bindings ?? {};
+	const doBindings = bindings.durableObjects;
+	if (doBindings && Object.keys(doBindings).length > 0) return true;
+	const sendEmail = bindings.sendEmail;
+	if (sendEmail && Object.keys(sendEmail).length > 0) return true;
+	return false;
+}
+function needsComposedWorkerEntrypoint(cwd, surfacePaths, config, routeDiscovery) {
+	if (Boolean(surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || surfacePaths.tail || routeDiscovery?.routes.length)) return true;
+	if (!surfacePaths.fetch) return false;
+	const assetsDirectory = config.assets?.directory;
+	if (assetsDirectory) {
+		const generatedAssetsWorkerPath = resolve(cwd, assetsDirectory, "_worker.js");
+		if (surfacePaths.fetch === generatedAssetsWorkerPath) return false;
+	}
+	return Boolean(surfacePaths.fetch);
+}
+async function prepareComposedWorkerEntrypoint(cwd, config, environment, options = {}) {
+	const resolvedConfig = resolveConfigForEnvironment(config, environment);
+	if (resolvedConfig.wrangler?.passthrough && Object.prototype.hasOwnProperty.call(resolvedConfig.wrangler.passthrough, "main")) return null;
+	const configuredFetch = resolvedConfig.files?.fetch;
+	if (typeof configuredFetch === "string" && looksLikeBuildArtifactPath(configuredFetch)) {
+		const fs = await import("node:fs/promises");
+		const fetchAbsolute = resolve(cwd, configuredFetch);
+		let fetchExists = true;
+		try {
+			await fs.access(fetchAbsolute);
+		} catch {
+			fetchExists = false;
+		}
+		if (!fetchExists && !mayRequireCompositionBesidesFetch(resolvedConfig)) return null;
+	}
+	const surfacePaths = await resolveWorkerSurfacePaths(cwd, resolvedConfig);
+	const routeDiscovery = await discoverRoutes(cwd, resolvedConfig);
+	if (!needsComposedWorkerEntrypoint(cwd, surfacePaths, resolvedConfig, routeDiscovery)) return null;
+	await validateFetchHandlerStyle(surfacePaths.fetch);
+	const fs = await import("node:fs/promises");
+	const entryDir = resolve(cwd, ".devflare", "worker-entrypoints");
+	const entryPath = resolve(entryDir, "main.ts");
+	await fs.mkdir(entryDir, { recursive: true });
+	const surfaceImportPaths = {
+		fetch: surfacePaths.fetch ? toImportSpecifier(entryPath, surfacePaths.fetch) : null,
+		queue: surfacePaths.queue ? toImportSpecifier(entryPath, surfacePaths.queue) : null,
+		scheduled: surfacePaths.scheduled ? toImportSpecifier(entryPath, surfacePaths.scheduled) : null,
+		email: surfacePaths.email ? toImportSpecifier(entryPath, surfacePaths.email) : null,
+		tail: surfacePaths.tail ? toImportSpecifier(entryPath, surfacePaths.tail) : null
+	};
+	const durableObjectExports = await createGeneratedDurableObjectExports(entryPath, cwd, resolvedConfig);
+	const routeImports = createGeneratedRouteModuleImports(entryPath, routeDiscovery);
+	await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, durableObjectExports, routeImports, options));
+	return entryPath;
+}
+//#endregion
+//#region src/vite/plugin-durable-objects.ts
+const VIRTUAL_DO_ENTRY = "virtual:devflare-do-entry";
+const RESOLVED_VIRTUAL_DO_ENTRY = "\0" + VIRTUAL_DO_ENTRY;
+/**
+* Generate virtual DO entry module code
+*/
+function generateVirtualDOEntry(discovery) {
+	const lines = [
+		"// Auto-generated by devflare — DO entry module",
+		"// Re-exports all Durable Object classes discovered from files.durableObjects pattern",
+		""
+	];
+	for (const [filePath, classNames] of discovery.files) {
+		const normalizedPath = filePath.replace(/\\/g, "/");
+		lines.push(`export { ${classNames.join(", ")} } from '${normalizedPath}'`);
+	}
+	lines.push("");
+	lines.push("// Default fetch handler for DO worker");
+	lines.push("export default {");
+	lines.push("	async fetch(request: Request): Promise<Response> {");
+	lines.push("		return new Response(\"Devflare DO Worker\", { status: 200 })");
+	lines.push("	}");
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Create auxiliary worker config for Durable Objects
+*/
+function createAuxiliaryWorkerConfig(wranglerConfig, discovery) {
+	const doBindings = wranglerConfig.durable_objects?.bindings?.map((binding) => ({
+		name: binding.name,
+		class_name: binding.class_name
+	})) ?? [];
+	return { config: {
+		name: discovery.workerName,
+		main: VIRTUAL_DO_ENTRY,
+		compatibility_date: wranglerConfig.compatibility_date,
+		compatibility_flags: wranglerConfig.compatibility_flags,
+		durable_objects: { bindings: doBindings },
+		migrations: wranglerConfig.migrations,
+		kv_namespaces: wranglerConfig.kv_namespaces,
+		d1_databases: wranglerConfig.d1_databases,
+		r2_buckets: wranglerConfig.r2_buckets,
+		browser: wranglerConfig.browser
+	} };
+}
+function logDiscoveredDurableObjects(projectRoot, discovery) {
+	if (!discovery || discovery.files.size === 0) return;
+	console.log(`[devflare] Discovered ${discovery.files.size} DO file(s):`);
+	for (const [filePath, classes] of discovery.files) console.log(`  • ${filePath.replace(projectRoot, ".")} → ${classes.join(", ")}`);
+}
+//#endregion
+//#region src/vite/plugin-service-bindings.ts
+const VIRTUAL_SERVICE_WORKER_PREFIX = "virtual:devflare-service-worker/";
+const RESOLVED_VIRTUAL_SERVICE_WORKER_PREFIX = "\0" + VIRTUAL_SERVICE_WORKER_PREFIX;
+function virtualServiceWorkerId(workerName) {
+	return `${VIRTUAL_SERVICE_WORKER_PREFIX}${encodeURIComponent(workerName)}`;
+}
+function resolvedVirtualServiceWorkerId(workerName) {
+	return `${RESOLVED_VIRTUAL_SERVICE_WORKER_PREFIX}${encodeURIComponent(workerName)}`;
+}
+function objectEntries(record) {
+	return record ? Object.entries(record) : [];
+}
+function toWranglerDurableObjectBinding(name, value) {
+	if (typeof value === "string") return {
+		name,
+		class_name: value
+	};
+	return {
+		name,
+		class_name: value.className,
+		script_name: value.scriptName
+	};
+}
+function toWranglerWorkerConfig(worker) {
+	const queueProducers = worker.queueProducers ? objectEntries(worker.queueProducers).map(([binding, producer]) => ({
+		binding,
+		queue: producer.queueName
+	})) : void 0;
+	const queueConsumers = worker.queueConsumers ? objectEntries(worker.queueConsumers).map(([queue, consumer]) => ({
+		queue,
+		...consumer.maxBatchSize !== void 0 && { max_batch_size: consumer.maxBatchSize },
+		...consumer.maxBatchTimeout !== void 0 && { max_batch_timeout: consumer.maxBatchTimeout },
+		...consumer.maxRetries !== void 0 && { max_retries: consumer.maxRetries },
+		...typeof consumer.deadLetterQueue === "string" && { dead_letter_queue: consumer.deadLetterQueue },
+		...consumer.maxConcurrency !== void 0 && { max_concurrency: consumer.maxConcurrency },
+		...consumer.retryDelay !== void 0 && { retry_delay: consumer.retryDelay }
+	})) : void 0;
+	const queues = queueProducers || queueConsumers ? {
+		...queueProducers && { producers: queueProducers },
+		...queueConsumers && { consumers: queueConsumers }
+	} : void 0;
+	const durableObjectBindings = worker.durableObjects ? objectEntries(worker.durableObjects).map(([name, value]) => toWranglerDurableObjectBinding(name, value)) : [];
+	const serviceBindings = worker.serviceBindings ? objectEntries(worker.serviceBindings).map(([binding, target]) => ({
+		binding,
+		service: target.name,
+		...target.entrypoint && { entrypoint: target.entrypoint }
+	})) : [];
+	return {
+		name: worker.name,
+		main: virtualServiceWorkerId(worker.name),
+		compatibility_date: worker.compatibilityDate,
+		...worker.compatibilityFlags && { compatibility_flags: worker.compatibilityFlags },
+		...worker.bindings && { vars: worker.bindings },
+		...worker.kvNamespaces && { kv_namespaces: objectEntries(worker.kvNamespaces).map(([binding, id]) => ({
+			binding,
+			id
+		})) },
+		...worker.r2Buckets && { r2_buckets: objectEntries(worker.r2Buckets).map(([binding, bucket_name]) => ({
+			binding,
+			bucket_name
+		})) },
+		...worker.d1Databases && { d1_databases: objectEntries(worker.d1Databases).map(([binding, database_id]) => ({
+			binding,
+			database_id,
+			database_name: database_id
+		})) },
+		...durableObjectBindings.length > 0 && { durable_objects: { bindings: durableObjectBindings } },
+		...serviceBindings.length > 0 && { services: serviceBindings },
+		...queues && { queues }
+	};
+}
+function createAuxiliaryServiceWorkerConfigs(resolution) {
+	if (!resolution || resolution.workers.length === 0) return {
+		auxiliaryWorkers: [],
+		virtualModules: /* @__PURE__ */ new Map()
+	};
+	const virtualModules = /* @__PURE__ */ new Map();
+	return {
+		auxiliaryWorkers: resolution.workers.map((worker) => {
+			virtualModules.set(resolvedVirtualServiceWorkerId(worker.name), worker.script);
+			return { config: toWranglerWorkerConfig(worker) };
+		}),
+		virtualModules
+	};
+}
+//#endregion
+//#region src/vite/plugin-context.ts
+const CONFIG_DIR$2 = ".devflare";
+function removeDevflareHandledServeBindings(config) {
+	const next = { ...config };
+	delete next.workflows;
+	delete next.media;
+	return next;
+}
+/**
+* Compile a DevflareConfig into the bundle of artefacts the Vite plugin
+* exposes to consumers (wrangler config, cloudflare-plugin programmatic
+* config, auxiliary DO worker, discovered DOs).
+*
+* Mode discriminator:
+* - `'serve'` — materialize names into stable local identifiers
+*   (miniflare-friendly).
+* - `'build'` — preserve names in the emitted Wrangler artefact so deploy
+*   can later resolve them against the real Cloudflare account.
+*/
+async function buildPluginContextState(projectRoot, devflareConfig, environment, mode = "serve", configDir = projectRoot) {
+	const effectiveConfig = await resolveConfigEnvVars(mode === "build" ? await resolveResources(devflareConfig, {
+		phase: "build",
+		environment
+	}) : await resolveResources(devflareConfig, {
+		phase: "local",
+		environment
+	}), {
+		cwd: configDir,
+		mode: mode === "build" ? "build" : "dev"
+	});
+	const compiledWranglerConfig = mode === "build" ? compileBuildConfig(effectiveConfig) : compileConfig(effectiveConfig);
+	const wranglerConfig = mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compiledWranglerConfig) : removeDevflareHandledServeBindings(compiledWranglerConfig);
+	const cloudflareConfig = { ...mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compileToProgrammaticConfig(effectiveConfig, environment, { preserveNamedBindings: true })) : removeDevflareHandledServeBindings(compileToProgrammaticConfig(effectiveConfig, environment)) };
+	const composedMainEntry = mode === "build" ? null : await prepareComposedWorkerEntrypoint(projectRoot, effectiveConfig, environment);
+	if (composedMainEntry) {
+		const relativeMain = relative(projectRoot, composedMainEntry);
+		wranglerConfig.main = relativeMain;
+		cloudflareConfig.main = relativeMain;
+	}
+	let durableObjects = null;
+	let auxiliaryWorkerConfig = null;
+	let serviceWorkerVirtualModules = /* @__PURE__ */ new Map();
+	let serviceAuxiliaryWorkerConfigs = [];
+	const doPatternConfig = effectiveConfig.files?.durableObjects;
+	const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
+	if (doPatternConfig !== false) {
+		const doWorkerName = `${wranglerConfig.name}-do`;
+		const discovery = await discoverDurableObjects(projectRoot, doPattern, doWorkerName);
+		if (discovery.files.size > 0) {
+			durableObjects = discovery;
+			if (wranglerConfig.durable_objects?.bindings) for (const binding of wranglerConfig.durable_objects.bindings) binding.script_name = doWorkerName;
+			if (cloudflareConfig.durable_objects) {
+				const doConfig = cloudflareConfig.durable_objects;
+				for (const binding of doConfig.bindings) binding.script_name = doWorkerName;
+			}
+			auxiliaryWorkerConfig = createAuxiliaryWorkerConfig(wranglerConfig, discovery);
+		}
+	}
+	if (mode === "serve" && effectiveConfig.bindings?.services) {
+		const serviceWorkers = createAuxiliaryServiceWorkerConfigs(await resolveServiceBindings(effectiveConfig, configDir));
+		serviceAuxiliaryWorkerConfigs = serviceWorkers.auxiliaryWorkers;
+		serviceWorkerVirtualModules = serviceWorkers.virtualModules;
+	}
+	return {
+		wranglerConfig,
+		cloudflareConfig,
+		auxiliaryWorkerConfigs: [...auxiliaryWorkerConfig ? [auxiliaryWorkerConfig] : [], ...serviceAuxiliaryWorkerConfigs],
+		serviceWorkerVirtualModules,
+		durableObjects,
+		auxiliaryWorkerConfig
+	};
+}
+async function ensureGeneratedConfigDir$1(projectRoot) {
+	const configDir = resolve(projectRoot, CONFIG_DIR$2);
+	const fs = await import("node:fs/promises");
+	await fs.mkdir(configDir, { recursive: true });
+	const gitignorePath = resolve(configDir, ".gitignore");
+	try {
+		await fs.access(gitignorePath);
+	} catch {
+		await fs.writeFile(gitignorePath, "*\n", "utf-8");
+	}
+	return configDir;
+}
+async function writeGeneratedWranglerConfig(projectRoot, wranglerConfig) {
+	const configDir = await ensureGeneratedConfigDir$1(projectRoot);
+	await writeWranglerConfig(configDir, rebaseWranglerConfigPaths(projectRoot, configDir, wranglerConfig), "wrangler.jsonc");
+}
+async function resolvePluginConfigPath(projectRoot, configPath) {
+	if (configPath) return isAbsolute(configPath) ? configPath : resolve(projectRoot, configPath);
+	return await resolveConfigPath(projectRoot) ?? null;
+}
+//#endregion
+//#region src/vite/plugin-transform.ts
+const TRANSFORMABLE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js"
+];
+/**
+* Returns `true` when devflare may rewrite the given module. Skips
+* `node_modules` and any file that isn't a `.ts`/`.tsx`/`.js`.
+*/
+function isTransformCandidate(id) {
+	if (id.includes("node_modules")) return false;
+	return TRANSFORMABLE_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Worker-entrypoint instrumentation step.
+*
+* Only handles `worker.ts` / `worker.js` files and only when
+* `shouldTransformWorker` accepts them. Returns `null` when this step does
+* not apply, so the caller can fall through to other transforms.
+*/
+async function runWorkerEntryTransform(code, id) {
+	if (!id.endsWith("worker.ts") && !id.endsWith("worker.js")) return null;
+	const { shouldTransformWorker, transformWorkerEntrypoint } = await import("./worker-entrypoint-CQW77lG8.js").then((n) => n.n);
+	if (!shouldTransformWorker(code, id)) return null;
+	const result = transformWorkerEntrypoint(code, id);
+	if (!result) return null;
+	return {
+		code: result.code,
+		map: result.map
+	};
+}
+/**
+* Durable Object class transform step.
+*
+* Only runs when the user opted in via `doTransforms` and the source mentions
+* `DurableObject` or the `@durableObject` decorator. Returns `null` when this
+* step does not apply.
+*/
+async function runDurableObjectTransform(code, id, options) {
+	if (!options.doTransforms) return null;
+	if (!code.includes("DurableObject") && !code.includes("@durableObject")) return null;
+	const { transformDurableObject } = await import("./durable-object-DMtH0XYX.js").then((n) => n.t);
+	return transformDurableObject(code, id);
+}
+/**
+* Apply devflare's source-level transforms to a single module.
+*
+* Order:
+* 1. Worker-entrypoint instrumentation (`runWorkerEntryTransform`)
+* 2. Durable Object class transform (`runDurableObjectTransform`)
+*
+* Returns `null` when no transform applies, mirroring Vite's transform-hook
+* contract.
+*/
+async function runDevflareTransform(code, id, options) {
+	if (!isTransformCandidate(id)) return null;
+	const workerResult = await runWorkerEntryTransform(code, id);
+	if (workerResult) return workerResult;
+	return await runDurableObjectTransform(code, id, options);
+}
+//#endregion
+//#region src/vite/plugin-programmatic.ts
+async function loadProgrammaticDevflareConfig(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const strategy = options.resolve ?? "offline-local";
+	return {
+		cwd,
+		devflareConfig: await resolveConfigEnvVars(strategy === "remote" ? await loadResolvedConfig({
+			cwd,
+			configFile: options.configPath,
+			environment: options.environment
+		}) : await resolveResources(await loadConfig({
+			cwd,
+			configFile: options.configPath
+		}), {
+			phase: "local",
+			environment: options.environment
+		}), {
+			cwd,
+			configPath: options.configPath,
+			mode: strategy === "remote" ? "build" : "dev"
+		})
+	};
+}
+/**
+* Single canonical builder for programmatic config artifacts.
+*
+* Both public helpers (`getCloudflareConfig`, `getDevflareConfigs`) project
+* out of this. The function loads the devflare config, prepares the composed
+* worker entrypoint, compiles the wrangler config, derives the matching
+* cloudflare-vite-plugin config (with optional `programmatic` projection),
+* and discovers auxiliary DO workers when applicable.
+*/
+async function buildProgrammaticArtifacts(options, mode) {
+	const { cwd, devflareConfig } = await loadProgrammaticDevflareConfig(options);
+	const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig);
+	const wranglerConfig = compileConfig(devflareConfig);
+	const cloudflareConfig = mode === "programmatic" ? compileToProgrammaticConfig(devflareConfig) : { ...wranglerConfig };
+	if (composedMainEntry) {
+		const relativeMain = relative(cwd, composedMainEntry);
+		wranglerConfig.main = relativeMain;
+		cloudflareConfig.main = relativeMain;
+	}
+	const auxiliaryWorkers = [];
+	const doPatternConfig = devflareConfig.files?.durableObjects;
+	const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
+	if (doPatternConfig !== false) {
+		const doWorkerName = `${wranglerConfig.name}-do`;
+		const discovery = await discoverDurableObjects(cwd, doPattern, doWorkerName);
+		if (discovery.files.size > 0) {
+			if (cloudflareConfig.durable_objects) {
+				const doConfig = cloudflareConfig.durable_objects;
+				for (const binding of doConfig.bindings) binding.script_name = doWorkerName;
+			}
+			auxiliaryWorkers.push(createAuxiliaryWorkerConfig(wranglerConfig, discovery));
+		}
+	}
+	if (devflareConfig.bindings?.services) {
+		const serviceBindingResolution = await resolveServiceBindings(devflareConfig, cwd);
+		auxiliaryWorkers.push(...createAuxiliaryServiceWorkerConfigs(serviceBindingResolution).auxiliaryWorkers);
+	}
+	return {
+		cwd,
+		devflareConfig,
+		composedMainEntry,
+		wranglerConfig,
+		cloudflareConfig,
+		auxiliaryWorkers
+	};
+}
+/**
+* Get cloudflare config for programmatic use with @cloudflare/vite-plugin.
+* Call this in vite.config.ts before setting up plugins.
+*
+* By default the config is resolved **offline** using local stable
+* identifiers (no Cloudflare credentials required — matches the Miniflare /
+* workerd behaviour of `vite dev`). Pass `{ resolve: 'remote' }` to restore
+* the legacy behaviour that talks to the Cloudflare API and fails without
+* credentials (e.g. when you want the programmatic config to reflect real
+* production IDs during an automation script).
+*/
+async function getCloudflareConfig(options = {}) {
+	const { cloudflareConfig } = await buildProgrammaticArtifacts(options, "programmatic");
+	return cloudflareConfig;
+}
+/**
+* Get auxiliary worker configs for Durable Objects
+* Use this when configuring @cloudflare/vite-plugin's auxiliaryWorkers option
+*
+* @example
+* ```ts
+* const { cloudflareConfig, auxiliaryWorkers } = await getDevflareConfigs()
+*
+* cloudflare({
+*   config: cloudflareConfig,
+*   auxiliaryWorkers
+* })
+* ```
+*/
+async function getDevflareConfigs(options = {}) {
+	const { cloudflareConfig, auxiliaryWorkers } = await buildProgrammaticArtifacts(options, "wrangler");
+	return {
+		cloudflareConfig,
+		auxiliaryWorkers
+	};
+}
+//#endregion
+//#region src/vite/plugin.ts
+const CONFIG_DIR$1 = ".devflare";
+function createPluginState() {
+	return {
+		context: {
+			wranglerConfig: null,
+			cloudflareConfig: null,
+			projectRoot: process.cwd(),
+			auxiliaryWorkerConfig: null,
+			auxiliaryWorkerConfigs: [],
+			serviceWorkerVirtualModules: /* @__PURE__ */ new Map(),
+			durableObjects: null
+		},
+		projectRoot: process.cwd(),
+		devflareConfig: null,
+		resolvedPluginConfigPath: null
+	};
+}
+/**
+* Reload `devflare.config.ts`, rebuild the plugin context state, mutate the
+* shared plugin state in-place, and write the generated wrangler config to
+* disk. Used by both `configResolved` (initial load) and the `configureServer`
+* watcher (HMR reload).
+*/
+async function loadAndApplyConfig(state, options, mode, onContextUpdated) {
+	state.devflareConfig = await loadConfig({
+		cwd: state.projectRoot,
+		configFile: options.configPath
+	});
+	const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, options.environment, mode, state.resolvedPluginConfigPath ? dirname(state.resolvedPluginConfigPath) : state.projectRoot);
+	Object.assign(state.context, {
+		projectRoot: state.projectRoot,
+		...pluginState
+	});
+	onContextUpdated(state.context);
+	logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
+	await writeGeneratedWranglerConfig(state.projectRoot, pluginState.wranglerConfig);
+}
+let lastPluginContext = createPluginState().context;
+/**
+* Get the compiled config context
+* Can be used by other plugins or CLI commands
+*/
+function getPluginContext() {
+	return lastPluginContext;
+}
+/**
+* Devflare Vite Plugin
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { defineConfig } from 'vite'
+* import { sveltekit } from '@sveltejs/kit/vite'
+* import { devflarePlugin, getPluginContext } from 'devflare/vite'
+* import { cloudflare } from '@cloudflare/vite-plugin'
+*
+* export default defineConfig(async () => {
+*   // First, run devflare to get context
+*   const lfPlugin = devflarePlugin()
+*
+*   return {
+*     plugins: [
+*       lfPlugin,
+*       sveltekit(),
+*       // Access context after configResolved
+*       cloudflare({
+*         config: getPluginContext().cloudflareConfig,
+*         auxiliaryWorkers: getPluginContext().auxiliaryWorkerConfigs.length > 0
+*           ? getPluginContext().auxiliaryWorkerConfigs
+*           : undefined
+*       })
+*     ]
+*   }
+* })
+* ```
+*/
+function devflarePlugin(options = {}) {
+	const { configPath, environment, doTransforms = true, watchConfig = true, bridgePort = process.env.DEVFLARE_BRIDGE_PORT ? Number.parseInt(process.env.DEVFLARE_BRIDGE_PORT, 10) : void 0, wsProxyPatterns = [] } = options;
+	const state = createPluginState();
+	return {
+		name: "devflare",
+		enforce: "pre",
+		async config(config, { command }) {
+			return buildPluginConfigHookResult(config.root ?? process.cwd(), {
+				configPath,
+				bridgePort,
+				wsProxyPatterns
+			}, command, config.define ?? {});
+		},
+		resolveId(id) {
+			if (id === "virtual:devflare-do-entry") return RESOLVED_VIRTUAL_DO_ENTRY;
+			if (id.startsWith("virtual:devflare-service-worker/")) return "\0" + id;
+			return null;
+		},
+		async load(id) {
+			if (id === "\0virtual:devflare-do-entry") {
+				if (!state.context.durableObjects) return "// No Durable Objects configured\nexport default { fetch: () => new Response(\"No DOs\") }";
+				return generateVirtualDOEntry(state.context.durableObjects);
+			}
+			if (id.startsWith("\0virtual:devflare-service-worker/")) return state.context.serviceWorkerVirtualModules.get(id) ?? null;
+			return null;
+		},
+		async configResolved(config) {
+			state.projectRoot = config.root;
+			state.context.projectRoot = state.projectRoot;
+			state.resolvedPluginConfigPath = await resolvePluginConfigPath(state.projectRoot, configPath);
+			try {
+				await loadAndApplyConfig(state, {
+					configPath,
+					environment
+				}, config.command === "build" ? "build" : "serve", (ctx) => {
+					lastPluginContext = ctx;
+				});
+				if (config.command === "serve") {
+					console.log("[devflare] Config generated to .devflare/wrangler.jsonc");
+					if (state.context.auxiliaryWorkerConfig) console.log("[devflare] ✓ Auxiliary DO worker configured");
+				}
+				if (config.command === "build") console.log(`[devflare] Generated ${CONFIG_DIR$1}/wrangler.jsonc`);
+			} catch (error) {
+				if (error instanceof Error) console.error("[devflare] Config error:", error.message);
+				throw error;
+			}
+		},
+		configureServer(server) {
+			if (!watchConfig) return;
+			const fullConfigPath = state.resolvedPluginConfigPath ?? resolve(state.projectRoot, configPath || "devflare.config.ts");
+			server.watcher.add(fullConfigPath);
+			server.watcher.on("change", async (changedPath) => {
+				if (changedPath === fullConfigPath) {
+					console.log("[devflare] Config changed, reloading...");
+					try {
+						await loadAndApplyConfig(state, {
+							configPath,
+							environment
+						}, "serve", (ctx) => {
+							lastPluginContext = ctx;
+						});
+						console.log("[devflare] Config reloaded");
+						server.ws.send({
+							type: "full-reload",
+							path: "*"
+						});
+					} catch (error) {
+						console.error("[devflare] Failed to reload config:", error);
+					}
+				}
+			});
+		},
+		async transform(code, id) {
+			return runDevflareTransform(code, id, { doTransforms });
+		}
+	};
+}
+//#endregion
+//#region src/vite/config-file.ts
+const CONFIG_DIR = ".devflare";
+const GENERATED_VITE_CONFIG_FILENAME = "vite.config.mjs";
+function hasInlineViteConfig(viteConfig) {
+	return Boolean(viteConfig && Object.keys(viteConfig).length > 0);
+}
+function resolveEffectiveViteProject(detection, config, environment) {
+	const hasDevflareConfig = hasInlineViteConfig(resolveConfigForEnvironment(config, environment).vite);
+	return {
+		...detection,
+		hasDevflareViteConfig: hasDevflareConfig,
+		shouldStartVite: detection.shouldStartVite || hasDevflareConfig,
+		wantsViteIntegration: detection.wantsViteIntegration || hasDevflareConfig
+	};
+}
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function normalizePluginOptions(pluginOption) {
+	if (typeof pluginOption === "undefined") return [];
+	return Array.isArray(pluginOption) ? pluginOption : [pluginOption];
+}
+function removePluginByName(pluginOption, pluginName) {
+	if (Array.isArray(pluginOption)) {
+		const filteredPlugins = pluginOption.map((nestedPlugin) => removePluginByName(nestedPlugin, pluginName)).filter((nestedPlugin) => typeof nestedPlugin !== "undefined");
+		return filteredPlugins.length > 0 ? filteredPlugins : void 0;
+	}
+	if (!pluginOption || typeof pluginOption === "boolean" || isPromiseLike(pluginOption)) return pluginOption;
+	return pluginOption.name === pluginName ? void 0 : pluginOption;
+}
+function withInjectedDevflarePlugin(config, pluginOptions) {
+	const existingPlugins = normalizePluginOptions(config.plugins).map((pluginOption) => removePluginByName(pluginOption, "devflare")).filter((pluginOption) => typeof pluginOption !== "undefined");
+	return {
+		...config,
+		plugins: [devflarePlugin(pluginOptions), ...existingPlugins]
+	};
+}
+async function resolveViteUserConfig(configEnv, options = {}) {
+	const { loadConfigFromFile, mergeConfig } = await import("vite");
+	const cwd = options.cwd ?? process.cwd();
+	const inlineViteConfig = resolveConfigForEnvironment(await loadConfig({
+		cwd,
+		configFile: options.configPath
+	}), options.environment).vite ?? {};
+	const mergedConfig = mergeConfig(options.localConfigPath ? (await loadConfigFromFile(configEnv, options.localConfigPath, cwd))?.config ?? {} : {}, inlineViteConfig);
+	return withInjectedDevflarePlugin(mergedConfig.root ? mergedConfig : {
+		...mergedConfig,
+		root: cwd
+	}, {
+		configPath: options.configPath,
+		environment: options.environment,
+		bridgePort: options.bridgePort
+	});
+}
+async function ensureGeneratedConfigDir(cwd) {
+	const fs = await import("node:fs/promises");
+	const { resolve } = await import("pathe");
+	const configDir = resolve(cwd, CONFIG_DIR);
+	await fs.mkdir(configDir, { recursive: true });
+	const gitignorePath = resolve(configDir, ".gitignore");
+	try {
+		await fs.access(gitignorePath);
+	} catch {
+		await fs.writeFile(gitignorePath, "*\n", "utf-8");
+	}
+	return configDir;
+}
+async function resolveDevflarePackageRoot(currentFilePath) {
+	const fs = await import("node:fs/promises");
+	const { dirname, resolve } = await import("pathe");
+	let currentDir = dirname(currentFilePath);
+	while (true) {
+		const packageJsonPath = resolve(currentDir, "package.json");
+		try {
+			if (JSON.parse(await fs.readFile(packageJsonPath, "utf-8")).name === "devflare") return currentDir;
+		} catch {}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	throw new Error("Could not resolve the devflare package root for generated Vite config imports.");
+}
+async function resolveGeneratedViteImportPath(configDir) {
+	const { fileURLToPath } = await import("node:url");
+	const { extname, normalize, relative, resolve } = await import("pathe");
+	const currentFilePath = normalize(fileURLToPath(import.meta.url));
+	const currentExtension = extname(currentFilePath);
+	const packageRoot = await resolveDevflarePackageRoot(currentFilePath);
+	const relativeImportPath = relative(configDir, currentFilePath.includes("/dist/") ? resolve(packageRoot, "dist/vite/index.js") : resolve(packageRoot, `src/vite/index${currentExtension}`));
+	return relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
+}
+async function writeGeneratedViteConfig(options) {
+	const fs = await import("node:fs/promises");
+	const { resolve } = await import("pathe");
+	const configDir = await ensureGeneratedConfigDir(options.cwd);
+	const generatedConfigPath = resolve(configDir, GENERATED_VITE_CONFIG_FILENAME);
+	const viteImportPath = await resolveGeneratedViteImportPath(configDir);
+	const content = `import { defineConfig } from 'vite'
+import { resolveViteUserConfig } from ${JSON.stringify(viteImportPath)}
+
+export default defineConfig(async (env) => {
+	return await resolveViteUserConfig(env, {
+		cwd: ${JSON.stringify(options.cwd)},
+		configPath: ${JSON.stringify(options.configPath)},
+		environment: ${JSON.stringify(options.environment)},
+		localConfigPath: ${JSON.stringify(options.localConfigPath)},
+		bridgePort: ${JSON.stringify(options.bridgePort)}
+	})
+})
+`;
+	await fs.writeFile(generatedConfigPath, content, "utf-8");
+	return generatedConfigPath;
+}
+//#endregion
+export { devflarePlugin as a, getDevflareConfigs as c, DEFAULT_FETCH_ENTRY_FILES as d, DEFAULT_QUEUE_ENTRY_FILES as f, discoverDurableObjectFiles as g, resolveWorkerSurfacePaths as h, writeGeneratedViteConfig as i, prepareComposedWorkerEntrypoint as l, hasWorkerSurfacePaths as m, resolveEffectiveViteProject as n, getPluginContext as o, DEFAULT_SCHEDULED_ENTRY_FILES as p, resolveViteUserConfig as r, getCloudflareConfig as s, hasInlineViteConfig as t, DEFAULT_EMAIL_ENTRY_FILES as u };