devflare 1.0.0-next.65 → 1.0.0-next.66

package/dist/_chunks/{dev-C7Z23WNH.js → vite-process-BxZ8pb7i.js}

@@ -1,27 +1,21 @@
-import { c as getDevflareDotenvPaths, d as resolveConfigEnvVars, o as EnvVarResolutionError } from "./preview-C3Cdr8an.js";
-import { i as resolveConfigPath, r as loadConfig } from "./loader-E_UGyTrJ.js";
-import { g as normalizeR2Binding, n as getLocalKVNamespaceIdentifier, r as getSingleBrowserBindingName, t as getLocalD1DatabaseIdentifier } from "./schema-normalization-Zgm4W6O6.js";
-import { t as applyLocalDevVarsToConfig } from "./local-dev-vars-CTSa-wvF.js";
-import { a as cyanBold, f as logLine, g as yellow, o as dim, r as createCliTheme } from "./ui-BUoZApvE.js";
-import { clearLocalSendEmailBindings, setLocalSendEmailBindings } from "../utils/send-email.js";
-import { C as buildSendEmailConfig, D as buildVersionMetadataConfig, E as buildTailConsumersConfig, O as buildWorkerLoadersConfig, S as buildSecretsStoreConfig, T as buildStreamingTailConsumersConfig, _ as buildMtlsCertificatesConfig, b as buildQueueProducers, c as buildAiSearchInstancesConfig, d as buildArtifactsConfig, f as buildDispatchNamespacesConfig, g as buildMediaConfig, h as buildImagesConfig, k as buildWorkflowsConfig, l as buildAiSearchNamespacesConfig, m as buildHyperdrivesConfig, n as getRouteDirectoryCandidate, p as buildFlagshipConfig, s as resolveServiceBindings, t as discoverRoutes, u as buildAnalyticsEngineConfig, v as buildPipelinesConfig, w as buildStreamConfig, x as buildRateLimitsConfig, y as buildQueueConsumers } from "./routes-BMU7ga_l.js";
-import { r as transformDurableObject } from "./durable-object-DMtH0XYX.js";
-import { i as findFiles } from "./glob-CmQOvunB.js";
-import { d as DEFAULT_FETCH_ENTRY_FILES, f as DEFAULT_QUEUE_ENTRY_FILES, g as discoverDurableObjectFiles, h as resolveWorkerSurfacePaths, i as writeGeneratedViteConfig, l as prepareComposedWorkerEntrypoint, m as hasWorkerSurfacePaths, n as resolveEffectiveViteProject, p as DEFAULT_SCHEDULED_ENTRY_FILES, u as DEFAULT_EMAIL_ENTRY_FILES } from "./vite-BBiqD3k7.js";
-import { a as createWorkerdBundlerDefaults, i as writeWorkerCompatibleBundle, n as ensureDebugShim, r as resolveWorkerCompatibleRolldownConfig, t as bundleWorkerEntry } from "./worker-bundler-dTTnYU3n.js";
-import { n as bundleWorkflowEntrypointScript, t as R2_PRESIGN_RUNTIME_JS } from "./r2-presign-runtime-zTOLS0Ea.js";
-import { n as buildLocalSecretWrappedBindingConfig } from "./local-secrets-6sMstHXw.js";
-import { t as buildLocalBindingShimServiceConfig } from "./local-media-bindings-DsAW4AMF.js";
-import { i as waitForViteReady, n as resolveViteMode, r as stopSpawnedProcessTree, t as detectViteProject } from "./vite-utils-OVLMV605.js";
+import { i as resolveConfigPath } from "./loader-BC0skbnH.js";
+import { g as normalizeR2Binding, n as getLocalKVNamespaceIdentifier, r as getSingleBrowserBindingName, t as getLocalD1DatabaseIdentifier } from "./schema-normalization-CTdiY17P.js";
+import { C as buildSendEmailConfig, D as buildVersionMetadataConfig, E as buildTailConsumersConfig, O as buildWorkerLoadersConfig, S as buildSecretsStoreConfig, T as buildStreamingTailConsumersConfig, _ as buildMtlsCertificatesConfig, b as buildQueueProducers, c as buildAiSearchInstancesConfig, d as buildArtifactsConfig, f as buildDispatchNamespacesConfig, g as buildMediaConfig, h as buildImagesConfig, k as buildWorkflowsConfig, l as buildAiSearchNamespacesConfig, m as buildHyperdrivesConfig, n as getRouteDirectoryCandidate, p as buildFlagshipConfig, u as buildAnalyticsEngineConfig, v as buildPipelinesConfig, w as buildStreamConfig, x as buildRateLimitsConfig, y as buildQueueConsumers } from "./routes-CRXB3-iw.js";
+import { r as transformDurableObject } from "./durable-object-DuMPM8re.js";
+import { i as findFiles } from "./glob-DRw9sbfF.js";
+import { d as DEFAULT_FETCH_ENTRY_FILES, f as DEFAULT_QUEUE_ENTRY_FILES, g as discoverDurableObjectFiles, h as resolveWorkerSurfacePaths, i as writeGeneratedViteConfig, m as hasWorkerSurfacePaths, p as DEFAULT_SCHEDULED_ENTRY_FILES, u as DEFAULT_EMAIL_ENTRY_FILES } from "./vite-Dxuhm1BP.js";
+import { a as createWorkerdBundlerDefaults, i as writeWorkerCompatibleBundle, n as ensureDebugShim, r as resolveWorkerCompatibleRolldownConfig } from "./worker-bundler-Isj5jiW6.js";
+import { t as R2_PRESIGN_RUNTIME_JS } from "./r2-presign-runtime-C75FkLMd.js";
+import { n as buildLocalSecretWrappedBindingConfig } from "./local-secrets-C0n5oRgI.js";
+import { t as buildLocalBindingShimServiceConfig } from "./local-media-bindings-ZQe-epuw.js";
+import { i as waitForViteReady, n as resolveViteMode } from "./vite-utils-D8kPPxUy.js";
 import { existsSync } from "node:fs";
 import { dirname, relative, resolve } from "pathe";
