devflare 1.0.0-next.10 → 1.0.0-next.12

package/dist/{dev-rk8p6pse.js → dev-d4wabqyf.js}

@@ -1,442 +1,44 @@
+import {
+  bundleWorkerEntry,
+  createDOBundler
+} from "./index-1xqeptt2.js";
 import {
   detectViteProject,
   stopSpawnedProcessTree,
   waitForViteReady
 } from "./index-y1d8za14.js";
 import {
-  prepareComposedWorkerEntrypoint
-} from "./index-ws68xvq2.js";
+  prepareComposedWorkerEntrypoint,
+  resolveEffectiveViteProject,
+  writeGeneratedViteConfig
+} from "./index-zbvmtcn2.js";
 import {
   discoverRoutes,
   getRouteDirectoryCandidate
 } from "./index-1p814k7s.js";
-import {
-  findDurableObjectClasses,
-  transformDurableObject
-} from "./index-9wt9x09k.js";
-import {
-  findFiles
-} from "./index-rbht7m9r.js";
+import"./index-rbht7m9r.js";
+import"./index-9wt9x09k.js";
 import {
   clearLocalSendEmailBindings,
   setLocalSendEmailBindings
 } from "./index-fef08w43.js";
+import"./index-rfhx0yd5.js";
 import {
   loadConfig,
   resolveConfigPath
-} from "./index-1phx14av.js";
+} from "./index-wyf3s77s.js";
+import"./index-v8vvsn9x.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/cli/commands/dev.ts
 import { createConsola } from "consola";
-import { relative as relative2, resolve as resolve3 } from "pathe";
+import { relative, resolve as resolve2 } from "pathe";
 
 // src/dev-server/server.ts
