devflare 1.0.0-next.7 → 1.0.0-next.71

package/dist/_chunks/dev-CRW_hBA3.js

@@ -0,0 +1,953 @@
+import { c as getDevflareDotenvPaths, d as resolveConfigEnvVars, o as EnvVarResolutionError } from "./preview-j9Kbx4-G.js";
+import { r as loadConfig } from "./loader-BC0skbnH.js";
+import { t as applyLocalDevVarsToConfig } from "./local-dev-vars-BFLS-HoI.js";
+import { a as cyanBold, f as logLine, g as yellow, o as dim, r as createCliTheme } from "./ui-BhCdDC2N.js";
+import { clearLocalSendEmailBindings, setLocalSendEmailBindings } from "../utils/send-email.js";
+import { s as resolveServiceBindings, t as discoverRoutes } from "./routes-CRXB3-iw.js";
+import { l as prepareComposedWorkerEntrypoint, m as hasWorkerSurfacePaths, n as resolveEffectiveViteProject } from "./vite-DTz2Pbtm.js";
+import { t as bundleWorkerEntry } from "./worker-bundler-CeMqQtBQ.js";
+import { _ as createMiniflareLog, a as logWorkerHandlerDetection, c as resolveViteIntegration, d as createRuntimeStdioForwarder, f as buildMiniflareDevConfig, g as runD1Migrations, h as resolveMainWorkerSurfacePaths, i as logRemoteBindingRequirements, l as resolveWorkerConfigWatchPath, m as collectWorkerWatchRoots, n as logMiniflareBindingDiagnostics, o as maybeStartBrowserShim, p as resolveR2PresignOrigin, r as logMiniflareConfigDiagnostics, s as maybeStartDOBundler, t as startViteProcess } from "./vite-process-BhGXJ764.js";
+import { n as bundleWorkflowEntrypointScript } from "./r2-presign-runtime-DlgH_FY8.js";
+import { t as generatedDir } from "./generated-dir-DC2kM-mt.js";
+import { r as stopSpawnedProcessTree, t as detectViteProject } from "./vite-utils-D_VR07Ks.js";
+import { dirname, relative, resolve } from "pathe";
+import { exec } from "node:child_process";
+import { createConsola } from "consola";
+import { connect } from "node:net";
+import { promisify } from "node:util";
+//#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/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/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-health.ts
+/** How often the runtime is probed. Cheap enough to be free, quick enough to catch a death between requests. */
+const RUNTIME_PROBE_INTERVAL_MS = 2e3;
+/** How long a single probe waits for the connection before counting as a failure. */
+const RUNTIME_PROBE_TIMEOUT_MS = 1e3;
+/**
+* Whether something is accepting connections at this address.
+*
+* A plain TCP connect, deliberately: the bridge only needs the listener to exist, and an HTTP request
+* would need a route that is meaningful for every app shape — a worker that 500s, hangs, or has no
+* matching route would then read as "dead" and have its runtime rebuilt underneath it. The tradeoff
+* is that a FOREIGN listener on the same port reads as alive; that only matters if something else
+* seizes the port while the runtime is down, in which case the rebuild fails on the address anyway
+* and the attempt limit reports it.
+*
+* @param options - `host`/`port` of the runtime, and how long to wait before giving up on the connect.
+* @returns true when the connection was accepted.
+*/
+function probeTcpReachable(options) {
+	const { host, port, timeoutMs = RUNTIME_PROBE_TIMEOUT_MS } = options;
+	return new Promise((resolve) => {
+		let settled = false;
+		const settle = (reachable) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			resolve(reachable);
+		};
+		const socket = connect({
+			host,
+			port
+		});
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => settle(true));
+		socket.once("timeout", () => settle(false));
+		socket.on("error", () => settle(false));
+	});
+}
+/**
+* A connect target that is dialable regardless of the address the runtime was bound to.
+*
+* A wildcard bind is not itself a valid destination on every platform, so probe the loopback address
+* of the SAME family. The families do not cross: a `::` bind is reachable on `::1` and NOT on
+* `127.0.0.1`, so collapsing both wildcards to the IPv4 loopback makes a healthy IPv6 runtime look
+* dead — and the watchdog would then kill and rebuild it on a loop.
+*
+* @param host - the configured Miniflare host.
+* @returns a host that can be connected to.
+*/
+function dialableHost(host) {
+	if (host === "::") return "::1";
+	if (host === "0.0.0.0") return "127.0.0.1";
+	return host;
+}
+/**
+* Watch a runtime and report it lost when it stops answering.
+*
+* The next probe is scheduled only once the previous one (and any rebuild it triggered) has finished,
+* so a slow rebuild cannot stack up signals. Reaching the threshold resets the failure count, which
+* spaces successive rebuild attempts a full threshold apart instead of firing on every probe.
+*
+* @param options - see {@link RuntimeWatchdogOptions}.
+* @returns a handle whose `stop()` ends the watch.
+*/
+function createRuntimeWatchdog(options) {
+	const { probe, onRuntimeLost, intervalMs = RUNTIME_PROBE_INTERVAL_MS, failureThreshold = 3, recoveryAttemptLimit = 3, setTimer = (fn, ms) => setTimeout(fn, ms), clearTimer = (handle) => clearTimeout(handle), logger } = options;
+	let stopped = false;
+	let timer = null;
+	let consecutiveFailures = 0;
+	let recoveryAttempts = 0;
+	function scheduleNext() {
+		if (stopped) return;
+		timer = setTimer(() => {
+			tick();
+		}, intervalMs);
+	}
+	async function tick() {
+		if (stopped) return;
+		const reachable = await probe().catch(() => false);
+		if (stopped) return;
+		if (reachable) {
+			consecutiveFailures = 0;
+			recoveryAttempts = 0;
+			scheduleNext();
+			return;
+		}
+		consecutiveFailures++;
+		if (consecutiveFailures < failureThreshold) {
+			scheduleNext();
+			return;
+		}
+		recoveryAttempts++;
+		if (recoveryAttempts > recoveryAttemptLimit) {
+			logger?.error(`The local runtime keeps going away after ${recoveryAttemptLimit} rebuild attempts. Giving up so the real error stays visible — restart \`devflare dev\` once it is resolved.`);
+			stop();
+			return;
+		}
+		try {
+			await onRuntimeLost();
+		} catch (error) {
+			logger?.error("[devflare dev] runtime rebuild failed:", error);
+		}
+		consecutiveFailures = 0;
+		scheduleNext();
+	}
+	function stop() {
+		if (stopped) return;
+		stopped = true;
+		if (timer !== null) {
+			clearTimer(timer);
+			timer = null;
+		}
+	}
+	scheduleNext();
+	return { stop };
+}
+//#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()}`;
+	/** Whether the local runtime is still accepting connections. */
+	async function isRuntimeReachable() {
+		return probeTcpReachable({
+			host: dialableHost(miniflareHost),
+			port: miniflarePort
+		});
+	}
+	/**
+	* Drop a runtime that has already gone away.
+	*
+	* Disposing a dead Miniflare routinely throws (its runtime is not there to talk to), which is not a
+	* reason to abandon the rebuild — so anything unrecognised is logged rather than propagated.
+	*/
+	async function discardDeadMiniflare() {
+		if (!state.miniflare) return;
+		try {
+			await state.miniflare.dispose();
+		} catch (error) {
+			if (!isIgnorableMiniflareDisposeError(error)) logger?.debug("Disposing the dead Miniflare threw (continuing with the rebuild):", error);
+		}
+		state.miniflare = null;
+	}
+	/**
+	* Set once {@link stop} begins. A rebuild started just before shutdown would otherwise construct a
+	* fresh Miniflare AFTER the teardown disposed the old one, leaking a runtime that outlives the
+	* server — which shows up as the next thing to use the port hanging.
+	*/
+	let isStopping = false;
+	/**
+	* Set once the runtime has come up at least once. Gates the rebuild path so a reload that arrives
+	* before the first start cannot mistake "not started yet" for "died".
+	*/
+	let hasStartedRuntime = false;
+	const reloadQueue = createReloadQueue({
+		reload: async () => {
+			if (isStopping) return;
+			if (hasStartedRuntime && !await isRuntimeReachable()) {
+				if (isStopping) return;
+				logger?.warn("Local runtime stopped responding — rebuilding it");
+				await discardDeadMiniflare();
+				await startMiniflare(state.currentDoResult);
+				await runD1Migrations({
+					cwd,
+					config: state.config,
+					miniflarePort,
+					logger
+				});
+				return;
+			}
+			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
+	});
+	/**
+	* Watches the runtime for the rest of the process's life, once it is first up.
+	*
+	* Held here rather than on {@link DevServerState} because it is pure server orchestration — it owns
+	* no resource the teardown sequence has to order around, only a timer.
+	*/
+	let runtimeWatchdog = null;
+	/**
+	* Begin watching the runtime, if it is not already being watched.
+	*
+	* Deliberately idempotent, because `startMiniflare` also runs on the REBUILD path — replacing the
+	* watchdog there would hand each rebuild a fresh recovery budget, so a probe that is wrong about a
+	* healthy runtime could rebuild it forever without the attempt limit ever biting. One watchdog for
+	* the server's lifetime keeps that budget meaningful; only a successful probe clears it.
+	*/
+	function watchRuntimeHealth() {
+		if (isStopping || runtimeWatchdog) return;
+		runtimeWatchdog = createRuntimeWatchdog({
+			probe: isRuntimeReachable,
+			onRuntimeLost: () => reloadQueue.schedule(),
+			logger
+		});
+	}
+	async function bundleMainWorker() {
+		if (!state.mainWorkerScriptPath || !state.config) {
+			state.bundledMainWorkerScriptPath = null;
+			return;
+		}
+		state.bundledMainWorkerScriptPath = await bundleWorkerEntry({
+			cwd,
+			inputFile: state.mainWorkerScriptPath,
+			outFile: generatedDir(cwd, "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);
+		const miniflare = new Miniflare(mfConfig);
+		state.miniflare = miniflare;
+		await miniflare.ready;
+		const displayHost = miniflareHost === "0.0.0.0" || miniflareHost === "::" ? "localhost" : miniflareHost;
+		logger?.success(`Miniflare ready on http://${displayHost}:${miniflarePort}`);
+		hasStartedRuntime = true;
+		watchRuntimeHealth();
+		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() {
+		isStopping = true;
+		runtimeWatchdog?.stop();
+		runtimeWatchdog = null;
+		await reloadQueue.drain();
+		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 };