devflare 1.0.0-next.2 → 1.0.0-next.21

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

@@ -1,321 +1,67 @@
 import {
-  findFiles
-} from "./index-rbht7m9r.js";
+  bundleWorkerEntry,
+  createDOBundler
+} from "./index-9fbtk7gv.js";
 import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
+  detectViteProject,
+  stopSpawnedProcessTree,
+  waitForViteReady
+} from "./index-y1d8za14.js";
 import {
-  loadConfig
-} from "./index-hcex3rgh.js";
+  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-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-124e9t4t.js";
+import"./index-n8k8chde.js";
+import {
+  getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
+  getSingleBrowserBindingName,
+  loadConfig,
+  resolveConfigPath
+} 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 { resolve as resolve3 } from "pathe";
+import { relative, resolve as resolve4 } from "pathe";
 
 // src/dev-server/server.ts
-import { resolve as resolve2 } from "pathe";
+import { resolve as resolve3 } from "pathe";
 
-// src/bundler/do-bundler.ts
-import { resolve, dirname, relative } from "pathe";
-import picomatch from "picomatch";
-function classToBindingName(className) {
-  return className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
-}
-async function discoverDOs(cwd, pattern) {
-  const fs = await import("node:fs/promises");
-  const discovered = [];
-  const files = await findFiles(pattern, { cwd });
-  for (const filePath of files) {
-    try {
-      const code = await fs.readFile(filePath, "utf-8");
-      const classNames = findDurableObjectClasses(code);
-      for (const className of classNames) {
-        discovered.push({
-          filePath,
-          className,
-          bindingName: classToBindingName(className)
-        });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-function stripDecoratorSyntax(code) {
-  let result = code;
-  result = result.replace(/@durableObject\s*\([^)]*\)\s*\n?\s*(?=export\s+class)/g, "");
-  result = result.replace(/import\s*\{([^}]*)\bdurableObject\b[^}]*\}\s*from\s*['"]devflare\/runtime['"]\s*;?/g, (match, imports) => {
-    const cleanedImports = imports.split(",").map((s) => s.trim()).filter((s) => !s.startsWith("durableObject")).join(", ");
-    if (cleanedImports.trim() === "") {
-      return "";
-    }
-    return `import { ${cleanedImports} } from 'devflare/runtime'`;
-  });
-  return result;
-}
-async function bundleDOFile(sourcePath, className, outDir, cwd) {
-  const { rolldown } = await import("rolldown");
-  const fs = await import("node:fs/promises");
-  await fs.mkdir(outDir, { recursive: true });
-  const sourceCode = await fs.readFile(sourcePath, "utf-8");
-  const cleanedCode = stripDecoratorSyntax(sourceCode);
-  const entryCode = `${cleanedCode}
-
-// Default export for worker (required by Miniflare)
-export default {
-	async fetch(request) {
-		return new Response('DO Worker for ${className}', { status: 200 });
-	}
-};
-`;
-  const tempFilePath = resolve(outDir, `_temp_${className}.ts`);
-  await fs.writeFile(tempFilePath, entryCode, "utf-8");
-  const classOutDir = resolve(outDir, className);
-  try {
-    await fs.rm(classOutDir, { recursive: true, force: true });
-  } catch {}
-  await fs.mkdir(classOutDir, { recursive: true });
-  const debugShimCode = `
-// Debug module shim for local development
-const createDebug = (namespace) => {
-	const logger = (...args) => {
-		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
-	}
-	logger.enabled = false
-	logger.namespace = namespace
-	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
-	return logger
-}
-createDebug.enabled = false
-createDebug.formatters = {}
-export default createDebug
-`;
-  const debugShimPath = resolve(outDir, "_debug_shim.js");
-  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
-  const bundle = await rolldown({
-    input: tempFilePath,
-    platform: "neutral",
-    tsconfig: resolve(cwd, "tsconfig.json"),
-    external: [
-      /^cloudflare:/,
-      /^node:/,
-      "buffer",
-      "crypto",
-      "events",
-      "http",
-      "https",
-      "net",
-      "os",
-      "path",
-      "stream",
-      "tls",
-      "url",
-      "util",
-      "zlib",
-      "fs",
-      "child_process",
-      "async_hooks",
-      "querystring",
-      "string_decoder",
-      "assert",
-      "dns"
-    ],
-    resolve: {
-      alias: {
-        debug: debugShimPath
-      }
-    }
-  });
-  const outFile = resolve(classOutDir, "index.js");
-  await bundle.write({
-    file: outFile,
-    format: "esm",
-    sourcemap: false,
-    inlineDynamicImports: true
-  });
-  await bundle.close();
-  try {
-    await fs.unlink(tempFilePath);
-  } catch {}
-  return resolve(classOutDir, "index.js");
-}
-async function bundleAllDOs(discovered, outDir, cwd, logger) {
-  const fs = await import("node:fs/promises");
-  const bundles = new Map;
-  const classes = new Map;
-  const sourceFiles = new Map;
-  const errors = [];
-  for (const do_ of discovered) {
-    const existing = sourceFiles.get(do_.filePath) || [];
-    existing.push(do_.className);
-    sourceFiles.set(do_.filePath, existing);
-  }
-  for (const do_ of discovered) {
-    try {
-      logger?.debug(`Bundling ${do_.className} from ${do_.filePath}`);
-      const outFile = await bundleDOFile(do_.filePath, do_.className, outDir, cwd);
-      bundles.set(do_.bindingName, outFile);
-      classes.set(do_.bindingName, do_.className);
-      logger?.debug(`  → ${outFile}`);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      errors.push(err);
-      logger?.error(`Failed to bundle ${do_.className}:`, err.message);
-    }
-  }
-  return { bundles, classes, sourceFiles, errors };
-}
-function createDOBundler(options) {
-  const { cwd, pattern, outDir, logger, onRebuild } = options;
-  let result = {
-    bundles: new Map,
-    classes: new Map,
-    sourceFiles: new Map,
-    errors: []
-  };
-  let watcher = null;
-  let chokidarWatcher = null;
-  async function build() {
-    const discovered = await discoverDOs(cwd, pattern);
-    if (discovered.length === 0) {
-      logger?.debug("No DOs found matching pattern:", pattern);
-      return result;
-    }
-    logger?.info(`Found ${discovered.length} Durable Object(s)`);
-    for (const do_ of discovered) {
-      logger?.info(`  • ${do_.className} → ${do_.bindingName}`);
-    }
-    result = await bundleAllDOs(discovered, outDir, cwd, logger);
-    if (result.errors.length === 0) {
-      logger?.success(`Bundled ${result.bundles.size} DO(s) to ${outDir}`);
-    }
-    return result;
-  }
-  async function watch() {
-    const chokidar = await import("chokidar");
-    const files = await findFiles(pattern, { cwd });
-    let dirsToWatch;
-    if (files.length > 0) {
-      dirsToWatch = [...new Set(files.map((f) => dirname(f)))];
-    } else {
-      const patternDir = dirname(pattern);
-      const absolutePatternDir = resolve(cwd, patternDir === "." ? "" : patternDir) || cwd;
-      dirsToWatch = [absolutePatternDir];
-      logger?.debug(`No DO files yet, watching pattern directory: ${absolutePatternDir}`);
-    }
-    logger?.info(`Watching ${files.length} DO file(s) in ${dirsToWatch.length} director(ies)...`);
-    const isWindows = process.platform === "win32";
-    chokidarWatcher = chokidar.watch(dirsToWatch, {
-      ignoreInitial: true,
-      usePolling: isWindows,
-      interval: isWindows ? 300 : undefined,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      },
-      depth: 0
-    });
-    const normalizePath = (p) => {
-      let normalized = p.replace(/\\/g, "/");
-      if (isWindows && /^[a-zA-Z]:/.test(normalized)) {
-        normalized = normalized[0].toLowerCase() + normalized.slice(1);
-      }
-      return normalized;
-    };
-    const isMatch = picomatch(pattern, {
-      cwd,
-      dot: true,
-      matchBase: false
-    });
-    const matchesPattern = (filePath) => {
-      const normalizedPath = normalizePath(filePath);
-      const relativePath = relative(normalizePath(cwd), normalizedPath);
-      return isMatch(relativePath);
-    };
-    let isRebuilding = false;
-    let pendingRebuild = null;
-    let rebuildTimeout = null;
-    const scheduleRebuild = (changedPath) => {
-      if (rebuildTimeout) {
-        clearTimeout(rebuildTimeout);
-      }
-      rebuildTimeout = setTimeout(() => {
-        triggerRebuild(changedPath);
-      }, 150);
-    };
-    const triggerRebuild = async (changedPath) => {
-      if (isRebuilding) {
-        pendingRebuild = changedPath;
-        logger?.debug(`Rebuild already in progress, queuing: ${changedPath}`);
-        return;
-      }
-      isRebuilding = true;
-      try {
-        logger?.info(`DO file changed: ${changedPath}`);
-        logger?.info("Rebuilding DOs...");
-        const startTime = Date.now();
-        result = await build();
-        const elapsed = Date.now() - startTime;
-        logger?.success(`DO rebuild complete (${elapsed}ms)`);
-        await onRebuild?.(result);
-      } catch (error) {
-        logger?.error("DO rebuild failed:", error);
-      } finally {
-        isRebuilding = false;
-        if (pendingRebuild) {
-          const nextPath = pendingRebuild;
-          pendingRebuild = null;
-          triggerRebuild(nextPath);
-        }
-      }
-    };
-    chokidarWatcher.on("change", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File changed: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("add", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File added: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("unlink", (filePath) => {
-      if (matchesPattern(filePath)) {
-        logger?.debug(`File removed: ${filePath}`);
-        scheduleRebuild(filePath);
-      }
-    });
-    chokidarWatcher.on("ready", () => {
-      logger?.info("DO file watcher ready");
-    });
-    chokidarWatcher.on("error", (error) => {
-      logger?.error("DO file watcher error:", error);
-    });
-  }
-  async function close() {
-    if (watcher) {
-      await watcher.close();
-      watcher = null;
-    }
-    if (chokidarWatcher) {
-      await chokidarWatcher.close();
-      chokidarWatcher = null;
-    }
-  }
-  function getResult() {
-    return result;
-  }
-  return {
-    build,
-    watch,
-    close,
-    getResult
-  };
-}
 // src/browser-shim/server.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -328,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)) {
@@ -369,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");
@@ -449,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();
@@ -537,10 +318,19 @@ function createBrowserShim(options = {}) {
     res.end("Not found");
   }
   function readBody(req) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const chunks = [];
-      req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
+      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);
     });
   }
