devflare 1.0.0-next.15 → 1.0.0-next.17

package/dist/{dev-ymtphbkg.js → dev-dg8dh5c1.js}

@@ -1,45 +1,66 @@
 import {
   bundleWorkerEntry,
   createDOBundler
-} from "./index-001mw014.js";
+} from "./index-9fbtk7gv.js";
 import {
   detectViteProject,
   stopSpawnedProcessTree,
   waitForViteReady
 } from "./index-y1d8za14.js";
 import {
+  createCliTheme,
+  cyanBold,
+  dim,
+  logLine,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import {
+  DEFAULT_EMAIL_ENTRY_FILES,
+  DEFAULT_FETCH_ENTRY_FILES,
+  DEFAULT_QUEUE_ENTRY_FILES,
+  DEFAULT_SCHEDULED_ENTRY_FILES,
+  hasWorkerSurfacePaths,
   prepareComposedWorkerEntrypoint,
   resolveEffectiveViteProject,
+  resolveWorkerSurfacePaths,
   writeGeneratedViteConfig
-} from "./index-zvgc3e0c.js";
+} from "./index-p97s12vf.js";
 import {
   discoverRoutes,
   getRouteDirectoryCandidate
 } from "./index-1p814k7s.js";
 import"./index-rbht7m9r.js";
 import"./index-9wt9x09k.js";
+import {
+  GATEWAY_RUNTIME_JS
+} from "./index-q34rvh5a.js";
 import {
   clearLocalSendEmailBindings,
   setLocalSendEmailBindings
-} from "./index-fef08w43.js";
-import"./index-5s1bz1e0.js";
+} from "./index-124e9t4t.js";
+import"./index-n8k8chde.js";
 import {
   getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
+  getSingleBrowserBindingName,
   loadConfig,
   resolveConfigPath
-} from "./index-tksw7gpy.js";
-import"./index-v8vvsn9x.js";
-import"./index-xdq9ery1.js";
+} from "./index-dmbdj6va.js";
+import"./index-nte9n8w9.js";
+import"./index-z9fjnwa8.js";
+import"./index-p296ban8.js";
+import"./index-tte89s31.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/cli/commands/dev.ts
 import { createConsola } from "consola";
-import { relative, resolve as resolve2 } from "pathe";
+import { relative, resolve as resolve4 } from "pathe";
 
 // src/dev-server/server.ts
-import { dirname, resolve } from "pathe";
+import { resolve as resolve3 } from "pathe";
 
 // src/browser-shim/server.ts
 import { homedir } from "node:os";
@@ -53,8 +74,6 @@ import {
   detectBrowserPlatform,
   Browser as BrowserType
 } from "@puppeteer/browsers";
