devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/{dev-c1xc1gq9.js → dev-2pd33m28.js}

@@ -1,17 +1,31 @@
 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-zbvmtcn2.js";
+} from "./index-j185x270.js";
 import {
   discoverRoutes,
   getRouteDirectoryCandidate
@@ -21,23 +35,29 @@ import"./index-9wt9x09k.js";
 import {
   clearLocalSendEmailBindings,
   setLocalSendEmailBindings
-} from "./index-fef08w43.js";
-import"./index-rfhx0yd5.js";
+} from "./index-h18pxvzs.js";
+import"./index-thna1tkd.js";
 import {
+  getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
+  getSingleBrowserBindingName,
   loadConfig,
   resolveConfigPath
-} from "./index-wyf3s77s.js";
-import"./index-v8vvsn9x.js";
+} from "./index-0apbm26n.js";
+import"./index-jb75kwa4.js";
+import"./index-0w826dsr.js";
+import"./index-6jef5emv.js";
+import"./index-t08te69w.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";
@@ -810,170 +830,89 @@ 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();
+// 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 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 getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-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;
+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]);
     }
-    if (logger) {
-      logger.info(notice);
-      return;
+    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;
     }
-    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);
+  logger?.warn(`Failed to apply migrations to ${bindingName}: ${getErrorMessage(lastError)}`);
 }
-function writeStderr(logger, message) {
-  if (typeof logger?.error === "function") {
-    logger.error(message);
+async function runD1Migrations(options) {
+  const { cwd, config, miniflarePort, logger } = options;
+  if (!config?.bindings?.d1) {
     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/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) {
-  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);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      continue;
-    }
-  }
-  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);
-}
-function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false || configuredPath === null) {
+  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;
   }
-  if (typeof configuredPath === "string" && configuredPath) {
-    roots.add(dirname(resolve(cwd, configuredPath)));
+  const files = readdirSync(migrationsDir).filter((file) => file.endsWith(".sql")).sort();
+  if (files.length === 0) {
+    logger?.debug("No SQL migration files found");
     return;
   }
-  for (const defaultEntry of defaultEntries) {
-    roots.add(dirname(resolve(cwd, defaultEntry)));
+  logger?.info(`Running ${files.length} D1 migration(s)...`);
+  const allStatements = [];
+  for (const file of files) {
+    const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
+    const statements = collectMigrationStatements(sql);
+    allStatements.push(...statements);
+    logger?.debug(`File ${file}: ${statements.length} statement(s)`);
   }
-}
-function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
-  const roots = new Set;
-  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
-    if (surfacePath) {
-      roots.add(dirname(surfacePath));
-    }
+  if (allStatements.length === 0) {
+    logger?.debug("No executable D1 migration statements found");
+    return;
   }
-  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)) {
+    await applyMigrationsToBinding({
+      bindingName,
+      statements: allStatements,
+      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);
@@ -1528,6 +1467,252 @@ function base64ToArrayBuffer(base64) {
 }
 `;
 }
+
+// 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/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 {
     cwd,
@@ -1569,11 +1754,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}`);
@@ -1583,7 +1767,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 = (() => {
@@ -1659,9 +1843,17 @@ 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: bindings.d1 },
+        ...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 },
@@ -1697,7 +1889,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 {
@@ -1842,7 +2034,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);
@@ -1860,7 +2052,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 {
@@ -1901,7 +2093,7 @@ function createDevServer(options) {
     await refreshWorkerOnlySurfaceState();
     await reloadMiniflare(currentDoResult);
   }
-  async function startWorkerSourceWatcher() {
+  async function startWorkerSourceWatcher2() {
     if (enableVite || !config) {
       return;
     }
@@ -1909,173 +2101,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 });
@@ -2125,7 +2162,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({
@@ -2139,7 +2176,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,
@@ -2158,14 +2195,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) {
@@ -2207,11 +2250,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;
@@ -2242,6 +2285,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, {
@@ -2250,7 +2294,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
@@ -2271,24 +2315,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,
@@ -2318,8 +2362,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 {