devflare 1.0.0-next.6 → 1.0.0-next.8

package/dist/{dev-7agn9g5s.js → dev-074w858d.js}

@@ -10,7 +10,8 @@ import {
   findDurableObjectClasses
 } from "./index-gz1gndna.js";
 import {
-  loadConfig
+  loadConfig,
+  resolveConfigPath
 } from "./index-hcex3rgh.js";
 import {
   __require
@@ -21,7 +22,7 @@ import { createConsola } from "consola";
 import { resolve as resolve3 } from "pathe";
 
 // src/dev-server/server.ts
-import { dirname as dirname2, resolve as resolve2 } from "pathe";
+import { dirname as dirname2, relative as relative2, resolve as resolve2 } from "pathe";
 
 // src/bundler/do-bundler.ts
 import { resolve, dirname, relative } from "pathe";
@@ -1092,6 +1093,40 @@ async function checkRemoteBindingRequirements(config) {
   };
 }
 
+// src/dev-server/miniflare-log.ts
+var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
+var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
+function normalizeMiniflareMessage(message) {
+  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
+}
+function formatCompatibilityDateFallbackNotice(message) {
+  const normalizedMessage = normalizeMiniflareMessage(message);
+  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
+  if (!match) {
+    return null;
+  }
+  const [, _supportedDate, requestedDate, fallbackDate] = match;
+  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
+}
+function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
+  const log = new BaseLog(level);
+  const originalWarn = log.warn.bind(log);
+  const originalInfo = log.info.bind(log);
+  log.warn = (message) => {
+    const notice = formatCompatibilityDateFallbackNotice(message);
+    if (!notice) {
+      originalWarn(message);
+      return;
+    }
+    if (logger) {
+      logger.info(notice);
+      return;
+    }
+    originalInfo(notice);
+  };
+  return log;
+}
+
 // src/dev-server/server.ts
 var DEFAULT_FETCH_ENTRY_FILES = [
   "src/fetch.ts",
@@ -1099,17 +1134,38 @@ var DEFAULT_FETCH_ENTRY_FILES = [
   "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 INTERNAL_APP_SERVICE_BINDING = "__DEVFLARE_APP";
-async function resolveMainWorkerScriptPath(cwd, config) {
-  if (config.files?.fetch === false) {
+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 config.files?.fetch === "string" && config.files.fetch) {
-    candidates.add(config.files.fetch);
+  if (typeof configuredPath === "string" && configuredPath) {
+    candidates.add(configuredPath);
   }
-  for (const defaultEntry of DEFAULT_FETCH_ENTRY_FILES) {
+  for (const defaultEntry of defaultEntries) {
     candidates.add(defaultEntry);
   }
   for (const candidate of candidates) {
@@ -1123,7 +1179,214 @@ async function resolveMainWorkerScriptPath(cwd, config) {
   }
   return null;
 }
-function collectWorkerWatchRoots(cwd, config, mainWorkerScriptPath) {
+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 getFirstWorkerSurfacePath(surfacePaths) {
+  return surfacePaths.fetch ?? surfacePaths.queue ?? surfacePaths.scheduled ?? surfacePaths.email;
+}
+function hasWorkerSurfacePaths(surfacePaths) {
+  return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
+}
+function toImportSpecifier(fromFilePath, toFilePath) {
+  const specifier = relative2(dirname2(fromFilePath), toFilePath).replace(/\\/g, "/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function getMainWorkerEntryScript(surfaceImportPaths) {
+  const importLines = [`import { runWithContext } from 'devflare/runtime'`];
+  const moduleFallbackLines = [];
+  const registerSurfaceModule = (identifier, importPath) => {
+    if (importPath) {
+      importLines.push(`import * as ${identifier} from '${importPath}'`);
+      return;
+    }
+    moduleFallbackLines.push(`const ${identifier} = {}`);
+  };
+  registerSurfaceModule("__devflareFetchModule", surfaceImportPaths.fetch);
+  registerSurfaceModule("__devflareQueueModule", surfaceImportPaths.queue);
+  registerSurfaceModule("__devflareScheduledModule", surfaceImportPaths.scheduled);
+  registerSurfaceModule("__devflareEmailModule", surfaceImportPaths.email);
+  return `
+${importLines.join(`
+`)}
+${moduleFallbackLines.join(`
+`)}
+
+const __devflareResolveHandler = (module, namedExport) => {
+	const defaultExport = module.default
+
+	if (typeof defaultExport === 'function') {
+		return defaultExport
+	}
+
+	if (defaultExport && typeof defaultExport[namedExport] === 'function') {
+		return defaultExport[namedExport].bind(defaultExport)
+	}
+
+	if (typeof module[namedExport] === 'function') {
+		return module[namedExport]
+	}
+
+	return null
+}
+
+const __devflareFetchHandler = __devflareResolveHandler(__devflareFetchModule, 'fetch')
+const __devflareQueueHandler = __devflareResolveHandler(__devflareQueueModule, 'queue')
+const __devflareScheduledHandler = __devflareResolveHandler(__devflareScheduledModule, 'scheduled')
+const __devflareEmailHandler = __devflareResolveHandler(__devflareEmailModule, 'email')
+
+function __devflareCreateEmailHeaders(rawBody) {
+	const headers = new Headers()
+	const lines = rawBody.split(/\\r?\\n/)
+
+	for (const line of lines) {
+		if (line.trim() === '') {
+			break
+		}
+
+		const colonIndex = line.indexOf(':')
+		if (colonIndex <= 0) {
+			continue
+		}
+
+		headers.append(line.slice(0, colonIndex).trim(), line.slice(colonIndex + 1).trim())
+	}
+
+	return headers
+}
+
+function __devflareCreateEmailRawStream(rawBody) {
+	return new ReadableStream({
+		start(controller) {
+			controller.enqueue(new TextEncoder().encode(rawBody))
+			controller.close()
+		}
+	})
+}
+
+async function __devflareHandleInternalEmail(request, env, ctx) {
+	if (!__devflareEmailHandler) {
+		return new Response('Email handler not configured', { status: 501 })
+	}
+
+	const from = request.headers.get('x-devflare-email-from') || 'unknown@example.com'
+	const to = request.headers.get('x-devflare-email-to') || 'worker@example.com'
+	const rawBody = await request.text()
+	const emailMessage = {
+		from,
+		to,
+		headers: __devflareCreateEmailHeaders(rawBody),
+		raw: __devflareCreateEmailRawStream(rawBody),
+		rawSize: rawBody.length,
+		setReject(reason) {
+			console.warn('[Devflare email rejected]', reason)
+		},
+		async forward(rcptTo) {
+			console.log('[Devflare email forwarded]', rcptTo)
+			return Promise.resolve()
+		},
+		async reply(message) {
+			console.log('[Devflare email reply sent]', message?.from)
+			return Promise.resolve()
+		}
+	}
+
+	await runWithContext(
+		env,
+		ctx,
+		null,
+		() => __devflareEmailHandler(emailMessage, env, ctx),
+		'email'
+	)
+
+	return new Response(JSON.stringify({ ok: true, from, to }), {
+		headers: { 'Content-Type': 'application/json' }
+	})
+}
+
+export default {
+	async fetch(request, env, ctx) {
+		const url = new URL(request.url)
+
+		if (
+			request.headers.get('x-devflare-event') === 'email' &&
+			url.pathname === '/_devflare/internal/email'
+		) {
+			return __devflareHandleInternalEmail(request, env, ctx)
+		}
+
+		if (!__devflareFetchHandler) {
+			return new Response('Fetch handler not configured', { status: 404 })
+		}
+
+		return runWithContext(
+			env,
+			ctx,
+			request,
+			() => __devflareFetchHandler(request, env, ctx),
+			'fetch'
+		)
+	},
+	...(__devflareQueueHandler
+		? {
+			async queue(batch, env, ctx) {
+				return runWithContext(
+					env,
+					ctx,
+					null,
+					() => __devflareQueueHandler(batch, env, ctx),
+					'queue'
+				)
+			}
+		}
+		: {}),
+	...(__devflareScheduledHandler
+		? {
+			async scheduled(controller, env, ctx) {
+				return runWithContext(
+					env,
+					ctx,
+					null,
+					() => __devflareScheduledHandler(controller, env, ctx),
+					'scheduled'
+				)
+			}
+		}
+		: {}),
+	...(__devflareEmailHandler
+		? {
+			async email(message, env, ctx) {
+				return runWithContext(
+					env,
+					ctx,
+					null,
+					() => __devflareEmailHandler(message, env, ctx),
+					'email'
+				)
+			}
+		}
+		: {})
+}
+`;
+}
+function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
+  if (configuredPath === false) {
+    return;
+  }
+  if (typeof configuredPath === "string" && configuredPath) {
+    roots.add(dirname2(resolve2(cwd, configuredPath)));
+    return;
+  }
+  for (const defaultEntry of defaultEntries) {
+    roots.add(dirname2(resolve2(cwd, defaultEntry)));
+  }
+}
+function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
   const roots = new Set;
   const addFileParent = (filePath) => {
     if (typeof filePath !== "string" || !filePath) {
@@ -1131,13 +1394,15 @@ function collectWorkerWatchRoots(cwd, config, mainWorkerScriptPath) {
     }
     roots.add(dirname2(resolve2(cwd, filePath)));
   };
-  if (mainWorkerScriptPath) {
-    roots.add(dirname2(mainWorkerScriptPath));
+  for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
+    if (surfacePath) {
+      roots.add(dirname2(surfacePath));
+    }
   }
-  addFileParent(config.files?.fetch);
-  addFileParent(config.files?.queue);
-  addFileParent(config.files?.scheduled);
-  addFileParent(config.files?.email);
+  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);
   if (config.files?.routes && typeof config.files.routes === "object") {
     roots.add(resolve2(cwd, config.files.routes.dir));
@@ -1263,69 +1528,27 @@ async function handleEmailIncoming(request, env, ctx, url) {
 		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' }
 		})
@@ -1737,16 +1960,24 @@ function createDevServer(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 reloadChain = Promise.resolve();
   async function bundleMainWorker() {
-    if (!mainWorkerScriptPath) {
+    if (!hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
       bundledMainWorkerScriptPath = null;
       return;
     }
@@ -1755,17 +1986,27 @@ function createDevServer(options) {
     }
     const fs = await import("node:fs/promises");
     const outDir = resolve2(cwd, ".devflare", "worker-bundles");
+    const entryDir = resolve2(cwd, ".devflare", "worker-entrypoints");
     await fs.rm(outDir, { recursive: true, force: true });
     await fs.mkdir(outDir, { recursive: true });
+    await fs.mkdir(entryDir, { recursive: true });
+    const entryPath = resolve2(entryDir, "fetch-entry.ts");
+    const surfaceImportPaths = {
+      fetch: mainWorkerSurfacePaths.fetch ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.fetch) : null,
+      queue: mainWorkerSurfacePaths.queue ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.queue) : null,
+      scheduled: mainWorkerSurfacePaths.scheduled ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.scheduled) : null,
+      email: mainWorkerSurfacePaths.email ? toImportSpecifier(entryPath, mainWorkerSurfacePaths.email) : null
+    };
+    await fs.writeFile(entryPath, getMainWorkerEntryScript(surfaceImportPaths));
     const result = await Bun.build({
-      entrypoints: [mainWorkerScriptPath],
+      entrypoints: [entryPath],
       outdir: outDir,
       target: "browser",
       conditions: ["browser"],
       format: "esm",
       minify: false,
       splitting: false,
-      external: ["cloudflare:workers", "cloudflare:*"]
+      external: ["cloudflare:workers", "cloudflare:*", "node:*"]
     });
     if (!result.success || result.outputs.length === 0) {
       const logs = result.logs.map((log) => ("message" in log) ? log.message : String(log)).join(`
@@ -1783,7 +2024,7 @@ ${logs}`);
     const bindings = loadedConfig.bindings ?? {};
     const persistPath = resolve2(cwd, ".devflare/data");
     const appWorkerName = loadedConfig.name;
-    const shouldRunMainWorker = !enableVite && !!mainWorkerScriptPath;
+    const shouldRunMainWorker = !enableVite && hasWorkerSurfacePaths(mainWorkerSurfacePaths);
     const queueProducers = (() => {
       if (!bindings.queues?.producers) {
         return;
@@ -1794,6 +2035,23 @@ ${logs}`);
       }
       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",
@@ -1829,7 +2087,9 @@ ${logs}`);
         ...bindings.r2 && { r2Buckets: bindings.r2 },
         ...bindings.d1 && { d1Databases: bindings.d1 },
         ...loadedConfig.vars && Object.keys(loadedConfig.vars).length > 0 && { bindings: loadedConfig.vars },
-        ...queueProducers && { queueProducers }
+        ...queueProducers && { queueProducers },
+        ...options2.queueConsumers && { queueConsumers: options2.queueConsumers },
+        ...options2.triggers && { triggers: options2.triggers }
       };
       if (options2.scriptPath) {
         workerConfig.scriptPath = options2.scriptPath;
@@ -1879,7 +2139,9 @@ ${logs}`);
       const mainWorkerConfig = createWorkerConfig({
         name: appWorkerName,
         scriptPath: bundledMainWorkerScriptPath ?? mainWorkerScriptPath,
-        serviceBindings: mainWorkerServiceBindings
+        serviceBindings: mainWorkerServiceBindings,
+        queueConsumers,
+        triggers: loadedConfig.triggers?.crons?.length ? { crons: loadedConfig.triggers.crons } : undefined
       });
       workers.push(mainWorkerConfig);
     }
@@ -1935,48 +2197,53 @@ ${logs}`);
   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);
+    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) {
@@ -1986,7 +2253,7 @@ ${logs}`);
         return;
       const { Log, LogLevel } = await import("miniflare");
       const mfConfig = buildMiniflareConfig(currentDoResult);
-      mfConfig.log = new Log(LogLevel.DEBUG);
+      mfConfig.log = createCompatibilityAwareMiniflareLog(Log, LogLevel.DEBUG, logger);
       logger?.info("Reloading Miniflare...");
       await miniflare.setOptions(mfConfig);
       logger?.success("Miniflare reloaded");
@@ -1994,12 +2261,68 @@ ${logs}`);
     reloadChain = queuedReload.catch(() => {});
     await queuedReload;
   }
+  async function resolveWorkerConfigWatchPath() {
+    if (configPath) {
+      const explicitPath = resolve2(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;
+    }
+    mainWorkerSurfacePaths = await resolveMainWorkerSurfacePaths(cwd, config);
+    mainWorkerScriptPath = getFirstWorkerSurfacePath(mainWorkerSurfacePaths);
+    if (hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
+      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;
+    }
+    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 reloadWorkerOnlyConfig() {
+    config = await loadConfig({ cwd, configFile: configPath });
+    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
+    await refreshWorkerOnlySurfaceState();
+    await reloadMiniflare(currentDoResult);
+  }
   async function startWorkerSourceWatcher() {
-    if (enableVite || !config || !mainWorkerScriptPath) {
+    if (enableVite || !config) {
       return;
     }
-    const watchRoots = collectWorkerWatchRoots(cwd, config, mainWorkerScriptPath);
-    if (watchRoots.length === 0) {
+    const watchTargets = getWorkerWatchTargets();
+    if (watchTargets.length === 0) {
       return;
     }
     const chokidar = await import("chokidar");
@@ -2020,8 +2343,14 @@ ${logs}`);
       }
       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}`);
-        await bundleMainWorker();
+        await refreshWorkerOnlySurfaceState();
         await reloadMiniflare(currentDoResult);
       } catch (error) {
         logger?.error("Worker source reload failed:", error);
@@ -2042,7 +2371,8 @@ ${logs}`);
         triggerReload(filePath);
       }, 150);
     };
-    workerSourceWatcher = chokidar.watch(watchRoots, {
+    workerWatchTargets = watchTargets;
+    workerSourceWatcher = chokidar.watch(watchTargets, {
       ignoreInitial: true,
       usePolling: isWindows,
       interval: isWindows ? 300 : undefined,
@@ -2061,12 +2391,22 @@ ${logs}`);
     workerSourceWatcher.on("change", onFileEvent);
     workerSourceWatcher.on("add", onFileEvent);
     workerSourceWatcher.on("unlink", onFileEvent);
-    workerSourceWatcher.on("ready", () => {
-      logger?.info(`Worker source watcher ready (${watchRoots.length} root(s))`);
-    });
     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)
@@ -2152,13 +2492,14 @@ ${logs}`);
   async function start() {
     logger?.info("Starting unified dev server...");
     config = await loadConfig({ cwd, configFile: configPath });
+    resolvedWorkerConfigPath = await resolveWorkerConfigWatchPath();
     logger?.debug("Loaded config:", config.name);
-    mainWorkerScriptPath = await resolveMainWorkerScriptPath(cwd, config);
-    if (!enableVite && mainWorkerScriptPath) {
-      logger?.info(`Worker entry detected: ${mainWorkerScriptPath}`);
-      await bundleMainWorker();
+    await refreshWorkerOnlySurfaceState();
+    if (!enableVite && hasWorkerSurfacePaths(mainWorkerSurfacePaths)) {
+      const detectedWorkerHandlers = Object.entries(mainWorkerSurfacePaths).filter(([, surfacePath]) => !!surfacePath).map(([surfaceName, surfacePath]) => `${surfaceName}=${surfacePath}`).join(", ");
+      logger?.info(`Worker handlers detected: ${detectedWorkerHandlers}`);
     } else if (!enableVite) {
-      logger?.warn("No local fetch worker entry was found for worker-only mode");
+      logger?.warn("No local worker handler entry was found for worker-only mode");
     }
     const remoteCheck = await checkRemoteBindingRequirements(config);
     if (remoteCheck.hasRemoteBindings) {