-var sessions = new Map;
-var history = [];
 var cachedExecutablePath = null;
 async function ensureChrome(cacheDir, logger) {
   if (cachedExecutablePath && existsSync(cachedExecutablePath)) {
@@ -94,8 +113,45 @@ function createBrowserShim(options = {}) {
   } = options;
   let server = null;
   let executablePath = null;
+  const sessions = new Map;
+  const history = [];
   let WebSocketServerClass = null;
   let WebSocketClass = null;
+  const maxRequestBodyBytes = 1024 * 1024;
+  function getRequestOrigin(req) {
+    const origin = req.headers.origin;
+    if (typeof origin === "string") {
+      return origin;
+    }
+    if (Array.isArray(origin) && origin[0]) {
+      return origin[0];
+    }
+    return null;
+  }
+  function isLoopbackOrigin(origin) {
+    try {
+      const url = new URL(origin);
+      return url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]";
+    } catch {
+      return false;
+    }
+  }
+  function applyCorsHeaders(req, res) {
+    const origin = getRequestOrigin(req);
+    if (!origin) {
+      return true;
+    }
+    if (!isLoopbackOrigin(origin)) {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Forbidden origin" }));
+      return false;
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    res.setHeader("Vary", "Origin");
+    return true;
+  }
   async function acquireSession(acquireOptions) {
     if (!executablePath) {
       throw new Error("Chrome not initialized");
@@ -174,9 +230,9 @@ function createBrowserShim(options = {}) {
     const url = new URL(req.url || "/", `http://${host}:${port}`);
     const method = req.method || "GET";
     logger?.debug(`[BrowserShim] ${method} ${url.pathname}${url.search ? url.search : ""}`);
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (!applyCorsHeaders(req, res)) {
+      return;
+    }
     if (method === "OPTIONS") {
       res.writeHead(204);
       res.end();
@@ -264,7 +320,16 @@ function createBrowserShim(options = {}) {
   function readBody(req) {
     return new Promise((resolve, reject) => {
       const chunks = [];
-      req.on("data", (chunk) => chunks.push(chunk));
+      let totalBytes = 0;
+      req.on("data", (chunk) => {
+        totalBytes += chunk.length;
+        if (totalBytes > maxRequestBodyBytes) {
+          req.destroy();
+          reject(new Error(`Request body exceeds ${maxRequestBodyBytes} bytes`));
+          return;
+        }
+        chunks.push(chunk);
+      });
       req.on("end", () => resolve(Buffer.concat(chunks).toString()));
       req.on("error", reject);
     });
@@ -298,6 +363,14 @@ function createBrowserShim(options = {}) {
     if (WebSocketServerClass) {
       const wss = new WebSocketServerClass({ noServer: true });
       server.on("upgrade", (request, socket, head) => {
+        const origin = getRequestOrigin(request);
+        if (origin && !isLoopbackOrigin(origin)) {
+          socket.write(`HTTP/1.1 403 Forbidden\r
+\r
+`);
+          socket.destroy();
+          return;
+        }
         const url = new URL(request.url || "/", `http://${host}:${port}`);
         if (url.pathname !== "/v1/connectDevtools") {
           socket.destroy();
@@ -415,7 +488,7 @@ function createBrowserShim(options = {}) {
     logger?.success(`Browser shim server ready on http://${host}:${port}`);
   }
   async function stop() {
-    for (const sessionId of sessions.keys()) {
+    for (const sessionId of Array.from(sessions.keys())) {
       await closeSession(sessionId, 3, "ServerShutdown");
     }
     if (server) {
@@ -812,186 +885,129 @@ async function checkRemoteBindingRequirements(config) {
   };
 }
 
-// src/dev-server/miniflare-log.ts
-var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
-var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
-function normalizeMiniflareMessage(message) {
-  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
-}
-function formatCompatibilityDateFallbackNotice(message) {
-  const normalizedMessage = normalizeMiniflareMessage(message);
-  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
-  if (!match) {
-    return null;
-  }
-  const [, _supportedDate, requestedDate, fallbackDate] = match;
-  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
-}
-function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
-  const log = new BaseLog(level);
-  const originalWarn = log.warn.bind(log);
-  const originalInfo = log.info.bind(log);
-  log.warn = (message) => {
-    const notice = formatCompatibilityDateFallbackNotice(message);
-    if (!notice) {
-      originalWarn(message);
-      return;
-    }
-    if (logger) {
-      logger.info(notice);
-      return;
-    }
-    originalInfo(notice);
-  };
-  return log;
-}
-
-// src/dev-server/runtime-stdio.ts
-import { createInterface } from "node:readline";
-function writeStdout(logger, message) {
-  if (typeof logger?.log === "function") {
-    logger.log(message);
-    return;
-  }
-  if (typeof logger?.info === "function") {
-    logger.info(message);
-    return;
-  }
-  console.log(message);
-}
-function writeStderr(logger, message) {
-  if (typeof logger?.error === "function") {
-    logger.error(message);
-    return;
-  }
-  console.error(message);
-}
-function createRuntimeStdioForwarder(logger) {
-  return (stdout, stderr) => {
-    createInterface({ input: stdout }).on("line", (data) => {
-      writeStdout(logger, data);
-    });
-    createInterface({ input: stderr }).on("line", (data) => {
-      writeStderr(logger, data);
-    });
-  };
+// src/dev-server/d1-migrations.ts
+import { resolve } from "pathe";
+var MIGRATION_RETRY_DELAYS_MS = [500, 1000, 1500, 2000];
+function collectMigrationStatements(sql) {
+  const cleanedSql = sql.split(`
+`).filter((line) => !line.trim().startsWith("--")).join(`
+`);
+  return cleanedSql.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
 }
-
-// src/dev-server/server.ts
-var DEFAULT_FETCH_ENTRY_FILES = [
-  "src/fetch.ts",
-  "src/fetch.js",
-  "src/fetch.mts",
-  "src/fetch.mjs"
-];
-var DEFAULT_QUEUE_ENTRY_FILES = [
-  "src/queue.ts",
-  "src/queue.js",
-  "src/queue.mts",
-  "src/queue.mjs"
-];
-var DEFAULT_SCHEDULED_ENTRY_FILES = [
-  "src/scheduled.ts",
-  "src/scheduled.js",
-  "src/scheduled.mts",
-  "src/scheduled.mjs"
-];
-var DEFAULT_EMAIL_ENTRY_FILES = [
-  "src/email.ts",
-  "src/email.js",
-  "src/email.mts",
-  "src/email.mjs"
-];
-var DEFAULT_TRANSPORT_ENTRY_FILES = [
-  "src/transport.ts",
-  "src/transport.js",
-  "src/transport.mts",
-  "src/transport.mjs"
-];
-var INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
-function formatErrorMessage(error) {
+function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false) {
-    return null;
-  }
-  const fs = await import("node:fs/promises");
-  const candidates = new Set;
-  if (typeof configuredPath === "string" && configuredPath) {
-    candidates.add(configuredPath);
-  }
-  for (const defaultEntry of defaultEntries) {
-    candidates.add(defaultEntry);
-  }
-  for (const candidate of candidates) {
-    const absolutePath = resolve(cwd, candidate);
+async function waitForRetry(delayMs) {
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, delayMs));
+}
+async function applyMigrationsToBinding(options) {
+  const { bindingName, statements, miniflarePort, logger } = options;
+  let lastError;
+  for (let attempt = 0;attempt <= MIGRATION_RETRY_DELAYS_MS.length; attempt++) {
+    if (attempt > 0) {
+      await waitForRetry(MIGRATION_RETRY_DELAYS_MS[attempt - 1]);
+    }
     try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      continue;
+      const response = await fetch(`http://127.0.0.1:${miniflarePort}/_devflare/migrate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ bindingName, statements })
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+      }
+      const result = await response.json();
+      if (result.success) {
+        logger?.success(`D1 migrations applied to ${bindingName}`);
+        return;
+      }
+      throw new Error(result.error || "Unknown error");
+    } catch (error) {
+      lastError = error;
     }
   }
-  return null;
-}
-async function resolveMainWorkerSurfacePaths(cwd, config) {
-  return {
-    fetch: await resolveWorkerHandlerPath(cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES),
-    queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES),
-    scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES),
-    email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES)
-  };
-}
-function hasWorkerSurfacePaths(surfacePaths) {
-  return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
+  logger?.warn(`Failed to apply migrations to ${bindingName}: ${getErrorMessage(lastError)}`);
 }
-function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false || configuredPath === null) {
+async function runD1Migrations(options) {
+  const { cwd, config, miniflarePort, logger } = options;
+  if (!config?.bindings?.d1) {
     return;
   }
-  if (typeof configuredPath === "string" && configuredPath) {
-    roots.add(dirname(resolve(cwd, configuredPath)));
+  const { existsSync: existsSync2, readdirSync, readFileSync, statSync } = await import("node:fs");
+  const migrationsDir = resolve(cwd, "migrations");
+  if (!existsSync2(migrationsDir)) {
+    logger?.debug("No migrations/ directory found, skipping D1 migrations");
     return;
   }
-  for (const defaultEntry of defaultEntries) {
-    roots.add(dirname(resolve(cwd, defaultEntry)));
-  }
-}
-function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
-  const roots = new Set;
-  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
-    if (surfacePath) {
-      roots.add(dirname(surfacePath));
+  const sharedFiles = readdirSync(migrationsDir).filter((file) => file.endsWith(".sql")).sort();
+  let sharedStatements = null;
+  if (sharedFiles.length > 0) {
+    sharedStatements = [];
+    for (const file of sharedFiles) {
+      const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
+      const fileStatements = collectMigrationStatements(sql);
+      sharedStatements.push(...fileStatements);
+      logger?.debug(`Shared file ${file}: ${fileStatements.length} statement(s)`);
     }
   }
-  addWorkerWatchRoots(roots, cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES);
-  addWorkerWatchRoots(roots, cwd, config.files?.transport, DEFAULT_TRANSPORT_ENTRY_FILES);
-  const routeDirectory = getRouteDirectoryCandidate(cwd, config);
-  if (routeDirectory) {
-    roots.add(routeDirectory.absoluteDir);
+  for (const [bindingName] of Object.entries(config.bindings.d1)) {
+    const perBindingDir = resolve(migrationsDir, bindingName);
+    const hasPerBindingDir = existsSync2(perBindingDir) && statSync(perBindingDir).isDirectory();
+    let statements = [];
+    let fileCount = 0;
+    let sourceLabel = "";
+    if (hasPerBindingDir) {
+      const perBindingFiles = readdirSync(perBindingDir).filter((file) => file.endsWith(".sql")).sort();
+      if (perBindingFiles.length === 0) {
+        logger?.debug(`No SQL migration files in migrations/${bindingName}/, skipping ${bindingName}`);
+        continue;
+      }
+      for (const file of perBindingFiles) {
+        const sql = readFileSync(resolve(perBindingDir, file), "utf-8");
+        const fileStatements = collectMigrationStatements(sql);
+        statements.push(...fileStatements);
+        logger?.debug(`File ${bindingName}/${file}: ${fileStatements.length} statement(s)`);
+      }
+      fileCount = perBindingFiles.length;
+      sourceLabel = `migrations/${bindingName}/`;
+    } else if (sharedStatements !== null) {
+      statements = sharedStatements;
+      fileCount = sharedFiles.length;
+      sourceLabel = "migrations/ [shared fallback]";
+    } else {
+      logger?.debug(`No migrations found for ${bindingName}, skipping`);
+      continue;
+    }
+    logger?.info(`Running ${fileCount} D1 migration(s) for ${bindingName} (from ${sourceLabel})`);
+    if (statements.length === 0) {
+      logger?.debug(`No executable D1 migration statements for ${bindingName}`);
+      continue;
+    }
+    await applyMigrationsToBinding({
+      bindingName,
+      statements,
+      miniflarePort,
+      logger
+    });
   }
-  return [...roots];
 }
+
+// src/dev-server/gateway-script.ts
 function getGatewayScript(wsRoutes = [], debug = false, appServiceBindingName = null) {
   const wsRoutesJson = JSON.stringify(wsRoutes);
   const appServiceBindingJson = JSON.stringify(appServiceBindingName);
   return `
-// Bridge Gateway Worker — RPC Handler
-// Handles all binding operations via WebSocket RPC
-// Also handles WebSocket proxying to Durable Objects
+${GATEWAY_RUNTIME_JS}
+
+// Bridge Gateway Worker — Dev Server
+// Handles WebSocket RPC, DO WS proxying, HTTP transfer, D1 migration, email ingest
 
 const DEBUG = ${debug}
 const log = (...args) => DEBUG && console.log('[Gateway]', ...args)
 
-const activeStreams = new Map()
 const wsProxies = new Map()
-const incomingStreams = new Map()
 
-// WebSocket routes configuration (injected at build time)
 const WS_ROUTES = ${wsRoutesJson}
 const APP_SERVICE_BINDING = ${appServiceBindingJson}
 
@@ -1000,32 +1016,26 @@ export default {
 		const url = new URL(request.url)
 		const isWebSocket = request.headers.get('Upgrade') === 'websocket'
 
-		// Check if this is a WebSocket request matching a DO route
 		if (isWebSocket) {
 			const matchedRoute = matchWsRoute(url.pathname)
 			if (matchedRoute) {
 				return handleDoWebSocket(request, env, url, matchedRoute)
 			}
-			// Otherwise handle as bridge RPC WebSocket
 			return handleBridgeWebSocket(request, env, ctx)
 		}
 
-		// HTTP endpoint for large file transfers
 		if (url.pathname.startsWith('/_devflare/transfer/')) {
 			return handleHttpTransfer(request, env, url)
 		}
 
-		// D1 migration endpoint
 		if (url.pathname === '/_devflare/migrate' && request.method === 'POST') {
 			return handleMigration(request, env)
 		}
 
-		// Email handler endpoint (simulates incoming email)
 		if (url.pathname === '/cdn-cgi/handler/email' && request.method === 'POST') {
 			return handleEmailIncoming(request, env, ctx, url)
 		}
 
-		// Health check
 		if (url.pathname === '/_devflare/health') {
 			return new Response(JSON.stringify({
 				ok: true,
@@ -1045,7 +1055,6 @@ export default {
 	}
 }
 
-// Handle D1 migrations
 async function handleMigration(request, env) {
 	try {
 		const { bindingName, statements } = await request.json()
@@ -1072,28 +1081,26 @@ async function handleMigration(request, env) {
 				}
 			}
 		}
-		
-		// Verify table exists after migration
+
 		try {
 			const tables = await db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all()
 			log('Tables after migration:', JSON.stringify(tables))
 		} catch (e) {
 			log('Error listing tables:', e.message)
 		}
-		
+
 		return Response.json({ success: true, results })
 	} catch (error) {
 		return Response.json({ error: error?.message || String(error) }, { status: 500 })
 	}
 }
 
-// Handle incoming email (simulates email() handler)
 async function handleEmailIncoming(request, env, ctx, url) {
 	try {
 		const from = url.searchParams.get('from') || 'unknown@example.com'
 		const to = url.searchParams.get('to') || 'worker@example.com'
 		const rawBody = await request.text()
-		
+
 		log('Email incoming:', { from, to, bodyLength: rawBody.length })
 
 		if (APP_SERVICE_BINDING) {
@@ -1115,7 +1122,7 @@ async function handleEmailIncoming(request, env, ctx, url) {
 				}
 			}
 		}
-		
+
 		return new Response(JSON.stringify({ ok: true, from, to }), {
 			headers: { 'Content-Type': 'application/json' }
 		})
@@ -1125,10 +1132,8 @@ async function handleEmailIncoming(request, env, ctx, url) {
 	}
 }
 
-// Match URL path against configured WS routes
 function matchWsRoute(pathname) {
 	for (const route of WS_ROUTES) {
-		// Simple exact match for now (could add glob/regex later)
 		if (pathname === route.pattern || pathname.startsWith(route.pattern + '?')) {
 			return route
 		}
@@ -1136,31 +1141,23 @@ function matchWsRoute(pathname) {
 	return null
 }
 
-// Handle WebSocket upgrade that should go to a Durable Object
 async function handleDoWebSocket(request, env, url, route) {
 	try {
-		// Get the DO namespace
 		const namespace = env[route.doNamespace]
 		if (!namespace) {
 			console.error('[Gateway] DO namespace not found:', route.doNamespace)
 			return new Response('DO namespace not found: ' + route.doNamespace, { status: 500 })
 		}
 
-		// Get the instance ID from query params
 		const idValue = url.searchParams.get(route.idParam) || 'default'
-
-		// Get or create DO instance
 		const doId = namespace.idFromName(idValue)
 		const stub = namespace.get(doId)
 
-		// Construct the forward URL for the DO
 		const forwardUrl = new URL(route.forwardPath, url.origin)
-		// Forward all query params
 		url.searchParams.forEach((v, k) => forwardUrl.searchParams.set(k, v))
 
 		log('Forwarding WebSocket to DO:', route.doNamespace, 'id:', idValue, 'path:', forwardUrl.pathname)
 
-		// Forward the request to the DO
 		return stub.fetch(forwardUrl.toString(), {
 			method: request.method,
 			headers: request.headers
@@ -1171,7 +1168,6 @@ async function handleDoWebSocket(request, env, url, route) {
 	}
 }
 
-// Handle bridge RPC WebSocket (for Node.js Vite server communication)
 function handleBridgeWebSocket(request, env, ctx) {
 	const { 0: client, 1: server } = new WebSocketPair()
 	server.accept()
@@ -1187,7 +1183,6 @@ function handleBridgeWebSocket(request, env, ctx) {
 	})
 
 	server.addEventListener('close', () => {
-		activeStreams.clear()
 		wsProxies.clear()
 	})
 
@@ -1218,180 +1213,11 @@ async function handleRpcCall(msg, ws, env, ctx) {
 		ws.send(JSON.stringify({
 			t: 'rpc.err',
 			id: msg.id,
-			error: { code: error.code || 'INTERNAL_ERROR', message: error.message }
+			error: { code: error?.code || 'INTERNAL_ERROR', message: error?.message || String(error) }
 		}))
 	}
 }
 
-async function executeRpcMethod(method, params, env, ctx) {
-	const parts = method.split('.')
-	const bindingName = parts[0]
-	const operation = parts.slice(1).join('.')
-	const binding = env[bindingName]
-	const RAW_EMAIL = 'EmailMessage::raw'
-
-	if (!binding) throw new Error('Binding not found: ' + bindingName)
-
-	// KV operations
-	if (operation === 'get') return binding.get(params[0], params[1])
-	if (operation === 'put') return binding.put(params[0], params[1], params[2])
-	if (operation === 'delete') return binding.delete(params[0])
-	if (operation === 'list') return binding.list(params[0])
-	if (operation === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-
-	// R2 operations
-	if (operation === 'head') return serializeR2Object(await binding.head(params[0]))
-	if (operation === 'r2.get') {
-		const obj = await binding.get(params[0], params[1])
-		if (!obj) return null
-		const body = await obj.arrayBuffer()
-		return serializeR2ObjectBody(obj, arrayBufferToBase64(body))
-	}
-	if (operation === 'r2.put') {
-		// Deserialize the value if it's a serialized ArrayBuffer/Uint8Array
-		let value = params[1]
-		if (value && typeof value === 'object') {
-			if (value.__type === 'ArrayBuffer') {
-				value = base64ToArrayBuffer(value.data)
-			} else if (value.__type === 'Uint8Array') {
-				value = base64ToArrayBuffer(value.data)
-			}
-		}
-		return serializeR2Object(await binding.put(params[0], value, params[2]))
-	}
-	if (operation === 'r2.delete') return binding.delete(params[0])
-	if (operation === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
-
-	// D1 operations
-	if (operation === 'exec') return binding.exec(params[0])
-	if (operation.startsWith('stmt.')) {
-		log('D1 RPC:', bindingName, operation, 'sql:', String(params[0]).slice(0, 60))
-		const mode = operation.split('.')[1]
-		const [sql, ...rest] = params
-		
-		// For first/raw, the last element is the column/options parameter (may be undefined)
-		// For all/run, rest contains only bindings
-		let bindings = rest
-		let extraParam = undefined
-		
-		if (mode === 'first' || mode === 'raw') {
-			// Last element is the column/options (may be undefined)
-			extraParam = rest[rest.length - 1]
-			bindings = rest.slice(0, -1)
-		}
-		
-		let stmt = binding.prepare(sql)
-		if (bindings.length > 0) stmt = stmt.bind(...bindings)
-		
-		if (mode === 'first') {
-			// Only pass column if it's a non-empty string
-			if (typeof extraParam === 'string' && extraParam.length > 0) {
-				return stmt.first(extraParam)
-			}
-			return stmt.first()
-		}
-		if (mode === 'all') return stmt.all()
-		if (mode === 'run') return stmt.run()
-		if (mode === 'raw') return stmt.raw(extraParam)
-	}
-
-	// DO operations
-	if (operation === 'idFromName') {
-		const id = binding.idFromName(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'idFromString') {
-		const id = binding.idFromString(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'newUniqueId') {
-		const id = binding.newUniqueId(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (operation === 'stub.fetch') {
-		const [, serializedId, serializedReq] = params
-		log('stub.fetch request:', {
-			url: serializedReq.url,
-			method: serializedReq.method,
-			headers: serializedReq.headers,
-			hasBody: !!serializedReq.body
-		})
-		const id = binding.idFromString(serializedId.hex)
-		const stub = binding.get(id)
-		try {
-			const response = await stub.fetch(new Request(serializedReq.url, {
-				method: serializedReq.method,
-				headers: serializedReq.headers,
-				body: serializedReq.body?.type === 'bytes' ? base64ToArrayBuffer(serializedReq.body.data) : undefined
-			}))
-			// Clone to read body for logging if there's an error
-			const cloned = response.clone()
-			const serialized = await serializeResponse(response)
-			log('stub.fetch response:', {
-				status: serialized.status,
-				headers: serialized.headers,
-				bodyLength: serialized.body?.data?.length || 0
-			})
-			// If 500, log the body content
-			if (response.status >= 400) {
-				const errBody = await cloned.text()
-				log('Error response body:', errBody)
-			}
-			return serialized
-		} catch (err) {
-			console.error('[Gateway] stub.fetch error:', err)
-			throw err
-		}
-	}
-	if (operation === 'stub.rpc') {
-		const [, serializedId, methodName, args] = params
-		const id = binding.idFromString(serializedId.hex)
-		const stub = binding.get(id)
-		const response = await stub.fetch(new Request('http://do/_rpc', {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ method: methodName, params: args })
-		}))
-		const result = await response.json()
-		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
-		return result.result
-	}
-
-	// Queue operations
-	if (operation === 'send') return binding.send(params[0], params[1])
-	if (operation === 'sendBatch') return binding.sendBatch(params[0], params[1])
-
-	// Email send operations (send_email binding)
-	if (operation === 'email.send') {
-		const message = params[0]
-		log('Email send:', { from: message?.from, to: message?.to })
-		if (binding && typeof binding.send === 'function') {
-			if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
-				return binding.send({
-					from: message.from,
-					to: message.to,
-					[RAW_EMAIL]: createEmailMessageRaw(message.raw)
-				})
-			}
-			return binding.send(message)
-		}
-		// Return success even if no real binding (simulated)
-		return { ok: true, simulated: true }
-	}
-
-	throw new Error('Unknown operation: ' + method)
-}
-
-function createEmailMessageRaw(raw) {
-	if (typeof raw === 'string' || raw instanceof ReadableStream) {
-		return raw
-	}
-	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
-		return new Response(raw).body
-	}
-	throw new Error('Unsupported EmailMessage raw payload')
-}
-
 async function handleWsOpen(msg, ws, env) {
 	try {
 		const binding = env[msg.target.binding]
@@ -1448,7 +1274,7 @@ async function handleHttpTransfer(request, env, url) {
 
 	if (request.method === 'PUT' || request.method === 'POST') {
 		const result = await bucket.put(key, request.body)
-		return new Response(JSON.stringify(result), { headers: { 'Content-Type': 'application/json' } })
+		return new Response(JSON.stringify(serializeR2Object(result)), { headers: { 'Content-Type': 'application/json' } })
 	}
 
 	if (request.method === 'GET') {
@@ -1464,71 +1290,253 @@ async function handleHttpTransfer(request, env, url) {
 
 	return new Response('Method not allowed', { status: 405 })
 }
+`;
+}
 
-// Helpers
-function serializeR2Object(obj) {
-	if (!obj) return null
-	return {
-		__type: 'R2Object',
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		checksums: obj.checksums,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata,
-		range: obj.range,
-		storageClass: obj.storageClass
-	}
+// src/dev-server/miniflare-log.ts
+var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
+var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
+function normalizeMiniflareMessage(message) {
+  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
 }
-function serializeR2ObjectBody(obj, bodyData) {
-	if (!obj) return null
-	return {
-		__type: 'R2ObjectBody',
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		checksums: obj.checksums,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata,
-		range: obj.range,
-		storageClass: obj.storageClass,
-		bodyData
-	}
+function formatCompatibilityDateFallbackNotice(message) {
+  const normalizedMessage = normalizeMiniflareMessage(message);
+  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
+  if (!match) {
+    return null;
+  }
+  const [, _supportedDate, requestedDate, fallbackDate] = match;
+  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
 }
-function serializeR2Objects(result) {
-	if (!result) return null
-	return { objects: result.objects.map(serializeR2Object), truncated: result.truncated, cursor: result.cursor }
+function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
+  const log = new BaseLog(level);
+  const originalWarn = log.warn.bind(log);
+  const originalInfo = log.info.bind(log);
+  log.warn = (message) => {
+    const notice = formatCompatibilityDateFallbackNotice(message);
+    if (!notice) {
+      originalWarn(message);
+      return;
+    }
+    if (logger) {
+      logger.info(notice);
+      return;
+    }
+    originalInfo(notice);
+  };
+  return log;
 }
-async function serializeResponse(response) {
-	// Read body as bytes and encode as base64
-	let body = null
-	if (response.body) {
-		const bytes = await response.arrayBuffer()
-		if (bytes.byteLength > 0) {
-			body = { type: 'bytes', data: arrayBufferToBase64(bytes) }
-		}
-	}
-	return { status: response.status, statusText: response.statusText, headers: [...response.headers.entries()], body }
+
+// src/dev-server/runtime-stdio.ts
+import { createInterface } from "node:readline";
+function writeStdout(logger, message) {
+  if (typeof logger?.log === "function") {
+    logger.log(message);
+    return;
+  }
+  if (typeof logger?.info === "function") {
+    logger.info(message);
+    return;
+  }
+  console.log(message);
 }
-function arrayBufferToBase64(buffer) {
-	const bytes = new Uint8Array(buffer)
-	let binary = ''
-	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i])
-	return btoa(binary)
+function writeStderr(logger, message) {
+  if (typeof logger?.error === "function") {
+    logger.error(message);
+    return;
+  }
+  console.error(message);
 }
-function base64ToArrayBuffer(base64) {
-	const binary = atob(base64)
-	const bytes = new Uint8Array(binary.length)
-	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
-	return bytes.buffer
+function createRuntimeStdioForwarder(logger) {
+  return (stdout, stderr) => {
+    createInterface({ input: stdout }).on("line", (data) => {
+      writeStdout(logger, data);
+    });
+    createInterface({ input: stderr }).on("line", (data) => {
+      writeStderr(logger, data);
+    });
+  };
 }
-`;
+
+// src/dev-server/vite-process.ts
+import { spawn } from "node:child_process";
+async function startViteProcess(options) {
+  const {
+    cwd,
+    vitePort,
+    miniflarePort,
+    generatedViteConfigPath,
+    logger
+  } = options;
+  const args = ["vite", "dev", "--port", String(vitePort)];
+  if (generatedViteConfigPath) {
+    args.push("--config", generatedViteConfigPath);
+  }
+  const viteProcess = spawn("bunx", args, {
+    cwd,
+    stdio: ["inherit", "pipe", "pipe"],
+    windowsHide: true,
+    env: {
+      ...process.env,
+      DEVFLARE_DEV: "true",
+      DEVFLARE_BRIDGE_PORT: String(miniflarePort),
+      FORCE_COLOR: "1"
+    }
+  });
+  const readyUrl = await waitForViteReady(viteProcess, {
+    onStdout(chunk) {
+      process.stdout.write(chunk);
+    },
+    onStderr(chunk) {
+      process.stderr.write(chunk);
+    }
+  });
+  if (readyUrl) {
+    logger?.success(`Vite dev server started on ${readyUrl}`);
+    return viteProcess;
+  }
+  logger?.warn("Vite process started, but the final local URL could not be confirmed yet");
+  return viteProcess;
+}
+
+// src/dev-server/worker-surface-paths.ts
+import { dirname, resolve as resolve2 } from "pathe";
+var DEFAULT_TRANSPORT_ENTRY_FILES = [
+  "src/transport.ts",
+  "src/transport.js",
+  "src/transport.mts",
+  "src/transport.mjs"
+];
+var resolveMainWorkerSurfacePaths = resolveWorkerSurfacePaths;
+function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
+  if (configuredPath === false || configuredPath === null) {
+    return;
+  }
+  if (typeof configuredPath === "string" && configuredPath) {
+    roots.add(dirname(resolve2(cwd, configuredPath)));
+    return;
+  }
+  for (const defaultEntry of defaultEntries) {
+    roots.add(dirname(resolve2(cwd, defaultEntry)));
+  }
+}
+function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
+  const roots = new Set;
+  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
+    if (surfacePath) {
+      roots.add(dirname(surfacePath));
+    }
+  }
+  addWorkerWatchRoots(roots, cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES);
+  addWorkerWatchRoots(roots, cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES);
+  addWorkerWatchRoots(roots, cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES);
+  addWorkerWatchRoots(roots, cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES);
+  addWorkerWatchRoots(roots, cwd, config.files?.transport, DEFAULT_TRANSPORT_ENTRY_FILES);
+  const routeDirectory = getRouteDirectoryCandidate(cwd, config);
+  if (routeDirectory) {
+    roots.add(routeDirectory.absoluteDir);
+  }
+  return [...roots];
+}
+
+// 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 : undefined,
+    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;
+}
+
+// src/dev-server/server.ts
+var INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 function createDevServer(options) {
   const {
@@ -1571,11 +1579,10 @@ function createDevServer(options) {
     bundledMainWorkerScriptPath = await bundleWorkerEntry({
       cwd,
       inputFile: mainWorkerScriptPath,
-      outFile: resolve(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      outFile: resolve3(cwd, ".devflare", "worker-entrypoints", "main.js"),
       rolldownOptions: config.rolldown?.options,
       sourcemap: config.rolldown?.sourcemap,
       minify: config.rolldown?.minify,
-      target: config.rolldown?.target,
       logger
     });
     logger?.debug(`Bundled main worker → ${bundledMainWorkerScriptPath}`);
@@ -1585,7 +1592,7 @@ function createDevServer(options) {
       throw new Error("Config not loaded");
     const loadedConfig = config;
     const bindings = loadedConfig.bindings ?? {};
-    const persistPath = resolve(cwd, ".devflare/data");
+    const persistPath = resolve3(cwd, ".devflare/data");
     const appWorkerName = loadedConfig.name;
     const shouldRunMainWorker = !enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length));
     const queueProducers = (() => {
@@ -1661,7 +1668,11 @@ function createDevServer(options) {
         modules: true,
         compatibilityDate: loadedConfig.compatibilityDate,
         compatibilityFlags: compatFlags,
-        ...bindings.kv && { kvNamespaces: bindings.kv },
+        ...bindings.kv && {
+          kvNamespaces: Object.fromEntries(Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => {
+            return [bindingName, getLocalKVNamespaceIdentifier(bindingConfig)];
+          }))
+        },
         ...bindings.r2 && { r2Buckets: bindings.r2 },
         ...bindings.d1 && {
           d1Databases: Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
@@ -1703,7 +1714,7 @@ function createDevServer(options) {
     });
     gatewayWorker.routes = ["*"];
     const hasDurableObjectBundles = !!doResult && doResult.bundles.size > 0;
-    const browserBindingName = bindings.browser?.binding;
+    const browserBindingName = getSingleBrowserBindingName(bindings.browser);
     const needsBrowserWorker = Boolean(browserBindingName && (hasDurableObjectBundles || shouldRunMainWorker));
     if (!shouldRunMainWorker && !hasDurableObjectBundles && !needsBrowserWorker) {
       return {
@@ -1848,7 +1859,7 @@ function createDevServer(options) {
   }
   async function resolveWorkerConfigWatchPath() {
     if (configPath) {
-      const explicitPath = resolve(cwd, configPath);
+      const explicitPath = resolve3(cwd, configPath);
       const fs = await import("node:fs/promises");
       try {
         await fs.access(explicitPath);
@@ -1866,7 +1877,7 @@ function createDevServer(options) {
     const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, config, undefined, {
       devInternalEmail: true
     });
-    mainWorkerScriptPath = composedMainEntry ? resolve(cwd, composedMainEntry) : null;
+    mainWorkerScriptPath = composedMainEntry ? resolve3(cwd, composedMainEntry) : null;
     if (mainWorkerScriptPath) {
       await bundleMainWorker();
     } else {
@@ -1907,7 +1918,7 @@ function createDevServer(options) {
     await refreshWorkerOnlySurfaceState();
     await reloadMiniflare(currentDoResult);
   }
-  async function startWorkerSourceWatcher() {
+  async function startWorkerSourceWatcher2() {
     if (enableVite || !config) {
       return;
     }
@@ -1915,173 +1926,18 @@ function createDevServer(options) {
     if (watchTargets.length === 0) {
       return;
     }
-    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 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 reloadWorkerOnlyConfig();
-          return;
-        }
-        logger?.info(`Worker source changed: ${filePath}`);
+    workerWatchTargets = watchTargets;
+    workerSourceWatcher = await startWorkerSourceWatcher({
+      watchTargets,
+      resolvedWorkerConfigPath,
+      logger,
+      onConfigChange: reloadWorkerOnlyConfig,
+      onWorkerChange: async () => {
         await refreshWorkerOnlySurfaceState();
         await reloadMiniflare(currentDoResult);
-      } catch (error) {
-        logger?.error("Worker source reload failed:", error);
-      } finally {
-        reloadInProgress = false;
-        if (pendingReloadPath) {
-          const nextPath = pendingReloadPath;
-          pendingReloadPath = null;
-          await triggerReload(nextPath);
-        }
-      }
-    };
-    const scheduleReload = (filePath) => {
-      if (reloadTimeout) {
-        clearTimeout(reloadTimeout);
       }
-      reloadTimeout = setTimeout(() => {
-        triggerReload(filePath);
-      }, 150);
-    };
-    workerWatchTargets = watchTargets;
-    workerSourceWatcher = chokidar.watch(watchTargets, {
-      ignoreInitial: true,
-      usePolling: isWindows,
-      interval: isWindows ? 300 : undefined,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      },
-      ignored: (filePath) => isIgnoredPath(filePath)
-    });
-    const onFileEvent = (filePath) => {
-      if (isIgnoredPath(filePath)) {
-        return;
-      }
-      scheduleReload(filePath);
-    };
-    workerSourceWatcher.on("change", onFileEvent);
-    workerSourceWatcher.on("add", onFileEvent);
-    workerSourceWatcher.on("unlink", onFileEvent);
-    workerSourceWatcher.on("error", (error) => {
-      logger?.error("Worker source watcher error:", error);
-    });
-    await new Promise((resolvePromise, rejectPromise) => {
-      const handleReady = () => {
-        workerSourceWatcher?.off("error", handleInitialError);
-        logger?.info(`Worker source watcher ready (${watchTargets.length} target(s))`);
-        resolvePromise();
-      };
-      const handleInitialError = (error) => {
-        workerSourceWatcher?.off("ready", handleReady);
-        rejectPromise(error instanceof Error ? error : new Error(String(error)));
-      };
-      workerSourceWatcher?.once("ready", handleReady);
-      workerSourceWatcher?.once("error", handleInitialError);
     });
   }
-  async function runD1Migrations() {
-    if (!miniflare || !config?.bindings?.d1)
-      return;
-    const { existsSync: existsSync2, readdirSync, readFileSync } = await import("node:fs");
-    const migrationsDir = resolve(cwd, "migrations");
-    if (!existsSync2(migrationsDir)) {
-      logger?.debug("No migrations/ directory found, skipping D1 migrations");
-      return;
-    }
-    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
-    if (files.length === 0) {
-      logger?.debug("No SQL migration files found");
-      return;
-    }
-    logger?.info(`Running ${files.length} D1 migration(s)...`);
-    const allStatements = [];
-    for (const file of files) {
-      const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
-      const cleanedSql = sql.split(`
-`).filter((line) => !line.trim().startsWith("--")).join(`
-`);
-      const statements = cleanedSql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
-      allStatements.push(...statements);
-      logger?.debug(`File ${file}: ${statements.length} statement(s)`);
-    }
-    for (const [bindingName] of Object.entries(config.bindings.d1)) {
-      for (let attempt = 0;attempt < 5; attempt++) {
-        await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
-        try {
-          const response = await fetch(`http://127.0.0.1:${miniflarePort}/_devflare/migrate`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ bindingName, statements: allStatements })
-          });
-          if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`HTTP ${response.status}: ${text}`);
-          }
-          const result = await response.json();
-          if (result.success) {
-            logger?.success(`D1 migrations applied to ${bindingName}`);
-            break;
-          } else {
-            throw new Error(result.error || "Unknown error");
-          }
-        } catch (error) {
-          if (attempt === 4) {
-            logger?.warn(`Failed to apply migrations to ${bindingName}: ${error}`);
-          }
-        }
-      }
-    }
-  }
-  async function startVite() {
-    const { spawn } = await import("node:child_process");
-    const args = ["vite", "dev", "--port", String(vitePort)];
-    if (generatedViteConfigPath) {
-      args.push("--config", generatedViteConfigPath);
-    }
-    viteProcess = spawn("bunx", args, {
-      cwd,
-      stdio: ["inherit", "pipe", "pipe"],
-      windowsHide: true,
-      env: {
-        ...process.env,
-        DEVFLARE_DEV: "true",
-        DEVFLARE_BRIDGE_PORT: String(miniflarePort),
-        FORCE_COLOR: "1"
-      }
-    });
-    const readyUrl = await waitForViteReady(viteProcess, {
-      onStdout(chunk) {
-        process.stdout.write(chunk);
-      },
-      onStderr(chunk) {
-        process.stderr.write(chunk);
-      }
-    });
-    if (readyUrl) {
-      logger?.success(`Vite dev server started on ${readyUrl}`);
-      return;
-    }
-    logger?.warn("Vite process started, but the final local URL could not be confirmed yet");
-  }
   async function start() {
     logger?.info("Starting unified dev server...");
     config = await loadConfig({ cwd, configFile: configPath });
@@ -2131,7 +1987,7 @@ function createDevServer(options) {
         logger?.info("");
       }
     }
-    const browserBinding = config.bindings?.browser?.binding;
+    const browserBinding = getSingleBrowserBindingName(config.bindings?.browser);
     if (browserBinding) {
       logger?.info(`Starting Browser Rendering shim (binding: ${browserBinding})...`);
       browserShim = createBrowserShim({
@@ -2145,7 +2001,7 @@ function createDevServer(options) {
     const doPattern = config.files?.durableObjects;
     let doResult = null;
     if (typeof doPattern === "string" && doPattern) {
-      const outDir = resolve(cwd, ".devflare/do-bundles");
+      const outDir = resolve3(cwd, ".devflare/do-bundles");
       doBundler = createDOBundler({
         cwd,
         pattern: doPattern,
@@ -2164,14 +2020,20 @@ function createDevServer(options) {
     }
     currentDoResult = doResult;
     await startMiniflare(doResult);
-    await startWorkerSourceWatcher();
+    await startWorkerSourceWatcher2();
     if (enableVite) {
-      await startVite();
+      viteProcess = await startViteProcess({
+        cwd,
+        vitePort,
+        miniflarePort,
+        generatedViteConfigPath,
+        logger
+      });
     } else {
       logger?.info("Vite startup skipped (no effective Vite config found for this package)");
     }
     await new Promise((r) => setTimeout(r, 1000));
-    await runD1Migrations();
+    await runD1Migrations({ cwd, config, miniflarePort, logger });
   }
   async function stop() {
     if (doBundler) {
@@ -2213,11 +2075,11 @@ async function createLogWriter(cwd, options) {
   const fs = await import("node:fs");
   let logPath;
   if (options.logTemp) {
-    logPath = resolve2(cwd, ".log");
+    logPath = resolve4(cwd, ".log");
   } else {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve2(cwd, `.log-${timestamp}`);
+    logPath = resolve4(cwd, `.log-${timestamp}`);
   }
   const fileStream = fs.createWriteStream(logPath, { flags: "w" });
   const ansiRegex = /\x1b\[[0-9;]*m/g;
@@ -2248,6 +2110,7 @@ async function runDevCommand(parsed, logger, options) {
   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 });
   const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd), config);
   const logWriter = await createLogWriter(cwd, {
@@ -2256,7 +2119,7 @@ async function runDevCommand(parsed, logger, options) {
   });
   if (logWriter) {
     const logFile = relative(cwd, logWriter.path) || ".log";
-    logger.info(`\uD83D\uDCDD Logging enabled → ${logFile}`);
+    logLine(logger, `${dim("logging", theme)} ${logFile}`);
   }
   const devLogger = createConsola({
     level: verbose ? 4 : 3
@@ -2277,24 +2140,24 @@ async function runDevCommand(parsed, logger, options) {
     Object.assign(devLogger.debug, wrapLog(devLogger.debug.bind(devLogger), "[DEBUG]"));
   }
   try {
-    logger.info("");
+    logLine(logger);
     if (viteProject.shouldStartVite) {
-      logger.info("\uD83D\uDE80 Devflare Unified Dev Server");
-      logger.info("   ├─ Vite: Full HMR for frontend");
-      logger.info("   ├─ Miniflare: All Cloudflare bindings");
-      logger.info("   ├─ Rolldown: Worker + DO bundling with watch");
-      logger.info("   └─ Bridge: WebSocket RPC connection");
+      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 {
-      logger.info("\uD83D\uDE80 Devflare Worker Dev Server");
-      logger.info("   ├─ Miniflare: All Cloudflare bindings");
-      logger.info("   ├─ Rolldown: Worker + DO bundling with watch");
-      logger.info("   └─ Vite: Disabled (no effective Vite config found)");
+      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");
       }
     }
-    logger.info("");
+    logLine(logger);
     const devServer = createDevServer({
       cwd,
       configPath,
@@ -2324,8 +2187,8 @@ async function runDevCommand(parsed, logger, options) {
         const message = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
         logger.error(message);
       }
-      logger.info("");
-      logger.info("Shutting down...");
+      logLine(logger);
+      logLine(logger, `${yellow("dev", theme)} ${dim("Shutting down…", theme)}`);
       try {
         await devServer.stop();
       } finally {