-import { exec, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join as join$1 } from "node:path";
-import { createConsola } from "consola";
 import picomatch from "picomatch";
 import { createHash } from "node:crypto";
-import { promisify } from "node:util";
 import { createInterface } from "node:readline";
 import { createServer } from "node:http";
 import { Browser, detectBrowserPlatform, install, resolveBuildId } from "@puppeteer/browsers";
@@ -1082,85 +1076,6 @@ async function handleHttpTransfer(request, env, url) {
 }
 `;
 //#endregion
-//#region src/bridge/miniflare.ts
-function isIgnorableMiniflareDisposeError(error) {
-	if (!(error instanceof Error)) return false;
-	const details = error;
-	return details.code === "EBADF" && details.syscall === "kill";
-}
-//#endregion
-//#region src/cli/wrangler-auth.ts
-const execAsync = promisify(exec);
-/**
-* Check if the config contains any bindings that require remote access
-*/
-function detectRemoteBindings(config) {
-	const remoteBindings = [];
-	const bindings = config.bindings;
-	if (!bindings) return remoteBindings;
-	if (bindings.ai) remoteBindings.push(`AI (binding: ${bindings.ai.binding})`);
-	if (bindings.vectorize) for (const [name] of Object.entries(bindings.vectorize)) remoteBindings.push(`Vectorize (binding: ${name})`);
-	return remoteBindings;
-}
-/**
-* Check if wrangler is logged in by running `wrangler whoami`
-*
-* Returns:
-* - loggedIn: true if user is authenticated
-* - accountId: the account ID if available
-* - email: the email if available
-* - error: error message if check failed
-*/
-async function checkWranglerAuth() {
-	try {
-		const { stdout, stderr } = await execAsync("bunx wrangler whoami", { timeout: 15e3 });
-		const output = stdout + stderr;
-		if (output.includes("not authenticated") || output.includes("Not logged in") || output.includes("wrangler login")) return {
-			loggedIn: false,
-			error: "Not logged in to Wrangler"
-		};
-		const emailMatch = output.match(/email[:\s]+([^\s!]+)/i);
-		const accountMatch = output.match(/Account\s+ID[:\s]+([a-f0-9]+)/i);
-		return {
-			loggedIn: true,
-			email: emailMatch?.[1],
-			accountId: accountMatch?.[1]
-		};
-	} catch (error) {
-		const msg = error instanceof Error ? error.message : String(error);
-		if (msg.includes("ENOENT") || msg.includes("not found")) return {
-			loggedIn: false,
-			error: "Wrangler not installed. Run: npm install -g wrangler"
-		};
-		return {
-			loggedIn: false,
-			error: msg
-		};
-	}
-}
-/**
-* Check if remote bindings are properly configured
-*
-* Returns warnings if:
-* - Config has remote-only bindings but no accountId
-* - Config has remote-only bindings but user is not logged in to wrangler
-*/
-async function checkRemoteBindingRequirements(config) {
-	const remoteBindings = detectRemoteBindings(config);
-	if (remoteBindings.length === 0) return {
-		hasRemoteBindings: false,
-		remoteBindings: [],
-		missingAccountId: false,
-		notLoggedIn: false
-	};
-	return {
-		hasRemoteBindings: true,
-		remoteBindings,
-		missingAccountId: !config.accountId,
-		notLoggedIn: !(await checkWranglerAuth()).loggedIn
-	};
-}
-//#endregion
 //#region src/dev-server/d1-migrations.ts
 const MIGRATION_RETRY_DELAYS_MS = [
 	500,
@@ -1310,81 +1225,6 @@ async function runD1Migrations(options) {
 	}
 }
 //#endregion
-//#region src/dev-server/dev-server-state.ts
-/**
-* Build a fresh `DevServerState` with all handles in their not-yet-started
-* positions. `enableVite` is the user's request — `start()` may downgrade it
-* later via `resolveViteIntegration`.
-*/
-function createDevServerState(initial) {
-	return {
-		enableVite: initial.enableVite,
-		miniflare: null,
-		doBundler: null,
-		workerSourceWatcher: null,
-		workerWatchTargets: [],
-		viteProcess: null,
-		config: null,
-		serviceBindingResolution: null,
-		browserShim: null,
-		browserShimPort: initial.browserShimPort ?? 8788,
-		mainWorkerSurfacePaths: {
-			fetch: null,
-			queue: null,
-			scheduled: null,
-			email: null,
-			tail: null
-		},
-		resolvedWorkerConfigPath: null,
-		mainWorkerScriptPath: null,
-		bundledMainWorkerScriptPath: null,
-		workflowEntrypointScript: "",
-		currentDoResult: null,
-		mainWorkerRoutes: null,
-		generatedViteConfigPath: null
-	};
-}
-/**
-* Tear down everything in `state` in the same order the legacy `stop()`
-* function used. After this returns, every handle on `state` is `null` again
-* and the local sendEmail bindings have been cleared.
-*
-* Order is important and intentionally mirrors the production sequence:
-* 1. DO bundler (stop rebuilds before Miniflare goes away)
-* 2. Worker source watcher (stop FS callbacks before Miniflare disposal)
-* 3. Miniflare itself
-* 4. Vite child process (after Miniflare so requests cannot race shutdown)
-* 5. Browser shim
-* 6. Local sendEmail registry reset
-*/
-async function disposeDevServerState(state) {
-	if (state.doBundler) {
-		await state.doBundler.close();
-		state.doBundler = null;
-	}
-	if (state.workerSourceWatcher) {
-		await state.workerSourceWatcher.close();
-		state.workerSourceWatcher = null;
-	}
-	if (state.miniflare) {
-		try {
-			await state.miniflare.dispose();
-		} catch (error) {
-			if (!isIgnorableMiniflareDisposeError(error)) throw error;
-		}
-		state.miniflare = null;
-	}
-	if (state.viteProcess) {
-		await stopSpawnedProcessTree(state.viteProcess);
-		state.viteProcess = null;
-	}
-	if (state.browserShim) {
-		await state.browserShim.stop();
-		state.browserShim = null;
-	}
-	clearLocalSendEmailBindings();
-}
-//#endregion
 //#region src/browser-shim/binding-worker.ts
 const MAX_CHUNK_SIZE = 1048575;
 /**
@@ -2170,7 +2010,7 @@ function resolveR2PresignOrigin(serverConfig, miniflareHost, miniflarePort) {
 * workers array is present.
 */
 function buildMiniflareDevConfig(input) {
-	const { config: loadedConfig, cwd, miniflarePort, miniflareHost = "127.0.0.1", persist, enableVite, debug, mainWorkerSurfacePaths, mainWorkerRoutes, mainWorkerScriptPath, bundledMainWorkerScriptPath, workflowEntrypointScript, browserShimPort, doResult, serviceBindingResolution, r2PresignSecret, logger } = input;
+	const { config: loadedConfig, cwd, miniflarePort, miniflareHost = "127.0.0.1", persist, enableVite, debug, mainWorkerSurfacePaths, mainWorkerRoutes, mainWorkerScriptPath, bundledMainWorkerScriptPath, workflowEntrypointScript, browserShimPort, doResult, serviceBindingResolution, r2PresignSecret, additionalInjectedVars, logger } = input;
 	const bindings = loadedConfig.bindings ?? {};
 	const persistPath = process.env.DEVFLARE_PERSIST_DIR ? resolve(cwd, process.env.DEVFLARE_PERSIST_DIR) : resolve(cwd, ".devflare/data");
 	const appWorkerName = loadedConfig.name;
@@ -2228,6 +2068,12 @@ function buildMiniflareDevConfig(input) {
 	const aiSearchInstancesConfig = buildAiSearchInstancesConfig(bindings);
 	const localSecretWrappedBindingConfig = buildLocalSecretWrappedBindingConfig(loadedConfig, cwd);
 	const localSecretBindingNames = new Set(localSecretWrappedBindingConfig.localBindingNames);
+	const secretsStoreConfig = buildSecretsStoreConfig(bindings, loadedConfig.secretsStoreId, localSecretBindingNames);
+	const presignVars = bindings.r2 && r2PresignSecret ? {
+		DEVFLARE_R2_PRESIGN_SECRET: r2PresignSecret,
+		DEVFLARE_R2_PRESIGN_ORIGIN: resolveR2PresignOrigin(serverConfig, miniflareHost, miniflarePort)
+	} : void 0;
+	const hasAdditional = additionalInjectedVars !== void 0 && Object.keys(additionalInjectedVars).length > 0;
 	const workerContext = {
 		cwd,
 		loadedConfig,
@@ -2251,12 +2097,12 @@ function buildMiniflareDevConfig(input) {
 		artifactsConfig,
 		aiSearchNamespacesConfig,
 		aiSearchInstancesConfig,
-		secretsStoreConfig: buildSecretsStoreConfig(bindings, loadedConfig.secretsStoreId, localSecretBindingNames),
+		secretsStoreConfig,
 		localSecretWrappedBindingConfig,
 		queueProducers,
-		injectedVars: bindings.r2 && r2PresignSecret ? {
-			DEVFLARE_R2_PRESIGN_SECRET: r2PresignSecret,
-			DEVFLARE_R2_PRESIGN_ORIGIN: resolveR2PresignOrigin(serverConfig, miniflareHost, miniflarePort)
+		injectedVars: presignVars || hasAdditional ? {
+			...presignVars ?? {},
+			...hasAdditional ? additionalInjectedVars : {}
 		} : void 0
 	};
 	const createWorkerConfig = (options) => makeMiniflareWorker(workerContext, options);
@@ -2329,43 +2175,6 @@ function buildMiniflareDevConfig(input) {
 	};
 }
 //#endregion
-//#region src/dev-server/reload-queue.ts
-function createReloadQueue({ reload, logger }) {
-	let running = null;
-	let pending = null;
-	async function runOnce() {
-		try {
-			await reload();
-		} catch (error) {
-			logger?.error("[devflare dev] reload failed:", error);
-		}
-	}
-	function schedule() {
-		if (!running) {
-			running = runOnce().finally(() => {
-				running = null;
-			});
-			return running;
-		}
-		if (!pending) pending = running.then(() => {
-			pending = null;
-			running = runOnce().finally(() => {
-				running = null;
-			});
-			return running;
-		});
-		return pending;
-	}
-	async function drain() {
-		while (running || pending) if (pending) await pending;
-		else if (running) await running;
-	}
-	return {
-		schedule,
-		drain
-	};
-}
-//#endregion
 //#region src/dev-server/runtime-stdio.ts
 function writeStdout(logger, message) {
 	if (typeof logger?.log === "function") {
@@ -3117,554 +2926,4 @@ async function startViteProcess(options) {
 	return viteProcess;
 }
 //#endregion
-//#region src/dev-server/worker-source-watcher.ts
-async function startWorkerSourceWatcher(options) {
-	const { watchTargets, resolvedWorkerConfigPath, logger, onConfigChange, onWorkerChange } = options;
-	if (watchTargets.length === 0) return null;
-	const chokidar = await import("chokidar");
-	const isWindows = process.platform === "win32";
-	const ignoredSegments = [
-		"/node_modules/",
-		"/.git/",
-		"/.devflare/",
-		"/dist/"
-	];
-	const normalizePath = (filePath) => filePath.replace(/\\/g, "/");
-	const isIgnoredPath = (filePath) => {
-		const normalizedPath = normalizePath(filePath);
-		return ignoredSegments.some((segment) => normalizedPath.includes(segment));
-	};
-	let reloadTimeout = null;
-	let reloadInProgress = false;
-	let pendingReloadPath = null;
-	const flushPendingReload = async () => {
-		if (!pendingReloadPath) return;
-		const nextPath = pendingReloadPath;
-		pendingReloadPath = null;
-		await triggerReload(nextPath);
-	};
-	const triggerReload = async (filePath) => {
-		if (reloadInProgress) {
-			pendingReloadPath = filePath;
-			return;
-		}
-		reloadInProgress = true;
-		try {
-			const normalizedConfigPath = resolvedWorkerConfigPath ? normalizePath(resolvedWorkerConfigPath) : null;
-			if (normalizedConfigPath && normalizePath(filePath) === normalizedConfigPath) {
-				logger?.info(`Devflare config changed: ${filePath}`);
-				await onConfigChange();
-				return;
-			}
-			logger?.info(`Worker source changed: ${filePath}`);
-			await onWorkerChange();
-		} catch (error) {
-			logger?.error("Worker source reload failed:", error);
-		} finally {
-			reloadInProgress = false;
-			await flushPendingReload();
-		}
-	};
-	const scheduleReload = (filePath) => {
-		if (reloadTimeout) clearTimeout(reloadTimeout);
-		reloadTimeout = setTimeout(() => {
-			reloadTimeout = null;
-			triggerReload(filePath);
-		}, 150);
-	};
-	const watcher = chokidar.watch(watchTargets, {
-		ignoreInitial: true,
-		usePolling: isWindows,
-		interval: isWindows ? 300 : void 0,
-		awaitWriteFinish: {
-			stabilityThreshold: 100,
-			pollInterval: 50
-		},
-		ignored: (filePath) => isIgnoredPath(filePath)
-	});
-	const onFileEvent = (filePath) => {
-		if (isIgnoredPath(filePath)) return;
-		scheduleReload(filePath);
-	};
-	watcher.on("change", onFileEvent);
-	watcher.on("add", onFileEvent);
-	watcher.on("unlink", onFileEvent);
-	watcher.on("error", (error) => {
-		logger?.error("Worker source watcher error:", error);
-	});
-	await new Promise((resolvePromise, rejectPromise) => {
-		const handleReady = () => {
-			watcher.off("error", handleInitialError);
-			logger?.info(`Worker source watcher ready (${watchTargets.length} target(s))`);
-			resolvePromise();
-		};
-		const handleInitialError = (error) => {
-			watcher.off("ready", handleReady);
-			rejectPromise(error instanceof Error ? error : new Error(String(error)));
-		};
-		watcher.once("ready", handleReady);
-		watcher.once("error", handleInitialError);
-	});
-	return watcher;
-}
-/**
-* Compute the diff between current and next watch-target lists and apply it
-* to the given watcher. Returns the deduped next-targets array which the
-* caller should store as the new "current" state.
-*/
-async function applyWatcherTargetDiff(watcher, currentTargets, nextTargets) {
-	const nextSet = new Set(nextTargets);
-	const targetsToRemove = currentTargets.filter((t) => !nextSet.has(t));
-	const targetsToAdd = nextTargets.filter((t) => !currentTargets.includes(t));
-	if (targetsToRemove.length > 0) await watcher.unwatch(targetsToRemove);
-	if (targetsToAdd.length > 0) watcher.add(targetsToAdd);
-	return nextTargets;
-}
-//#endregion
-//#region src/dev-server/server.ts
-function createDevServer(options) {
-	const { cwd, configPath, vitePort = 5173, miniflarePort = 8787, miniflareHost = "127.0.0.1", enableVite: enableViteRequested = true, persist = true, logger, verbose = false, debug = process.env.DEVFLARE_DEBUG === "true" } = options;
-	const state = createDevServerState({ enableVite: enableViteRequested });
-	const r2PresignSecret = `${crypto.randomUUID()}${crypto.randomUUID()}`;
-	const reloadQueue = createReloadQueue({
-		reload: async () => {
-			if (!state.miniflare) return;
-			const { Log, LogLevel } = await import("miniflare");
-			const mfConfig = buildMiniflareConfig(state.currentDoResult);
-			const log = createMiniflareLog(Log, LogLevel, "DEBUG", logger);
-			if (log) mfConfig.log = log;
-			mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
-			logger?.info("Reloading Miniflare...");
-			await state.miniflare.setOptions(mfConfig);
-			logger?.success("Miniflare reloaded");
-		},
-		logger
-	});
-	async function bundleMainWorker() {
-		if (!state.mainWorkerScriptPath || !state.config) {
-			state.bundledMainWorkerScriptPath = null;
-			return;
-		}
-		state.bundledMainWorkerScriptPath = await bundleWorkerEntry({
-			cwd,
-			inputFile: state.mainWorkerScriptPath,
-			outFile: resolve(cwd, ".devflare", "worker-entrypoints", "main.js"),
-			rolldownOptions: state.config.rolldown?.options,
-			sourcemap: state.config.rolldown?.sourcemap,
-			minify: state.config.rolldown?.minify,
-			logger
-		});
-		logger?.debug(`Bundled main worker → ${state.bundledMainWorkerScriptPath}`);
-	}
-	function buildMiniflareConfig(doResult) {
-		if (!state.config) throw new Error("Config not loaded");
-		return buildMiniflareDevConfig({
-			config: state.config,
-			cwd,
-			miniflarePort,
-			miniflareHost,
-			persist,
-			enableVite: state.enableVite,
-			debug,
-			mainWorkerSurfacePaths: state.mainWorkerSurfacePaths,
-			mainWorkerRoutes: state.mainWorkerRoutes,
-			mainWorkerScriptPath: state.mainWorkerScriptPath,
-			bundledMainWorkerScriptPath: state.bundledMainWorkerScriptPath,
-			workflowEntrypointScript: state.workflowEntrypointScript,
-			browserShimPort: state.browserShimPort,
-			doResult,
-			serviceBindingResolution: state.serviceBindingResolution,
-			r2PresignSecret,
-			logger
-		});
-	}
-	async function bundleWorkflowEntrypoints() {
-		if (!state.config) {
-			state.workflowEntrypointScript = "";
-			return;
-		}
-		state.workflowEntrypointScript = await bundleWorkflowEntrypointScript(state.config, cwd, { logger });
-	}
-	/**
-	* Start Miniflare with current config
-	*/
-	async function startMiniflare(doResult) {
-		const { Miniflare, Log, LogLevel } = await import("miniflare");
-		const mfConfig = buildMiniflareConfig(doResult);
-		const log = createMiniflareLog(Log, LogLevel, "DEBUG", logger);
-		if (log) mfConfig.log = log;
-		mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
-		const shouldLogMiniflareDiagnostics = verbose || debug;
-		if (shouldLogMiniflareDiagnostics) logMiniflareConfigDiagnostics(logger, mfConfig);
-		state.miniflare = new Miniflare(mfConfig);
-		await state.miniflare.ready;
-		const displayHost = miniflareHost === "0.0.0.0" || miniflareHost === "::" ? "localhost" : miniflareHost;
-		logger?.success(`Miniflare ready on http://${displayHost}:${miniflarePort}`);
-		if (shouldLogMiniflareDiagnostics) await logMiniflareBindingDiagnostics(logger, state.miniflare, mfConfig);
-	}
-	/**
-	* Reload Miniflare with updated DO bundles
-	*/
-	async function reloadMiniflare(doResult) {
-		state.currentDoResult = doResult;
-		await reloadQueue.schedule();
-	}
-	async function refreshWorkerOnlySurfaceState() {
-		if (!state.config) return;
-		state.mainWorkerSurfacePaths = await resolveMainWorkerSurfacePaths(cwd, state.config);
-		state.mainWorkerRoutes = await discoverRoutes(cwd, state.config);
-		const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, state.config, void 0, { devInternalEmail: true });
-		state.mainWorkerScriptPath = composedMainEntry ? composedMainEntry : null;
-		if (state.mainWorkerScriptPath) await bundleMainWorker();
-		else state.bundledMainWorkerScriptPath = null;
-		await syncWorkerWatchTargets();
-	}
-	function getWorkerWatchTargets() {
-		if (state.enableVite || !state.config) return [];
-		const targets = collectWorkerWatchRoots(cwd, state.config, state.mainWorkerSurfacePaths);
-		if (state.resolvedWorkerConfigPath) targets.push(state.resolvedWorkerConfigPath);
-		return [...new Set(targets)];
-	}
-	async function syncWorkerWatchTargets() {
-		if (!state.workerSourceWatcher) return;
-		state.workerWatchTargets = await applyWatcherTargetDiff(state.workerSourceWatcher, state.workerWatchTargets, getWorkerWatchTargets());
-	}
-	async function reloadWorkerOnlyConfig() {
-		await loadRuntimeConfigWhenEnvReady();
-		if (!state.config) return;
-		setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
-		await bundleWorkflowEntrypoints();
-		await refreshWorkerOnlySurfaceState();
-		await reloadMiniflare(state.currentDoResult);
-	}
-	async function loadRuntimeConfig() {
-		state.resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath(cwd, configPath);
-		state.config = await applyLocalDevVarsToConfig(await resolveConfigEnvVars(await loadConfig({
-			cwd,
-			configFile: configPath
-		}), {
-			cwd,
-			configPath: state.resolvedWorkerConfigPath ?? configPath,
-			mode: "dev"
-		}), {
-			cwd,
-			configPath: state.resolvedWorkerConfigPath ?? void 0
-		});
-		state.serviceBindingResolution = state.config.bindings?.services ? await resolveServiceBindings(state.config, state.resolvedWorkerConfigPath ? dirname(state.resolvedWorkerConfigPath) : cwd) : null;
-	}
-	async function waitForDotenvChange() {
-		const configWatchPath = state.resolvedWorkerConfigPath ?? await resolveWorkerConfigWatchPath(cwd, configPath);
-		const watchPaths = getDevflareDotenvPaths(configWatchPath ? dirname(configWatchPath) : cwd);
-		const { watch } = await import("chokidar");
-		await new Promise((resolveWait, rejectWait) => {
-			const watcher = watch(watchPaths, {
-				ignoreInitial: true,
-				awaitWriteFinish: {
-					stabilityThreshold: 100,
-					pollInterval: 25
-				}
-			});
-			const finish = () => {
-				watcher.close().then(resolveWait, rejectWait);
-			};
-			watcher.on("add", finish);
-			watcher.on("change", finish);
-			watcher.on("unlink", finish);
-			watcher.on("error", rejectWait);
-		});
-	}
-	async function loadRuntimeConfigWhenEnvReady() {
-		while (true) try {
-			await loadRuntimeConfig();
-			return;
-		} catch (error) {
-			if (!(error instanceof EnvVarResolutionError)) throw error;
-			logger?.warn(error.message);
-			logger?.info("Devflare dev is waiting for .env or .env.dev to change before starting.");
-			await waitForDotenvChange();
-		}
-	}
-	async function startWorkerSourceWatcher$1() {
-		if (state.enableVite || !state.config) return;
-		const watchTargets = getWorkerWatchTargets();
-		if (watchTargets.length === 0) return;
-		state.workerWatchTargets = watchTargets;
-		state.workerSourceWatcher = await startWorkerSourceWatcher({
-			watchTargets,
-			resolvedWorkerConfigPath: state.resolvedWorkerConfigPath,
-			logger,
-			onConfigChange: reloadWorkerOnlyConfig,
-			onWorkerChange: async () => {
-				await refreshWorkerOnlySurfaceState();
-				await reloadMiniflare(state.currentDoResult);
-			}
-		});
-	}
-	/**
-	* Start the complete dev server
-	*/
-	async function start() {
-		logger?.info("Starting unified dev server...");
-		await loadRuntimeConfigWhenEnvReady();
-		if (!state.config) throw new Error("Config not loaded");
-		setLocalSendEmailBindings(state.config.bindings?.sendEmail ?? {});
-		logger?.debug("Loaded config:", state.config.name);
-		await bundleWorkflowEntrypoints();
-		const viteIntegration = await resolveViteIntegration({
-			cwd,
-			configPath,
-			miniflarePort,
-			enableViteRequested: state.enableVite,
-			logger
-		});
-		state.enableVite = viteIntegration.enableVite;
-		state.generatedViteConfigPath = viteIntegration.generatedViteConfigPath;
-		await refreshWorkerOnlySurfaceState();
-		if (!state.enableVite && (hasWorkerSurfacePaths(state.mainWorkerSurfacePaths) || Boolean(state.mainWorkerRoutes?.routes.length))) logWorkerHandlerDetection(logger, state.enableVite, true, state.mainWorkerSurfacePaths, state.mainWorkerRoutes);
-		else if (!state.enableVite) logWorkerHandlerDetection(logger, state.enableVite, false, state.mainWorkerSurfacePaths, state.mainWorkerRoutes);
-		logRemoteBindingRequirements(logger, await checkRemoteBindingRequirements(state.config));
-		state.browserShim = await maybeStartBrowserShim(state.config, {
-			browserShimPort: state.browserShimPort,
-			logger,
-			verbose
-		});
-		const doInit = await maybeStartDOBundler(state.config, {
-			cwd,
-			logger,
-			onRebuild: async (result) => {
-				await reloadMiniflare(result);
-			}
-		});
-		state.doBundler = doInit.bundler;
-		const doResult = doInit.result;
-		state.currentDoResult = doResult;
-		await startMiniflare(doResult);
-		await startWorkerSourceWatcher$1();
-		if (state.enableVite) state.viteProcess = await startViteProcess({
-			cwd,
-			configPath,
-			vitePort,
-			miniflarePort,
-			generatedViteConfigPath: state.generatedViteConfigPath,
-			r2Presign: state.config.bindings?.r2 ? {
-				secret: r2PresignSecret,
-				origin: resolveR2PresignOrigin(state.config.server, miniflareHost, miniflarePort)
-			} : null,
-			logger
-		});
-		else logger?.info("Vite startup skipped (no effective Vite config found for this package)");
-		await new Promise((r) => setTimeout(r, 1e3));
-		await runD1Migrations({
-			cwd,
-			config: state.config,
-			miniflarePort,
-			logger
-		});
-	}
-	/**
-	* Stop the dev server
-	*/
-	async function stop() {
-		await disposeDevServerState(state);
-	}
-	/**
-	* Get Miniflare instance
-	*/
-	function getMiniflare() {
-		return state.miniflare;
-	}
-	return {
-		start,
-		stop,
-		getMiniflare
-	};
-}
-//#endregion
-//#region src/cli/commands/dev.ts
-function readStringOption(value) {
-	return typeof value === "string" ? value : void 0;
-}
-function parsePort(value, source) {
-	const port = Number(value);
-	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error(`${source} must be an integer between 1 and 65535`);
-	return port;
-}
-function resolveSinglePort(runtimePort, bridgePort, source) {
-	if (runtimePort && bridgePort && runtimePort !== bridgePort) throw new Error(`Conflicting Devflare runtime ports: ${source} runtime port is ${runtimePort}, but bridge port is ${bridgePort}. Use one value for both.`);
-	const value = runtimePort ?? bridgePort;
-	return value ? parsePort(value, source) : void 0;
-}
-function resolveDevRuntimePort(options, env = process.env, configPort) {
-	return resolveSinglePort(readStringOption(options["runtime-port"]), readStringOption(options["bridge-port"]), "CLI") ?? resolveSinglePort(env.DEVFLARE_RUNTIME_PORT, env.DEVFLARE_BRIDGE_PORT, "environment") ?? configPort ?? 8787;
-}
-/**
-* Resolve the host the local Miniflare runtime instance binds to.
-*
-* Precedence: `--runtime-host` CLI flag > `DEVFLARE_RUNTIME_HOST` env var >
-* `server.host` config value > `127.0.0.1`.
-*/
-function resolveDevRuntimeHost(options, env = process.env, configHost) {
-	const envHost = env.DEVFLARE_RUNTIME_HOST?.trim();
-	return readStringOption(options["runtime-host"]) ?? (envHost ? envHost : void 0) ?? configHost ?? "127.0.0.1";
-}
-/**
-* Create a log writer that writes to both terminal and file
-*/
-async function createLogWriter(cwd, options) {
-	if (!options.log && !options.logTemp) return null;
-	const fs = await import("node:fs");
-	let logPath;
-	if (options.logTemp) logPath = resolve(cwd, ".log");
-	else logPath = resolve(cwd, `.log-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19)}`);
-	const fileStream = fs.createWriteStream(logPath, { flags: "w" });
-	const ansiRegex = /\x1b\[[0-9;]*m/g;
-	return {
-		path: logPath,
-		write(data, source) {
-			const str = typeof data === "string" ? data : data.toString();
-			if (!str.trim()) return;
-			const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
-			const prefix = source ? `[${timestamp}][${source.toUpperCase()}] ` : `[${timestamp}] `;
-			const cleanStr = str.replace(ansiRegex, "");
-			fileStream.write(prefix + cleanStr + (cleanStr.endsWith("\n") ? "" : "\n"));
-		},
-		close() {
-			fileStream.end();
-		}
-	};
-}
-async function runDevCommand(parsed, logger, options) {
-	const cwd = options.cwd || parsed.options.cwd || process.cwd();
-	const configPath = parsed.options.config;
-	const port = parsed.options.port;
-	const logEnabled = parsed.options.log === true;
-	const logTempEnabled = parsed.options["log-temp"] === true;
-	const persistEnabled = parsed.options.persist === true;
-	const debugEnabled = parsed.options.debug === true || process.env.DEVFLARE_DEBUG === "true";
-	const verbose = parsed.options.verbose === true || debugEnabled;
-	const theme = createCliTheme(parsed.options);
-	const config = await loadConfig({
-		cwd,
-		configFile: configPath
-	});
-	let miniflarePort;
-	let miniflareHost;
-	try {
-		miniflarePort = resolveDevRuntimePort(parsed.options, process.env, config.server?.port);
-		miniflareHost = resolveDevRuntimeHost(parsed.options, process.env, config.server?.host);
-	} catch (error) {
-		logger.error(error instanceof Error ? error.message : String(error));
-		return { exitCode: 1 };
-	}
-	const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd), config);
-	const logWriter = await createLogWriter(cwd, {
-		log: logEnabled,
-		logTemp: logTempEnabled
-	});
-	if (logWriter) {
-		const logFile = relative(cwd, logWriter.path) || ".log";
-		logLine(logger, `${dim("logging", theme)} ${logFile}`);
-	}
-	const devLogger = createConsola({ level: verbose ? 4 : 3 });
-	if (logWriter) {
-		const wrapLog = (original, prefix = "") => {
-			return (message, ...args) => {
-				original(message, ...args);
-				const formatted = prefix ? `${prefix} ${[message, ...args].join(" ")}` : [message, ...args].join(" ");
-				logWriter.write(formatted);
-			};
-		};
-		Object.assign(devLogger.log, wrapLog(devLogger.log.bind(devLogger)));
-		Object.assign(devLogger.info, wrapLog(devLogger.info.bind(devLogger)));
-		Object.assign(devLogger.error, wrapLog(devLogger.error.bind(devLogger), "[ERROR]"));
-		Object.assign(devLogger.warn, wrapLog(devLogger.warn.bind(devLogger), "[WARN]"));
-		Object.assign(devLogger.success, wrapLog(devLogger.success.bind(devLogger), "[OK]"));
-		Object.assign(devLogger.debug, wrapLog(devLogger.debug.bind(devLogger), "[DEBUG]"));
-	}
-	try {
-		logLine(logger);
-		if (viteProject.shouldStartVite) {
-			logLine(logger, `${cyanBold("dev", theme)} ${dim("Unified Dev Server", theme)}`);
-			logLine(logger, "   ├─ Vite: Full HMR for frontend");
-			logLine(logger, "   ├─ Miniflare: All Cloudflare bindings");
-			logLine(logger, "   ├─ Rolldown: Worker + DO bundling with watch");
-			logLine(logger, "   └─ Bridge: WebSocket RPC connection");
-		} else {
-			logLine(logger, `${cyanBold("dev", theme)} ${dim("Worker Dev Server", theme)}`);
-			logLine(logger, "   ├─ Miniflare: All Cloudflare bindings");
-			logLine(logger, "   ├─ Rolldown: Worker + DO bundling with watch");
-			logLine(logger, "   └─ Vite: Disabled (no effective Vite config found)");
-			if (viteProject.wantsViteIntegration) {
-				logger.warn("Vite-related settings were detected, but no effective Vite config was available");
-				logger.warn("Skipping Vite startup and running in worker-only mode");
-			}
-		}
-		logLine(logger);
-		const devServer = createDevServer({
-			cwd,
-			configPath,
-			vitePort: port ? Number.parseInt(port, 10) : 5173,
-			miniflarePort,
-			miniflareHost,
-			enableVite: viteProject.shouldStartVite,
-			persist: persistEnabled,
-			logger: devLogger,
-			verbose,
-			debug: debugEnabled
-		});
-		let isCleaningUp = false;
-		const cleanupHandlers = /* @__PURE__ */ new Map();
-		const removeCleanupHandlers = () => {
-			for (const [event, handler] of cleanupHandlers) process.off(event, handler);
-			cleanupHandlers.clear();
-		};
-		const cleanup = async (exitCode, reason) => {
-			if (isCleaningUp) return;
-			isCleaningUp = true;
-			removeCleanupHandlers();
-			if (reason) {
-				const message = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
-				logger.error(message);
-			}
-			logLine(logger);
-			logLine(logger, `${yellow("dev", theme)} ${dim("Shutting down…", theme)}`);
-			try {
-				await devServer.stop();
-			} finally {
-				logWriter?.close();
-				process.exit(exitCode);
-			}
-		};
-		const registerCleanupHandler = (event, handler) => {
-			cleanupHandlers.set(event, handler);
-			process.on(event, handler);
-		};
-		registerCleanupHandler("SIGINT", () => {
-			cleanup(0);
-		});
-		registerCleanupHandler("SIGTERM", () => {
-			cleanup(0);
-		});
-		registerCleanupHandler("SIGHUP", () => {
-			cleanup(0);
-		});
-		registerCleanupHandler("uncaughtException", (error) => {
-			cleanup(1, error);
-		});
-		registerCleanupHandler("unhandledRejection", (reason) => {
-			cleanup(1, reason);
-		});
-		await devServer.start();
-		await new Promise(() => {});
-		return { exitCode: 0 };
-	} catch (error) {
-		logWriter?.close();
-		if (error instanceof Error) {
-			logger.error("Dev server failed:", error.message);
-			if (verbose) logger.error(error.stack);
-		}
-		return { exitCode: 1 };
-	}
-}
-//#endregion
-export { runDevCommand };
+export { createMiniflareLog as _, logWorkerHandlerDetection as a, resolveViteIntegration as c, createRuntimeStdioForwarder as d, buildMiniflareDevConfig as f, runD1Migrations as g, resolveMainWorkerSurfacePaths as h, logRemoteBindingRequirements as i, resolveWorkerConfigWatchPath as l, collectWorkerWatchRoots as m, logMiniflareBindingDiagnostics as n, maybeStartBrowserShim as o, resolveR2PresignOrigin as p, logMiniflareConfigDiagnostics as r, maybeStartDOBundler as s, startViteProcess as t, createBrowserShim as u, createDOBundler as v };