-import { dirname as dirname2, resolve as resolve2 } 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;
-}
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-function matchesExternalPattern(pattern, id) {
-  if (pattern instanceof RegExp) {
-    pattern.lastIndex = 0;
-    return pattern.test(id);
-  }
-  return pattern === id;
-}
-function matchesExternalOption(option, id, parentId, isResolved) {
-  if (!option) {
-    return false;
-  }
-  if (typeof option === "function") {
-    return option(id, parentId, isResolved) ?? false;
-  }
-  return toArray(option).some((pattern) => matchesExternalPattern(pattern, id));
-}
-function mergeExternalOptions(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  if (typeof base !== "function" && typeof user !== "function") {
-    return [...toArray(base), ...toArray(user)];
-  }
-  return (id, parentId, isResolved) => {
-    return matchesExternalOption(base, id, parentId, isResolved) || matchesExternalOption(user, id, parentId, isResolved) || false;
-  };
-}
-function mergePluginOptions(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  return [base, user];
-}
-function mergeResolveOptions(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  return {
-    ...user,
-    ...base,
-    alias: {
-      ...user.alias ?? {},
-      ...base.alias ?? {}
-    }
-  };
-}
-function resolveDOBundleRolldownConfig(options) {
-  const {
-    output: userOutputOptions,
-    input: _ignoredInput,
-    cwd: _ignoredCwd,
-    platform: _ignoredPlatform,
-    watch: _ignoredWatch,
-    external: userExternal,
-    plugins: userPlugins,
-    resolve: userResolve,
-    tsconfig: userTsconfig,
-    ...userInputOptions
-  } = options.rolldownOptions ?? {};
-  const {
-    codeSplitting: _ignoredCodeSplitting,
-    dir: _ignoredDir,
-    file: _ignoredFile,
-    format: _ignoredFormat,
-    inlineDynamicImports: _ignoredInlineDynamicImports,
-    ...safeUserOutputOptions
-  } = userOutputOptions ?? {};
-  const defaultExternalModules = [
-    /^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"
-  ];
-  return {
-    inputOptions: {
-      ...userInputOptions,
-      input: options.inputFile,
-      cwd: options.cwd,
-      platform: "neutral",
-      tsconfig: userTsconfig ?? resolve(options.cwd, "tsconfig.json"),
-      external: mergeExternalOptions(defaultExternalModules, userExternal),
-      plugins: mergePluginOptions(undefined, userPlugins),
-      resolve: mergeResolveOptions({
-        alias: {
-          debug: options.debugShimPath
-        }
-      }, userResolve)
-    },
-    outputOptions: {
-      ...safeUserOutputOptions,
-      file: options.outFile,
-      format: "esm",
-      sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
-      minify: safeUserOutputOptions.minify ?? options.minify,
-      codeSplitting: false
-    }
-  };
-}
-async function bundleDOFile(sourcePath, className, outDir, cwd, bundleOptions) {
-  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 transformedCode = (await transformDurableObject(sourceCode, sourcePath))?.code ?? stripDecoratorSyntax(sourceCode);
-  const entryCode = `${transformedCode}
+import { dirname, resolve } from "pathe";
 
-// Default export for worker (required by Miniflare)
-export default {
-	async fetch(request) {
-		return new Response('DO Worker for ${className}', { status: 200 });
-	}
-};
-`;
-  const tempFilePath = resolve(dirname(sourcePath), `.devflare-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 outFile = resolve(classOutDir, "index.js");
-  const { inputOptions, outputOptions } = resolveDOBundleRolldownConfig({
-    cwd,
-    inputFile: tempFilePath,
-    outFile,
-    debugShimPath,
-    rolldownOptions: bundleOptions?.rolldownOptions,
-    sourcemap: bundleOptions?.sourcemap,
-    minify: bundleOptions?.minify
-  });
-  const bundle = await rolldown(inputOptions);
-  await bundle.write(outputOptions);
-  await bundle.close();
-  try {
-    await fs.unlink(tempFilePath);
-  } catch {}
-  return resolve(classOutDir, "index.js");
-}
-async function bundleAllDOs(discovered, outDir, cwd, logger, bundleOptions) {
-  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, bundleOptions);
-      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, rolldownOptions, sourcemap, minify } = 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, {
-      rolldownOptions,
-      sourcemap,
-      minify
-    });
-    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";
@@ -658,10 +260,10 @@ 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()));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString()));
       req.on("error", reject);
     });
   }
@@ -802,10 +404,10 @@ 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}`);
@@ -815,8 +417,8 @@ function createBrowserShim(options = {}) {
       await closeSession(sessionId, 3, "ServerShutdown");
     }
     if (server) {
-      await new Promise((resolve2) => {
-        server.close(() => resolve2());
+      await new Promise((resolve) => {
+        server.close(() => resolve());
       });
       server = null;
     }
@@ -1298,6 +900,12 @@ var DEFAULT_EMAIL_ENTRY_FILES = [
   "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);
@@ -1315,7 +923,7 @@ async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
     candidates.add(defaultEntry);
   }
   for (const candidate of candidates) {
-    const absolutePath = resolve2(cwd, candidate);
+    const absolutePath = resolve(cwd, candidate);
     try {
       await fs.access(absolutePath);
       return absolutePath;
@@ -1337,35 +945,29 @@ function hasWorkerSurfacePaths(surfacePaths) {
   return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
 }
 function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
-  if (configuredPath === false) {
+  if (configuredPath === false || configuredPath === null) {
     return;
   }
   if (typeof configuredPath === "string" && configuredPath) {
-    roots.add(dirname2(resolve2(cwd, configuredPath)));
+    roots.add(dirname(resolve(cwd, configuredPath)));
     return;
   }
   for (const defaultEntry of defaultEntries) {
-    roots.add(dirname2(resolve2(cwd, defaultEntry)));
+    roots.add(dirname(resolve(cwd, defaultEntry)));
   }
 }
 function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
   const roots = new Set;
-  const addFileParent = (filePath) => {
-    if (typeof filePath !== "string" || !filePath) {
-      return;
-    }
-    roots.add(dirname2(resolve2(cwd, filePath)));
-  };
   for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
     if (surfacePath) {
-      roots.add(dirname2(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);
-  addFileParent(config.files?.transport);
+  addWorkerWatchRoots(roots, cwd, config.files?.transport, DEFAULT_TRANSPORT_ENTRY_FILES);
   const routeDirectory = getRouteDirectoryCandidate(cwd, config);
   if (routeDirectory) {
     roots.add(routeDirectory.absoluteDir);
@@ -1957,36 +1559,23 @@ function createDevServer(options) {
   let bundledMainWorkerScriptPath = null;
   let currentDoResult = null;
   let mainWorkerRoutes = null;
+  let generatedViteConfigPath = null;
   let reloadChain = Promise.resolve();
   async function bundleMainWorker() {
-    if (!mainWorkerScriptPath) {
+    if (!mainWorkerScriptPath || !config) {
       bundledMainWorkerScriptPath = null;
       return;
     }
-    if (typeof Bun === "undefined" || typeof Bun.build !== "function") {
-      throw new Error("Worker-only dev mode requires the Bun runtime for main worker bundling");
-    }
-    const fs = await import("node:fs/promises");
-    const outDir = resolve2(cwd, ".devflare", "worker-bundles");
-    await fs.rm(outDir, { recursive: true, force: true });
-    await fs.mkdir(outDir, { recursive: true });
-    const result = await Bun.build({
-      entrypoints: [mainWorkerScriptPath],
-      outdir: outDir,
-      target: "browser",
-      conditions: ["browser"],
-      format: "esm",
-      minify: false,
-      splitting: false,
-      external: ["cloudflare:workers", "cloudflare:*", "node:*"]
+    bundledMainWorkerScriptPath = await bundleWorkerEntry({
+      cwd,
+      inputFile: mainWorkerScriptPath,
+      outFile: resolve(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      rolldownOptions: config.rolldown?.options,
+      sourcemap: config.rolldown?.sourcemap,
+      minify: config.rolldown?.minify,
+      target: config.rolldown?.target,
+      logger
     });
-    if (!result.success || result.outputs.length === 0) {
-      const logs = result.logs.map((log) => ("message" in log) ? log.message : String(log)).join(`
-`);
-      throw new Error(`Failed to bundle main worker:
-${logs}`);
-    }
-    bundledMainWorkerScriptPath = result.outputs[0].path;
     logger?.debug(`Bundled main worker → ${bundledMainWorkerScriptPath}`);
   }
   function buildMiniflareConfig(doResult) {
@@ -1994,7 +1583,7 @@ ${logs}`);
       throw new Error("Config not loaded");
     const loadedConfig = config;
     const bindings = loadedConfig.bindings ?? {};
-    const persistPath = resolve2(cwd, ".devflare/data");
+    const persistPath = resolve(cwd, ".devflare/data");
     const appWorkerName = loadedConfig.name;
     const shouldRunMainWorker = !enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length));
     const queueProducers = (() => {
@@ -2253,7 +1842,7 @@ ${logs}`);
   }
   async function resolveWorkerConfigWatchPath() {
     if (configPath) {
-      const explicitPath = resolve2(cwd, configPath);
+      const explicitPath = resolve(cwd, configPath);
       const fs = await import("node:fs/promises");
       try {
         await fs.access(explicitPath);
@@ -2271,7 +1860,7 @@ ${logs}`);
     const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, config, undefined, {
       devInternalEmail: true
     });
-    mainWorkerScriptPath = composedMainEntry ? resolve2(cwd, composedMainEntry) : null;
+    mainWorkerScriptPath = composedMainEntry ? resolve(cwd, composedMainEntry) : null;
     if (mainWorkerScriptPath) {
       await bundleMainWorker();
     } else {
@@ -2407,7 +1996,7 @@ ${logs}`);
     if (!miniflare || !config?.bindings?.d1)
       return;
     const { existsSync: existsSync2, readdirSync, readFileSync } = await import("node:fs");
-    const migrationsDir = resolve2(cwd, "migrations");
+    const migrationsDir = resolve(cwd, "migrations");
     if (!existsSync2(migrationsDir)) {
       logger?.debug("No migrations/ directory found, skipping D1 migrations");
       return;
@@ -2420,7 +2009,7 @@ ${logs}`);
     logger?.info(`Running ${files.length} D1 migration(s)...`);
     const allStatements = [];
     for (const file of files) {
-      const sql = readFileSync(resolve2(migrationsDir, file), "utf-8");
+      const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
       const cleanedSql = sql.split(`
 `).filter((line) => !line.trim().startsWith("--")).join(`
 `);
@@ -2459,6 +2048,9 @@ ${logs}`);
   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"],
@@ -2490,6 +2082,16 @@ ${logs}`);
     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}`);
@@ -2537,7 +2139,7 @@ ${logs}`);
     const doPattern = config.files?.durableObjects;
     let doResult = null;
     if (typeof doPattern === "string" && doPattern) {
-      const outDir = resolve2(cwd, ".devflare/do-bundles");
+      const outDir = resolve(cwd, ".devflare/do-bundles");
       doBundler = createDOBundler({
         cwd,
         pattern: doPattern,
@@ -2560,7 +2162,7 @@ ${logs}`);
     if (enableVite) {
       await startVite();
     } else {
-      logger?.info("Vite startup skipped (no local vite.config.* found for this package)");
+      logger?.info("Vite startup skipped (no effective Vite config found for this package)");
     }
     await new Promise((r) => setTimeout(r, 1000));
     await runD1Migrations();
@@ -2605,11 +2207,11 @@ async function createLogWriter(cwd, options) {
   const fs = await import("node:fs");
   let logPath;
   if (options.logTemp) {
-    logPath = resolve3(cwd, ".log");
+    logPath = resolve2(cwd, ".log");
   } else {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve3(cwd, `.log-${timestamp}`);
+    logPath = resolve2(cwd, `.log-${timestamp}`);
   }
   const fileStream = fs.createWriteStream(logPath, { flags: "w" });
   const ansiRegex = /\x1b\[[0-9;]*m/g;
@@ -2640,13 +2242,14 @@ 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 viteProject = await detectViteProject(cwd);
+  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 = relative2(cwd, logWriter.path) || ".log";
+    const logFile = relative(cwd, logWriter.path) || ".log";
     logger.info(`\uD83D\uDCDD Logging enabled → ${logFile}`);
   }
   const devLogger = createConsola({
@@ -2673,15 +2276,15 @@ async function runDevCommand(parsed, logger, options) {
       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("   ├─ Rolldown: Worker + DO bundling with watch");
       logger.info("   └─ Bridge: WebSocket RPC connection");
     } else {
       logger.info("\uD83D\uDE80 Devflare Worker Dev Server");
       logger.info("   ├─ Miniflare: All Cloudflare bindings");
-      logger.info("   ├─ Rolldown: Fast DO bundling with watch");
-      logger.info("   └─ Vite: Disabled (no local vite.config.* found)");
+      logger.info("   ├─ Rolldown: Worker + DO bundling with watch");
+      logger.info("   └─ Vite: Disabled (no effective Vite config found)");
       if (viteProject.wantsViteIntegration) {
-        logger.warn("Vite-related dependencies were found, but no local vite.config.* was detected");
+        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");
       }
     }