@@ -573,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();
@@ -681,21 +479,21 @@ function createBrowserShim(options = {}) {
         });
       });
     }
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve, reject) => {
       server.on("error", reject);
       server.listen(port, host, () => {
-        resolve2();
+        resolve();
       });
     });
     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) {
-      await new Promise((resolve2) => {
-        server.close(() => resolve2());
+      await new Promise((resolve) => {
+        server.close(() => resolve());
       });
       server = null;
     }
@@ -1087,55 +885,157 @@ async function checkRemoteBindingRequirements(config) {
   };
 }
 
-// src/dev-server/server.ts
-function getGatewayScript(wsRoutes = [], debug = false) {
+// 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);
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+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 {
+      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;
+    }
+  }
+  logger?.warn(`Failed to apply migrations to ${bindingName}: ${getErrorMessage(lastError)}`);
+}
+async function runD1Migrations(options) {
+  const { cwd, config, miniflarePort, logger } = options;
+  if (!config?.bindings?.d1) {
+    return;
+  }
+  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;
+  }
+  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)`);
+    }
+  }
+  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
+    });
+  }
+}
+
+// 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}
 
 export default {
 	async fetch(request, env, ctx) {
 		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,
@@ -1144,11 +1044,17 @@ export default {
 			}), { headers: { 'Content-Type': 'application/json' } })
 		}
 
+		if (APP_SERVICE_BINDING) {
+			const appWorker = env[APP_SERVICE_BINDING]
+			if (appWorker && typeof appWorker.fetch === 'function') {
+				return appWorker.fetch(request)
+			}
+		}
+
 		return new Response('Devflare Bridge Gateway', { status: 200 })
 	}
 }
 
-// Handle D1 migrations
 async function handleMigration(request, env) {
 	try {
 		const { bindingName, statements } = await request.json()
@@ -1175,92 +1081,48 @@ 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 })
-		
-		// Parse headers from raw email for the Headers object
-		const headerLines = []
-		const lines = rawBody.split(/\\r?\\n/)
-		let bodyStart = 0
-		for (let i = 0; i < lines.length; i++) {
-			if (lines[i].trim() === '') {
-				bodyStart = i + 1
-				break
-			}
-			headerLines.push(lines[i])
-		}
-		
-		const headers = new Headers()
-		for (const line of headerLines) {
-			const colonIdx = line.indexOf(':')
-			if (colonIdx > 0) {
-				const key = line.slice(0, colonIdx).trim()
-				const value = line.slice(colonIdx + 1).trim()
-				headers.append(key, value)
-			}
-		}
-		
-		// Create ReadableStream from raw email
-		const rawStream = new ReadableStream({
-			start(controller) {
-				controller.enqueue(new TextEncoder().encode(rawBody))
-				controller.close()
-			}
-		})
-		
-		// Create ForwardableEmailMessage-like object
-		const emailMessage = {
-			from,
-			to,
-			headers,
-			raw: rawStream,
-			rawSize: rawBody.length,
-			
-			setReject(reason) {
-				log('Email rejected:', reason)
-			},
-			
-			async forward(rcptTo, extraHeaders) {
-				log('Email forwarded to:', rcptTo)
-				return Promise.resolve()
-			},
-			
-			async reply(message) {
-				log('Email reply sent to:', message.from)
-				return Promise.resolve()
+
+		if (APP_SERVICE_BINDING) {
+			const appWorker = env[APP_SERVICE_BINDING]
+			if (appWorker && typeof appWorker.fetch === 'function') {
+				const response = await appWorker.fetch(new Request('http://devflare.internal/_devflare/internal/email', {
+					method: 'POST',
+					headers: {
+						'x-devflare-event': 'email',
+						'x-devflare-email-from': from,
+						'x-devflare-email-to': to,
+						'content-type': request.headers.get('content-type') || 'text/plain'
+					},
+					body: rawBody
+				}))
+
+				if (!response.ok) {
+					return response
+				}
 			}
 		}
-		
-		// Look for email handler in the worker module
-		// For now, we call via a special RPC method that DO workers can implement
-		// The email binding should be configured in the worker
-		
-		// Check if there's an EMAIL_HANDLER binding (special DO for email handling)
-		if (env.__emailHandler && typeof env.__emailHandler.email === 'function') {
-			await env.__emailHandler.email(emailMessage, env, ctx)
-		}
-		
+
 		return new Response(JSON.stringify({ ok: true, from, to }), {
 			headers: { 'Content-Type': 'application/json' }
 		})
@@ -1270,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
 		}
@@ -1281,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
@@ -1316,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()
@@ -1332,7 +1183,6 @@ function handleBridgeWebSocket(request, env, ctx) {
 	})
 
 	server.addEventListener('close', () => {
-		activeStreams.clear()
 		wsProxies.clear()
 	})
 
@@ -1363,160 +1213,9 @@ 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 }
-		}))
-	}
-}
-
-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]
-
-	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 })
+			error: { code: error?.code || 'INTERNAL_ERROR', message: error?.message || String(error) }
 		}))
-		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') {
-		log('Email send:', { from: params[0]?.from, to: params[0]?.to })
-		// In local dev, we just log the email - Miniflare handles writing to file
-		if (binding && typeof binding.send === 'function') {
-			return binding.send(params[0])
-		}
-		// Return success even if no real binding (simulated)
-		return { ok: true, simulated: true }
 	}
-
-	throw new Error('Unknown operation: ' + method)
 }
 
 async function handleWsOpen(msg, ws, env) {
@@ -1575,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') {
@@ -1591,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 {
@@ -1663,6 +1544,7 @@ function createDevServer(options) {
     configPath,
     vitePort = 5173,
     miniflarePort = 8787,
+    enableVite = true,
     persist = true,
     logger,
     verbose = false,
@@ -1670,15 +1552,76 @@ function createDevServer(options) {
   } = options;
   let miniflare = null;
   let doBundler = null;
+  let workerSourceWatcher = null;
+  let workerWatchTargets = [];
   let viteProcess = null;
   let config = null;
   let browserShim = null;
   let browserShimPort = 8788;
+  let mainWorkerSurfacePaths = {
+    fetch: null,
+    queue: null,
+    scheduled: null,
+    email: null
+  };
+  let resolvedWorkerConfigPath = null;
+  let mainWorkerScriptPath = null;
+  let bundledMainWorkerScriptPath = null;
+  let currentDoResult = null;
+  let mainWorkerRoutes = null;
+  let generatedViteConfigPath = null;
+  let reloadChain = Promise.resolve();
+  async function bundleMainWorker() {
+    if (!mainWorkerScriptPath || !config) {
+      bundledMainWorkerScriptPath = null;
+      return;
+    }
+    bundledMainWorkerScriptPath = await bundleWorkerEntry({
+      cwd,
+      inputFile: mainWorkerScriptPath,
+      outFile: resolve3(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      rolldownOptions: config.rolldown?.options,
+      sourcemap: config.rolldown?.sourcemap,
+      minify: config.rolldown?.minify,
+      logger
+    });
+    logger?.debug(`Bundled main worker → ${bundledMainWorkerScriptPath}`);
+  }
   function buildMiniflareConfig(doResult) {
     if (!config)
       throw new Error("Config not loaded");
-    const bindings = config.bindings ?? {};
-    const persistPath = resolve2(cwd, ".devflare/data");
+    const loadedConfig = config;
+    const bindings = loadedConfig.bindings ?? {};
+    const persistPath = resolve3(cwd, ".devflare/data");
+    const appWorkerName = loadedConfig.name;
+    const shouldRunMainWorker = !enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length));
+    const queueProducers = (() => {
+      if (!bindings.queues?.producers) {
+        return;
+      }
+      const producers = {};
+      for (const [bindingName, queueName] of Object.entries(bindings.queues.producers)) {
+        producers[bindingName] = { queueName };
+      }
+      return producers;
+    })();
+    const queueConsumers = (() => {
+      if (!bindings.queues?.consumers || bindings.queues.consumers.length === 0) {
+        return;
+      }
+      const consumers = {};
+      for (const consumer of bindings.queues.consumers) {
+        consumers[consumer.queue] = {
+          ...consumer.maxBatchSize !== undefined && { maxBatchSize: consumer.maxBatchSize },
+          ...consumer.maxBatchTimeout !== undefined && { maxBatchTimeout: consumer.maxBatchTimeout },
+          ...consumer.maxRetries !== undefined && { maxRetries: consumer.maxRetries },
+          ...consumer.deadLetterQueue && { deadLetterQueue: consumer.deadLetterQueue },
+          ...consumer.maxConcurrency !== undefined && { maxConcurrency: consumer.maxConcurrency },
+          ...consumer.retryDelay !== undefined && { retryDelay: consumer.retryDelay }
+        };
+      }
+      return consumers;
+    })();
     const sharedOptions = {
       port: miniflarePort,
       host: "127.0.0.1",
@@ -1687,19 +1630,93 @@ function createDevServer(options) {
       d1Persist: persist ? `${persistPath}/d1` : undefined,
       durableObjectsPersist: persist ? `${persistPath}/do` : undefined
     };
-    const gatewayWorker = {
-      name: "gateway",
-      modules: true,
-      script: getGatewayScript(config.wsRoutes, debug),
-      compatibilityDate: config.compatibilityDate,
-      compatibilityFlags: config.compatibilityFlags ?? [],
-      routes: ["*"],
-      kvNamespaces: bindings.kv ? bindings.kv : undefined,
-      r2Buckets: bindings.r2 ? bindings.r2 : undefined,
-      d1Databases: bindings.d1 ? bindings.d1 : undefined,
-      bindings: config.vars
+    const createServiceBindings = (extraBindings = {}) => {
+      const serviceBindings = {};
+      if (bindings.services) {
+        for (const [bindingName, serviceConfig] of Object.entries(bindings.services)) {
+          serviceBindings[bindingName] = {
+            name: serviceConfig.service,
+            ...serviceConfig.entrypoint && { entrypoint: serviceConfig.entrypoint }
+          };
+        }
+      }
+      for (const [bindingName, target] of Object.entries(extraBindings)) {
+        serviceBindings[bindingName] = target;
+      }
+      return Object.keys(serviceBindings).length > 0 ? serviceBindings : undefined;
     };
-    if (!doResult || doResult.bundles.size === 0) {
+    const sendEmailConfig = bindings.sendEmail ? {
+      send_email: Object.entries(bindings.sendEmail).map(([name, binding]) => ({
+        name,
+        ...binding.destinationAddress && {
+          destination_address: binding.destinationAddress
+        },
+        ...binding.allowedDestinationAddresses && {
+          allowed_destination_addresses: binding.allowedDestinationAddresses
+        },
+        ...binding.allowedSenderAddresses && {
+          allowed_sender_addresses: binding.allowedSenderAddresses
+        }
+      }))
+    } : undefined;
+    const createWorkerConfig = (options2) => {
+      const baseFlags = loadedConfig.compatibilityFlags ?? [];
+      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
+      const workerBindings = loadedConfig.vars ?? {};
+      const workerConfig = {
+        name: options2.name,
+        modules: true,
+        compatibilityDate: loadedConfig.compatibilityDate,
+        compatibilityFlags: compatFlags,
+        ...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]) => {
+            return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
+          }))
+        },
+        ...Object.keys(workerBindings).length > 0 && { bindings: workerBindings },
+        ...sendEmailConfig && { email: sendEmailConfig },
+        ...queueProducers && { queueProducers },
+        ...options2.queueConsumers && { queueConsumers: options2.queueConsumers },
+        ...options2.triggers && { triggers: options2.triggers }
+      };
+      if (options2.scriptPath) {
+        workerConfig.scriptPath = options2.scriptPath;
+        workerConfig.modulesRoot = cwd;
+        workerConfig.modulesRules = [
+          { type: "ESModule", include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.mjs"] },
+          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
+          { type: "ESModule", include: ["**/*.jsx"] }
+        ];
+      }
+      if (options2.script) {
+        workerConfig.script = options2.script;
+      }
+      if (options2.durableObjects && Object.keys(options2.durableObjects).length > 0) {
+        workerConfig.durableObjects = options2.durableObjects;
+      }
+      if (options2.serviceBindings && Object.keys(options2.serviceBindings).length > 0) {
+        workerConfig.serviceBindings = options2.serviceBindings;
+      }
+      return workerConfig;
+    };
+    const gatewayWorker = createWorkerConfig({
+      name: "gateway",
+      script: getGatewayScript(loadedConfig.wsRoutes, debug, shouldRunMainWorker ? INTERNAL_APP_SERVICE_BINDING : null),
+      serviceBindings: shouldRunMainWorker ? createServiceBindings({
+        [INTERNAL_APP_SERVICE_BINDING]: { name: appWorkerName }
+      }) : createServiceBindings()
+    });
+    gatewayWorker.routes = ["*"];
+    const hasDurableObjectBundles = !!doResult && doResult.bundles.size > 0;
+    const browserBindingName = getSingleBrowserBindingName(bindings.browser);
+    const needsBrowserWorker = Boolean(browserBindingName && (hasDurableObjectBundles || shouldRunMainWorker));
+    if (!shouldRunMainWorker && !hasDurableObjectBundles && !needsBrowserWorker) {
       return {
         ...sharedOptions,
         ...gatewayWorker
@@ -1708,56 +1725,64 @@ function createDevServer(options) {
     const workers = [];
     const durableObjects = {};
     const browserShimUrl = `http://127.0.0.1:${browserShimPort}`;
