devflare 1.0.0-next.5 → 1.0.0-next.7

package/dist/{dev-b9dmrj7b.js → dev-rsdssknb.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";
@@ -1099,17 +1100,35 @@ 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) {
+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 +1142,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 +1357,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 +1491,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 +1923,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,16 +1949,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(`
@@ -1782,7 +1987,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;
@@ -1793,6 +1998,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",
@@ -1828,7 +2050,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;
@@ -1878,7 +2102,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);
     }
@@ -1993,12 +2219,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");
@@ -2019,8 +2301,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);
@@ -2041,7 +2329,8 @@ ${logs}`);
         triggerReload(filePath);
       }, 150);
     };
-    workerSourceWatcher = chokidar.watch(watchRoots, {
+    workerWatchTargets = watchTargets;
+    workerSourceWatcher = chokidar.watch(watchTargets, {
       ignoreInitial: true,
       usePolling: isWindows,
       interval: isWindows ? 300 : undefined,
@@ -2061,7 +2350,7 @@ ${logs}`);
     workerSourceWatcher.on("add", onFileEvent);
     workerSourceWatcher.on("unlink", onFileEvent);
     workerSourceWatcher.on("ready", () => {
-      logger?.info(`Worker source watcher ready (${watchRoots.length} root(s))`);
+      logger?.info(`Worker source watcher ready (${watchTargets.length} target(s))`);
     });
     workerSourceWatcher.on("error", (error) => {
       logger?.error("Worker source watcher error:", error);
@@ -2151,13 +2440,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) {

package/dist/dev-server/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAc3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AAmqBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAkuBpE"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev-server/server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAA;AAc3D,MAAM,WAAW,gBAAgB;IAChC,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACzB,2BAA2B;IAC3B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,0BAA0B;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,yCAAyC;IACzC,YAAY,IAAI,aAAa,GAAG,IAAI,CAAA;CACpC;AAy3BD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAi3BpE"}

package/dist/index-62b3gt2g.js

@@ -0,0 +1,12 @@
+// src/workerName.ts
+var workerName = (() => {
+  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
+    return __DEVFLARE_WORKER_NAME__;
+  }
+  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
+    return process.env.DEVFLARE_WORKER_NAME;
+  }
+  return "unknown";
+})();
+
+export { workerName };