-    const browserBindingName = bindings.browser?.binding;
     const browserWorkerName = "browser-binding";
-    for (const [bindingName, bundlePath] of doResult.bundles) {
-      const className = doResult.classes.get(bindingName);
-      if (!className)
-        continue;
-      const workerName = `do-${bindingName.toLowerCase()}`;
-      const baseFlags = config.compatibilityFlags ?? [];
-      const compatFlags = baseFlags.includes("nodejs_compat") ? baseFlags : [...baseFlags, "nodejs_compat"];
-      const workerConfig = {
-        name: workerName,
-        modules: true,
-        modulesRoot: cwd,
-        modulesRules: [
-          { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
-          { type: "ESModule", include: ["**/*.mjs"] }
-        ],
-        scriptPath: bundlePath,
-        compatibilityDate: config.compatibilityDate,
-        compatibilityFlags: compatFlags,
-        durableObjects: {
-          [bindingName]: className
+    if (shouldRunMainWorker && mainWorkerScriptPath) {
+      const mainWorkerServiceBindings = createServiceBindings(browserBindingName ? {
+        [browserBindingName]: { name: browserWorkerName }
+      } : {});
+      const mainWorkerConfig = createWorkerConfig({
+        name: appWorkerName,
+        scriptPath: bundledMainWorkerScriptPath ?? mainWorkerScriptPath,
+        serviceBindings: mainWorkerServiceBindings,
+        queueConsumers,
+        triggers: loadedConfig.triggers?.crons?.length ? { crons: loadedConfig.triggers.crons } : undefined
+      });
+      workers.push(mainWorkerConfig);
+    }
+    if (doResult) {
+      for (const [bindingName, bundlePath] of doResult.bundles) {
+        const className = doResult.classes.get(bindingName);
+        if (!className)
+          continue;
+        const workerName = `do-${bindingName.toLowerCase()}`;
+        const workerConfig = createWorkerConfig({
+          name: workerName,
+          scriptPath: bundlePath,
+          durableObjects: {
+            [bindingName]: className
+          },
+          serviceBindings: createServiceBindings(browserBindingName ? {
+            [browserBindingName]: { name: browserWorkerName }
+          } : {})
+        });
+        if (browserBindingName) {
+          logger?.debug(`DO ${workerName} has browser service binding: ${browserBindingName} → ${browserWorkerName}`);
         }
-      };
-      if (browserBindingName) {
-        workerConfig.serviceBindings = {
-          ...workerConfig.serviceBindings,
-          [browserBindingName]: browserWorkerName
+        logger?.debug(`DO ${workerName} config:`, JSON.stringify(workerConfig, null, 2));
+        workers.push(workerConfig);
+        durableObjects[bindingName] = {
+          className,
+          scriptName: workerName
         };
-        logger?.debug(`DO ${workerName} has browser service binding: ${browserBindingName} → ${browserWorkerName}`);
       }
-      logger?.debug(`DO ${workerName} config:`, JSON.stringify(workerConfig, null, 2));
-      workers.push(workerConfig);
-      durableObjects[bindingName] = {
-        className,
-        scriptName: workerName
-      };
     }
-    if (browserBindingName) {
-      const browserWorker = {
+    if (needsBrowserWorker) {
+      const browserWorker = createWorkerConfig({
         name: browserWorkerName,
-        modules: true,
-        script: getBrowserBindingScript(browserShimUrl, debug),
-        compatibilityDate: config.compatibilityDate,
-        compatibilityFlags: config.compatibilityFlags ?? []
-      };
+        script: getBrowserBindingScript(browserShimUrl, debug)
+      });
       workers.push(browserWorker);
       logger?.info(`Browser binding worker configured: ${browserBindingName} → ${browserShimUrl}`);
     }
-    gatewayWorker.durableObjects = durableObjects;
+    if (Object.keys(durableObjects).length > 0) {
+      gatewayWorker.durableObjects = durableObjects;
+      if (shouldRunMainWorker) {
+        const mainWorker = workers.find((worker) => worker.name === appWorkerName);
+        if (mainWorker) {
+          mainWorker.durableObjects = durableObjects;
+        }
+      }
+    }
     return {
       ...sharedOptions,
       workers: [gatewayWorker, ...workers]
@@ -1766,132 +1791,177 @@ function createDevServer(options) {
   async function startMiniflare(doResult) {
     const { Miniflare, Log, LogLevel } = await import("miniflare");
     const mfConfig = buildMiniflareConfig(doResult);
-    mfConfig.log = new Log(LogLevel.DEBUG);
-    logger?.info("=== MINIFLARE CONFIG DEBUG ===");
-    logger?.info("Full config:", JSON.stringify(mfConfig, (key, value) => {
-      if (key === "script" && typeof value === "string" && value.length > 200) {
-        return value.substring(0, 200) + "...[truncated]";
-      }
-      return value;
-    }, 2));
-    if (mfConfig.workers) {
-      logger?.info("Workers order:");
-      for (const w of mfConfig.workers) {
-        logger?.info(`  → ${w.name}:`);
-        logger?.info(`      script: ${w.script ? "inline" : w.scriptPath}`);
-        logger?.info(`      browserRendering: ${JSON.stringify(w.browserRendering)}`);
-        logger?.info(`      durableObjects: ${JSON.stringify(w.durableObjects)}`);
+    mfConfig.log = createCompatibilityAwareMiniflareLog(Log, LogLevel.DEBUG, logger);
+    mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
+    const shouldLogMiniflareDiagnostics = verbose || debug;
+    if (shouldLogMiniflareDiagnostics) {
+      logger?.info("=== MINIFLARE CONFIG DEBUG ===");
+      logger?.info("Full config:", JSON.stringify(mfConfig, (key, value) => {
+        if (key === "script" && typeof value === "string" && value.length > 200) {
+          return value.substring(0, 200) + "...[truncated]";
+        }
+        return value;
+      }, 2));
+      if (mfConfig.workers) {
+        logger?.info("Workers order:");
+        for (const w of mfConfig.workers) {
+          logger?.info(`  → ${w.name}:`);
+          logger?.info(`      script: ${w.script ? "inline" : w.scriptPath}`);
+          logger?.info(`      browserRendering: ${JSON.stringify(w.browserRendering)}`);
+          logger?.info(`      durableObjects: ${JSON.stringify(w.durableObjects)}`);
+        }
       }
     }
     miniflare = new Miniflare(mfConfig);
     await miniflare.ready;
     logger?.success(`Miniflare ready on http://localhost:${miniflarePort}`);
-    try {
-      const gatewayBindings = await miniflare.getBindings("gateway");
-      logger?.info("Gateway worker bindings:", Object.keys(gatewayBindings));
-      if (mfConfig.workers) {
-        for (const w of mfConfig.workers) {
-          if (w.name !== "gateway") {
-            try {
-              const doBindings = await miniflare.getBindings(w.name);
-              logger?.info(`${w.name} worker bindings:`, Object.keys(doBindings));
-              if ("BROWSER" in doBindings) {
-                logger?.success(`${w.name} has BROWSER binding!`);
-              } else {
-                logger?.warn(`${w.name} is MISSING BROWSER binding`);
+    if (shouldLogMiniflareDiagnostics) {
+      try {
+        const gatewayBindings = await miniflare.getBindings("gateway");
+        logger?.info("Gateway worker bindings:", Object.keys(gatewayBindings));
+        if (mfConfig.workers) {
+          for (const w of mfConfig.workers) {
+            if (w.name !== "gateway") {
+              try {
+                const doBindings = await miniflare.getBindings(w.name);
+                logger?.info(`${w.name} worker bindings:`, Object.keys(doBindings));
+                if ("BROWSER" in doBindings) {
+                  logger?.success(`${w.name} has BROWSER binding!`);
+                } else {
+                  logger?.warn(`${w.name} is MISSING BROWSER binding`);
+                }
+              } catch (error) {
+                logger?.debug(`Skipping binding diagnostics for ${w.name}: ${formatErrorMessage(error)}`);
               }
-            } catch (e) {
-              logger?.warn(`Could not get bindings for ${w.name}:`, e);
             }
           }
         }
+      } catch (error) {
+        logger?.debug(`Skipping Miniflare binding diagnostics: ${formatErrorMessage(error)}`);
       }
-    } catch (e) {
-      logger?.warn("Error getting bindings:", e);
     }
   }
   async function reloadMiniflare(doResult) {
-    if (!miniflare)
-      return;
-    const { Log, LogLevel } = await import("miniflare");
-    const mfConfig = buildMiniflareConfig(doResult);
-    mfConfig.log = new Log(LogLevel.DEBUG);
-    logger?.info("Reloading Miniflare with updated DOs...");
-    await miniflare.setOptions(mfConfig);
-    logger?.success("Miniflare reloaded");
+    currentDoResult = doResult;
+    const queuedReload = reloadChain.then(async () => {
+      if (!miniflare)
+        return;
+      const { Log, LogLevel } = await import("miniflare");
+      const mfConfig = buildMiniflareConfig(currentDoResult);
+      mfConfig.log = createCompatibilityAwareMiniflareLog(Log, LogLevel.DEBUG, logger);
+      mfConfig.handleRuntimeStdio = createRuntimeStdioForwarder(logger);
+      logger?.info("Reloading Miniflare...");
+      await miniflare.setOptions(mfConfig);
+      logger?.success("Miniflare reloaded");
+    });
+    reloadChain = queuedReload.catch(() => {});
+    await queuedReload;
   }
-  async function runD1Migrations() {
-    if (!miniflare || !config?.bindings?.d1)
-      return;
-    const { existsSync: existsSync2, readdirSync, readFileSync } = await import("node:fs");
-    const migrationsDir = resolve2(cwd, "migrations");
-    if (!existsSync2(migrationsDir)) {
-      logger?.debug("No migrations/ directory found, skipping D1 migrations");
+  async function resolveWorkerConfigWatchPath() {
+    if (configPath) {
+      const explicitPath = resolve3(cwd, configPath);
+      const fs = await import("node:fs/promises");
+      try {
+        await fs.access(explicitPath);
+        return explicitPath;
+      } catch {}
+    }
+    return await resolveConfigPath(cwd) ?? null;
+  }
+  async function refreshWorkerOnlySurfaceState() {
+    if (!config) {
       return;
     }
-    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
-    if (files.length === 0) {
-      logger?.debug("No SQL migration files found");
+    mainWorkerSurfacePaths = await resolveMainWorkerSurfacePaths(cwd, config);
+    mainWorkerRoutes = await discoverRoutes(cwd, config);
+    const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, config, undefined, {
+      devInternalEmail: true
+    });
+    mainWorkerScriptPath = composedMainEntry ? resolve3(cwd, composedMainEntry) : null;
+    if (mainWorkerScriptPath) {
+      await bundleMainWorker();
+    } else {
+      bundledMainWorkerScriptPath = null;
+    }
+    await syncWorkerWatchTargets();
+  }
+  function getWorkerWatchTargets() {
+    if (enableVite || !config) {
+      return [];
+    }
+    const targets = collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths);
+    if (resolvedWorkerConfigPath) {
+      targets.push(resolvedWorkerConfigPath);
+    }
+    return [...new Set(targets)];
+  }
+  async function syncWorkerWatchTargets() {
+    if (!workerSourceWatcher) {
       return;
     }
-    logger?.info(`Running ${files.length} D1 migration(s)...`);
-    const allStatements = [];
-    for (const file of files) {
-      const sql = readFileSync(resolve2(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}`);
-          }
-        }
-      }
+    const nextWatchTargets = getWorkerWatchTargets();
+    const nextWatchTargetSet = new Set(nextWatchTargets);
+    const targetsToRemove = workerWatchTargets.filter((target) => !nextWatchTargetSet.has(target));
+    const targetsToAdd = nextWatchTargets.filter((target) => !workerWatchTargets.includes(target));
+    if (targetsToRemove.length > 0) {
+      await workerSourceWatcher.unwatch(targetsToRemove);
+    }
+    if (targetsToAdd.length > 0) {
+      workerSourceWatcher.add(targetsToAdd);
     }
+    workerWatchTargets = nextWatchTargets;
   }
-  async function startVite() {
-    const { spawn } = await import("node:child_process");
-    const args = ["vite", "dev", "--port", String(vitePort)];
-    viteProcess = spawn("bunx", args, {
-      cwd,
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        DEVFLARE_DEV: "true",
-        DEVFLARE_BRIDGE_PORT: String(miniflarePort),
-        FORCE_COLOR: "1"
+  async function reloadWorkerOnlyConfig() {
+    config = await loadConfig({ cwd, configFile: configPath });
+    setLocalSendEmailBindings(config.bindings?.sendEmail ?? {});
+    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
+    await refreshWorkerOnlySurfaceState();
+    await reloadMiniflare(currentDoResult);
+  }
+  async function startWorkerSourceWatcher2() {
+    if (enableVite || !config) {
+      return;
+    }
+    const watchTargets = getWorkerWatchTargets();
+    if (watchTargets.length === 0) {
+      return;
+    }
+    workerWatchTargets = watchTargets;
+    workerSourceWatcher = await startWorkerSourceWatcher({
+      watchTargets,
+      resolvedWorkerConfigPath,
+      logger,
+      onConfigChange: reloadWorkerOnlyConfig,
+      onWorkerChange: async () => {
+        await refreshWorkerOnlySurfaceState();
+        await reloadMiniflare(currentDoResult);
       }
     });
-    logger?.success(`Vite dev server started on http://localhost:${vitePort}`);
   }
   async function start() {
     logger?.info("Starting unified dev server...");
     config = await loadConfig({ cwd, configFile: configPath });
+    setLocalSendEmailBindings(config.bindings?.sendEmail ?? {});
+    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
     logger?.debug("Loaded config:", config.name);
+    if (enableVite) {
+      const viteProject = await detectViteProject(cwd);
+      generatedViteConfigPath = await writeGeneratedViteConfig({
+        cwd,
+        configPath,
+        localConfigPath: viteProject.viteConfigPath,
+        bridgePort: miniflarePort
+      });
+      logger?.debug(`Generated Vite config → ${generatedViteConfigPath}`);
+    }
+    await refreshWorkerOnlySurfaceState();
+    if (!enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length))) {
+      const detectedWorkerHandlers = Object.entries(mainWorkerSurfacePaths).filter(([, surfacePath]) => !!surfacePath).map(([surfaceName, surfacePath]) => `${surfaceName}=${surfacePath}`);
+      const detectedRouteHandlers = mainWorkerRoutes?.routes.map((route) => `route=${route.filePath}`) ?? [];
+      logger?.info(`Worker handlers detected: ${[...detectedWorkerHandlers, ...detectedRouteHandlers].join(", ")}`);
+    } else if (!enableVite) {
+      logger?.warn("No local worker handler entry was found for worker-only mode");
+    }
     const remoteCheck = await checkRemoteBindingRequirements(config);
     if (remoteCheck.hasRemoteBindings) {
       logger?.info("");
@@ -1917,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({
@@ -1931,48 +2001,62 @@ function createDevServer(options) {
     const doPattern = config.files?.durableObjects;
     let doResult = null;
     if (typeof doPattern === "string" && doPattern) {
-      const outDir = resolve2(cwd, ".devflare/do-bundles");
+      const outDir = resolve3(cwd, ".devflare/do-bundles");
       doBundler = createDOBundler({
         cwd,
         pattern: doPattern,
         outDir,
+        rolldownOptions: config.rolldown?.options,
+        sourcemap: config.rolldown?.sourcemap,
+        minify: config.rolldown?.minify,
         logger,
         onRebuild: async (result) => {
           await reloadMiniflare(result);
         }
       });
       doResult = await doBundler.build();
+      currentDoResult = doResult;
       await doBundler.watch();
     }
+    currentDoResult = doResult;
     await startMiniflare(doResult);
-    await startVite();
+    await startWorkerSourceWatcher2();
+    if (enableVite) {
+      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();
-    const cleanup = async () => {
-      logger?.info("Shutting down...");
-      await stop();
-      process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
+    await runD1Migrations({ cwd, config, miniflarePort, logger });
   }
   async function stop() {
     if (doBundler) {
       await doBundler.close();
       doBundler = null;
     }
+    if (workerSourceWatcher) {
+      await workerSourceWatcher.close();
+      workerSourceWatcher = null;
+    }
     if (miniflare) {
       await miniflare.dispose();
       miniflare = null;
     }
     if (viteProcess) {
-      viteProcess.kill("SIGTERM");
+      await stopSpawnedProcessTree(viteProcess);
       viteProcess = null;
     }
     if (browserShim) {
       await browserShim.stop();
       browserShim = null;
     }
+    clearLocalSendEmailBindings();
   }
   function getMiniflare() {
     return miniflare;
@@ -1991,15 +2075,16 @@ async function createLogWriter(cwd, options) {
   const fs = await import("node:fs");
   let logPath;
   if (options.logTemp) {
-    logPath = resolve3(cwd, ".log");
+    logPath = resolve4(cwd, ".log");
   } else {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve3(cwd, `.log-${timestamp}`);
+    logPath = resolve4(cwd, `.log-${timestamp}`);
   }
   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())
@@ -2025,13 +2110,16 @@ 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, {
     log: logEnabled,
     logTemp: logTempEnabled
   });
   if (logWriter) {
-    const logFile = logTempEnabled ? ".log" : `.log-{datetime}`;
-    logger.info(`\uD83D\uDCDD Logging enabled → ${logFile}`);
+    const logFile = relative(cwd, logWriter.path) || ".log";
+    logLine(logger, `${dim("logging", theme)} ${logFile}`);
   }
   const devLogger = createConsola({
     level: verbose ? 4 : 3
@@ -2044,6 +2132,7 @@ async function runDevCommand(parsed, logger, options) {
         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]"));
@@ -2051,43 +2140,92 @@ async function runDevCommand(parsed, logger, options) {
     Object.assign(devLogger.debug, wrapLog(devLogger.debug.bind(devLogger), "[DEBUG]"));
   }
   try {
-    logger.info("");
-    logger.info("\uD83D\uDE80 Devflare Unified Dev Server");
-    logger.info("   ├─ Vite: Full HMR for frontend");
-    logger.info("   ├─ Miniflare: All Cloudflare bindings");
-    logger.info("   ├─ Rolldown: Fast DO bundling with watch");
-    logger.info("   └─ Bridge: WebSocket RPC connection");
-    logger.info("");
+    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 ? parseInt(port, 10) : 5173,
       miniflarePort: 8787,
+      enableVite: viteProject.shouldStartVite,
       persist: persistEnabled,
       logger: devLogger,
       verbose,
       debug: debugEnabled
     });
-    const cleanup = async () => {
-      logger.info("");
-      logger.info("Shutting down...");
-      await devServer.stop();
-      logWriter?.close();
-      process.exit(0);
+    let isCleaningUp = false;
+    const cleanupHandlers = new Map;
+    const removeCleanupHandlers = () => {
+      for (const [event, handler] of cleanupHandlers) {
+        process.off(event, handler);
+      }
+      cleanupHandlers.clear();
     };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
+    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);
       }
     }
-    logWriter?.close();
     return { exitCode: 1 };
   }
 }