devflare 1.0.0-next.6 → 1.0.0-next.7

package/dist/index-a0fjkq68.js

@@ -0,0 +1,198 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/worker-entry/composed-worker.ts
+import { defu } from "defu";
+import { dirname, relative, resolve } from "pathe";
+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"
+];
+function resolveConfigForEnvironment(config, environment) {
+  if (environment && config.env?.[environment]) {
+    return defu(config.env[environment], config);
+  }
+  return config;
+}
+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 resolveWorkerSurfacePaths(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 toImportSpecifier(fromFilePath, toFilePath) {
+  const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function needsComposedWorkerEntrypoint(surfacePaths) {
+  return Boolean(surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email);
+}
+function getComposedWorkerEntrypointSource(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')
+
+export default {
+	...(__devflareFetchHandler
+		? {
+			async fetch(request, env, ctx) {
+				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'
+				)
+			}
+		}
+		: {})
+}
+`.trimStart();
+}
+async function prepareComposedWorkerEntrypoint(cwd, config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  if (resolvedConfig.wrangler?.passthrough && Object.prototype.hasOwnProperty.call(resolvedConfig.wrangler.passthrough, "main")) {
+    return null;
+  }
+  const surfacePaths = await resolveWorkerSurfacePaths(cwd, resolvedConfig);
+  if (!needsComposedWorkerEntrypoint(surfacePaths)) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  const entryDir = resolve(cwd, ".devflare", "worker-entrypoints");
+  const entryPath = resolve(entryDir, "main.ts");
+  await fs.mkdir(entryDir, { recursive: true });
+  const surfaceImportPaths = {
+    fetch: surfacePaths.fetch ? toImportSpecifier(entryPath, surfacePaths.fetch) : null,
+    queue: surfacePaths.queue ? toImportSpecifier(entryPath, surfacePaths.queue) : null,
+    scheduled: surfacePaths.scheduled ? toImportSpecifier(entryPath, surfacePaths.scheduled) : null,
+    email: surfacePaths.email ? toImportSpecifier(entryPath, surfacePaths.email) : null
+  };
+  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths));
+  return ".devflare/worker-entrypoints/main.ts";
+}
+
+export { prepareComposedWorkerEntrypoint };

package/dist/{index-rprrn24p.js → index-f8qh2tyh.js}

@@ -35,7 +35,8 @@ import {
 } from "./index-ccrh4w3t.js";
 import {
   loadConfig,
-  normalizeDOBinding
+  normalizeDOBinding,
+  resolveConfigPath
 } from "./index-hcex3rgh.js";
 import {
   canProceedWithTest,
@@ -1062,15 +1063,12 @@ function getCallerDirectory() {
   }
   return process.cwd();
 }
-function findNearestConfig(startDir) {
-  const configNames = ["devflare.config.ts", "devflare.config.js"];
+async function findNearestConfig(startDir) {
   let currentDir = startDir;
   while (true) {
-    for (const name of configNames) {
-      const configPath = join6(currentDir, name);
-      if (existsSync2(configPath)) {
-        return configPath;
-      }
+    const configPath = await resolveConfigPath(currentDir);
+    if (configPath) {
+      return configPath;
     }
     const parentDir = dirname2(currentDir);
     if (parentDir === currentDir) {
@@ -1085,9 +1083,10 @@ async function createTestContext(configPath) {
   if (configPath) {
     absolutePath = resolve2(callerDir, configPath);
   } else {
-    const found = findNearestConfig(callerDir);
+    const found = await findNearestConfig(callerDir);
     if (!found) {
-      throw new Error(`Could not find devflare.config.ts. Searched upward from: ${callerDir}
+      throw new Error(`Could not find a devflare config file. Searched upward from: ${callerDir}
+` + `Expected one of: devflare.config.ts, devflare.config.mts, devflare.config.js, devflare.config.mjs
 ` + `Either create a config file or provide an explicit path: createTestContext('./path/to/config.ts')`);
     }
     absolutePath = found;

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   stopBridgeTestContext,
   testEnv,
   withTestContext
-} from "./index-rprrn24p.js";
+} from "./index-f8qh2tyh.js";
 import"./index-d8bdkx2h.js";
 import {
   findExportedFunctions,
@@ -215,19 +215,19 @@ async function runInit(parsed, logger, options) {
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-7agn9g5s.js");
+  const { runDevCommand } = await import("./dev-rsdssknb.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-nz5yrj7f.js");
+  const { runBuildCommand } = await import("./build-9myaxf07.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-a5pcxd5w.js");
+  const { runDeployCommand } = await import("./deploy-h1wz5p7m.js");
   return runDeployCommand(parsed, logger, options);
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-vss6vrz7.js");
+  const { runTypesCommand } = await import("./types-wdcpnfvy.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {

package/dist/test/index.js

@@ -26,7 +26,7 @@ import {
   testEnv,
   withTestContext,
   worker
-} from "../index-rprrn24p.js";
+} from "../index-f8qh2tyh.js";
 import"../index-d8bdkx2h.js";
 import"../index-z14anrqp.js";
 import"../index-tk6ej9dj.js";

package/dist/test/simple-context.d.ts

@@ -3,7 +3,7 @@
  * This starts Miniflare with the configured bindings and sets up the bridge.
  *
  * @param configPath - Optional path to config file. If not provided, searches
- *                     upward from the test file for devflare.config.ts.
+ *                     upward from the test file for a supported devflare config.
  *                     If provided, path is resolved relative to the test file.
  */
 export declare function createTestContext(configPath?: string): Promise<void>;

package/dist/test/simple-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simple-context.d.ts","sourceRoot":"","sources":["../../src/test/simple-context.ts"],"names":[],"mappings":"AAiKA;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAse1E;AA+BD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACvB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAED;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,WAAW;CAAI;AAEhC;;;;;;;;GAQG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"simple-context.d.ts","sourceRoot":"","sources":["../../src/test/simple-context.ts"],"names":[],"mappings":"AA8JA;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAue1E;AA+BD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACvB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAED;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,WAAW;CAAI;AAEhC;;;;;;;;GAQG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA"}

package/dist/{types-vss6vrz7.js → types-wdcpnfvy.js}

@@ -18,7 +18,8 @@ import"./index-v8vvsn9x.js";
 import"./index-67qcae0f.js";
 import {
   loadConfig,
-  normalizeDOBinding
+  normalizeDOBinding,
+  resolveConfigPath
 } from "./index-hcex3rgh.js";
 import {
   __require
@@ -26,6 +27,34 @@ import {
 
 // src/cli/commands/types.ts
 import { resolve, relative, dirname } from "pathe";
+var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+function hasKnownConfigExtension(filePath) {
+  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function resolveConfigCandidatePath(candidatePath) {
+  const fs = await import("node:fs/promises");
+  const candidates = [candidatePath];
+  const getExistingFilePath = async (filePath) => {
+    try {
+      const stat = await fs.stat(filePath);
+      return stat.isFile() ? filePath : null;
+    } catch {
+      return null;
+    }
+  };
+  if (!hasKnownConfigExtension(candidatePath)) {
+    for (const extension of CONFIG_FILE_EXTENSIONS) {
+      candidates.push(`${candidatePath}${extension}`);
+    }
+  }
+  for (const candidate of candidates) {
+    const existingFilePath = await getExistingFilePath(candidate);
+    if (existingFilePath) {
+      return existingFilePath;
+    }
+  }
+  return await resolveConfigPath(candidatePath) ?? null;
+}
 async function parseConfigForRefs(configPath) {
   const fs = await import("node:fs/promises");
   const refs = [];
@@ -99,7 +128,6 @@ async function findInterfaceTypes(searchDirs) {
   return interfaces;
 }
 async function resolveReferencedConfigs(configPath, cwd) {
-  const fs = await import("node:fs/promises");
   const referenced = [];
   const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
   if (refs.length === 0) {
@@ -107,12 +135,12 @@ async function resolveReferencedConfigs(configPath, cwd) {
   }
   const configDir = dirname(configPath);
   for (const ref of refs) {
-    let refConfigPath = resolvePackageSpecifier(ref.importPath, configDir);
-    if (!refConfigPath.endsWith(".ts") && !refConfigPath.endsWith(".js")) {
-      refConfigPath += ".ts";
+    const refImportPath = resolvePackageSpecifier(ref.importPath, configDir);
+    const refConfigPath = await resolveConfigCandidatePath(refImportPath);
+    if (!refConfigPath) {
+      continue;
     }
     try {
-      await fs.access(refConfigPath);
       const refDir = dirname(refConfigPath);
       const entrypoints = await discoverEntrypointsAsync(refDir, DEFAULT_ENTRYPOINT_PATTERN);
       const refDOs = await discoverDurableObjects(refDir, DEFAULT_DO_PATTERN);
@@ -371,8 +399,12 @@ async function runTypesCommand(parsed, logger, options) {
   const outputPath = parsed.options.output || "env.d.ts";
   logger.info("Generating TypeScript types...");
   try {
-    const actualConfigPath = configPath ? resolve(cwd, configPath) : resolve(cwd, "devflare.config.ts");
     const config = await loadConfig({ cwd, configFile: configPath });
+    const requestedConfigPath = configPath ? resolve(cwd, configPath) : cwd;
+    const actualConfigPath = await resolveConfigCandidatePath(requestedConfigPath);
+    if (!actualConfigPath) {
+      throw new Error("Could not resolve the loaded devflare config file path");
+    }
     const doPattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
     let discoveredDOs = [];
     if (config.files?.durableObjects !== false) {

package/dist/vite/index.js

@@ -1,3 +1,6 @@
+import {
+  prepareComposedWorkerEntrypoint
+} from "../index-a0fjkq68.js";
 import {
   DEFAULT_DO_PATTERN,
   findFiles
@@ -11,14 +14,15 @@ import {
   writeWranglerConfig
 } from "../index-67qcae0f.js";
 import {
-  loadConfig
+  loadConfig,
+  resolveConfigPath
 } from "../index-hcex3rgh.js";
 import {
   __require
 } from "../index-37x76zdn.js";
 
 // src/vite/plugin.ts
-import { resolve } from "pathe";
+import { isAbsolute, relative, resolve } from "pathe";
 var CONFIG_DIR = ".devflare";
 var VIRTUAL_DO_ENTRY = "virtual:devflare-do-entry";
 var RESOLVED_VIRTUAL_DO_ENTRY = "\x00" + VIRTUAL_DO_ENTRY;
@@ -89,6 +93,89 @@ function createAuxiliaryWorkerConfig(wranglerConfig, discovery) {
     }
   };
 }
+function rebaseMainPathForConfigDir(projectRoot, configDir, mainEntry) {
+  if (!mainEntry) {
+    return mainEntry;
+  }
+  const absoluteMainPath = isAbsolute(mainEntry) ? mainEntry : resolve(projectRoot, mainEntry);
+  return relative(configDir, absoluteMainPath).replace(/\\/g, "/");
+}
+function logDiscoveredDurableObjects(projectRoot, discovery) {
+  if (!discovery || discovery.files.size === 0) {
+    return;
+  }
+  console.log(`[devflare] Discovered ${discovery.files.size} DO file(s):`);
+  for (const [filePath, classes] of discovery.files) {
+    console.log(`  • ${filePath.replace(projectRoot, ".")} → ${classes.join(", ")}`);
+  }
+}
+async function buildPluginContextState(projectRoot, devflareConfig, environment) {
+  const wranglerConfig = compileConfig(devflareConfig, environment);
+  const cloudflareConfig = compileToProgrammaticConfig(devflareConfig, environment);
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(projectRoot, devflareConfig, environment);
+  if (composedMainEntry) {
+    wranglerConfig.main = composedMainEntry;
+    cloudflareConfig.main = composedMainEntry;
+  }
+  let durableObjects = null;
+  let auxiliaryWorkerConfig = null;
+  const doPatternConfig = devflareConfig.files?.durableObjects;
+  const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
+  if (doPatternConfig !== false) {
+    const doWorkerName = `${wranglerConfig.name}-do`;
+    const discovery = await discoverDurableObjects(projectRoot, doPattern, doWorkerName);
+    if (discovery.files.size > 0) {
+      durableObjects = discovery;
+      if (wranglerConfig.durable_objects?.bindings) {
+        for (const binding of wranglerConfig.durable_objects.bindings) {
+          binding.script_name = doWorkerName;
+        }
+      }
+      if (cloudflareConfig.durable_objects) {
+        const doConfig = cloudflareConfig.durable_objects;
+        for (const binding of doConfig.bindings) {
+          binding.script_name = doWorkerName;
+        }
+      }
+      auxiliaryWorkerConfig = createAuxiliaryWorkerConfig(wranglerConfig, discovery);
+    }
+  }
+  return {
+    wranglerConfig,
+    cloudflareConfig,
+    durableObjects,
+    auxiliaryWorkerConfig
+  };
+}
+async function ensureGeneratedConfigDir(projectRoot) {
+  const configDir = resolve(projectRoot, CONFIG_DIR);
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(configDir, { recursive: true });
+  const gitignorePath = resolve(configDir, ".gitignore");
+  try {
+    await fs.access(gitignorePath);
+  } catch {
+    await fs.writeFile(gitignorePath, `*
+`, "utf-8");
+  }
+  return configDir;
+}
+async function writeGeneratedWranglerConfig(projectRoot, wranglerConfig) {
+  const configDir = await ensureGeneratedConfigDir(projectRoot);
+  const wranglerFileConfig = {
+    ...wranglerConfig,
+    ...wranglerConfig.main && {
+      main: rebaseMainPathForConfigDir(projectRoot, configDir, wranglerConfig.main)
+    }
+  };
+  await writeWranglerConfig(configDir, wranglerFileConfig, "wrangler.jsonc");
+}
+async function resolvePluginConfigPath(projectRoot, configPath) {
+  if (configPath) {
+    return isAbsolute(configPath) ? configPath : resolve(projectRoot, configPath);
+  }
+  return await resolveConfigPath(projectRoot) ?? null;
+}
 function devflarePlugin(options = {}) {
   const {
     configPath,
@@ -100,6 +187,7 @@ function devflarePlugin(options = {}) {
   } = options;
   let projectRoot;
   let devflareConfig;
+  let resolvedPluginConfigPath = null;
   return {
     name: "devflare",
     enforce: "pre",
@@ -175,54 +263,22 @@ export default { fetch: () => new Response("No DOs") }`;
     async configResolved(config) {
       projectRoot = config.root;
       pluginContext.projectRoot = projectRoot;
+      resolvedPluginConfigPath = await resolvePluginConfigPath(projectRoot, configPath);
       try {
         devflareConfig = await loadConfig({
           cwd: projectRoot,
           configFile: configPath
         });
-        const wranglerConfig = compileConfig(devflareConfig, environment);
-        pluginContext.wranglerConfig = wranglerConfig;
-        const cloudflareConfig = compileToProgrammaticConfig(devflareConfig, environment);
-        pluginContext.cloudflareConfig = cloudflareConfig;
-        const doPatternConfig = devflareConfig.files?.durableObjects;
-        const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
-        if (doPatternConfig !== false) {
-          const doWorkerName = `${wranglerConfig.name}-do`;
-          const discovery = await discoverDurableObjects(projectRoot, doPattern, doWorkerName);
-          pluginContext.durableObjects = discovery;
-          if (discovery.files.size > 0) {
-            if (wranglerConfig.durable_objects?.bindings) {
-              for (const binding of wranglerConfig.durable_objects.bindings) {
-                binding.script_name = doWorkerName;
-              }
-            }
-            if (cloudflareConfig.durable_objects) {
-              const doConfig = cloudflareConfig.durable_objects;
-              for (const binding of doConfig.bindings) {
-                binding.script_name = doWorkerName;
-              }
-            }
-            pluginContext.auxiliaryWorkerConfig = createAuxiliaryWorkerConfig(wranglerConfig, discovery);
-            console.log(`[devflare] Discovered ${discovery.files.size} DO file(s):`);
-            for (const [filePath, classes] of discovery.files) {
-              console.log(`  • ${filePath.replace(projectRoot, ".")} → ${classes.join(", ")}`);
-            }
-          }
-        }
-        const configDir = resolve(projectRoot, CONFIG_DIR);
-        const fs = await import("node:fs/promises");
-        await fs.mkdir(configDir, { recursive: true });
-        const gitignorePath = resolve(configDir, ".gitignore");
-        try {
-          await fs.access(gitignorePath);
-        } catch {
-          await fs.writeFile(gitignorePath, `*
-`, "utf-8");
-        }
-        await writeWranglerConfig(configDir, wranglerConfig, "wrangler.jsonc");
+        const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment);
+        Object.assign(pluginContext, {
+          projectRoot,
+          ...pluginState
+        });
+        logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
+        await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
         if (config.command === "serve") {
           console.log("[devflare] Config generated to .devflare/wrangler.jsonc");
-          if (pluginContext.auxiliaryWorkerConfig) {
+          if (pluginState.auxiliaryWorkerConfig) {
             console.log("[devflare] ✓ Auxiliary DO worker configured");
           }
         }
@@ -239,8 +295,7 @@ export default { fetch: () => new Response("No DOs") }`;
     configureServer(server) {
       if (!watchConfig)
         return;
-      const configFileName = configPath || "devflare.config.ts";
-      const fullConfigPath = resolve(projectRoot, configFileName);
+      const fullConfigPath = resolvedPluginConfigPath ?? resolve(projectRoot, configPath || "devflare.config.ts");
       server.watcher.add(fullConfigPath);
       server.watcher.on("change", async (changedPath) => {
         if (changedPath === fullConfigPath) {
@@ -250,10 +305,13 @@ export default { fetch: () => new Response("No DOs") }`;
               cwd: projectRoot,
               configFile: configPath
             });
-            const wranglerConfig = compileConfig(devflareConfig, environment);
-            pluginContext.wranglerConfig = wranglerConfig;
-            const cloudflareConfig = compileToProgrammaticConfig(devflareConfig, environment);
-            pluginContext.cloudflareConfig = cloudflareConfig;
+            const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment);
+            Object.assign(pluginContext, {
+              projectRoot,
+              ...pluginState
+            });
+            logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
+            await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
             console.log("[devflare] Config reloaded");
             server.ws.send({
               type: "full-reload",
@@ -302,7 +360,12 @@ async function getCloudflareConfig(options = {}) {
     cwd,
     configFile: options.configPath
   });
-  return compileToProgrammaticConfig(devflareConfig, options.environment);
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig, options.environment);
+  const cloudflareConfig = compileToProgrammaticConfig(devflareConfig, options.environment);
+  if (composedMainEntry) {
+    cloudflareConfig.main = composedMainEntry;
+  }
+  return cloudflareConfig;
 }
 async function getDevflareConfigs(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -310,8 +373,13 @@ async function getDevflareConfigs(options = {}) {
     cwd,
     configFile: options.configPath
   });
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig, options.environment);
   const wranglerConfig = compileConfig(devflareConfig, options.environment);
   const cloudflareConfig = { ...wranglerConfig };
+  if (composedMainEntry) {
+    wranglerConfig.main = composedMainEntry;
+    cloudflareConfig.main = composedMainEntry;
+  }
   const auxiliaryWorkers = [];
   const doPatternConfig = devflareConfig.files?.durableObjects;
   const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;

package/dist/vite/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAA;AAGjE,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,oBAAoB,CAAA;AAW3B,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,cAAc,EAAE,cAAc,GAAG,IAAI,CAAA;IAErC;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAEhD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAEnD;;OAEG;IACH,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC;AAED,MAAM,WAAW,iBAAiB;IACjC,gDAA8C;IAC9C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC5B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAWD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD;AA8FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAmR1E;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE;IAClD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,GAAE;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,gBAAgB,EAAE,qBAAqB,EAAE,CAAA;CACzC,CAAC,CAiCD;AAGD,eAAe,cAAc,CAAA"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAA;AAGjE,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,oBAAoB,CAAA;AAY3B,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,cAAc,EAAE,cAAc,GAAG,IAAI,CAAA;IAErC;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAEhD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAEnD;;OAEG;IACH,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC;AAED,MAAM,WAAW,iBAAiB;IACjC,gDAA8C;IAC9C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC5B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAkBD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD;AAwND;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAuO1E;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE;IAClD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAaxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,GAAE;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,gBAAgB,EAAE,qBAAqB,EAAE,CAAA;CACzC,CAAC,CAsCD;AAGD,eAAe,cAAc,CAAA"}

package/dist/worker-entry/composed-worker.d.ts

@@ -0,0 +1,10 @@
+import type { DevflareConfig } from '../config';
+export interface WorkerSurfacePaths {
+    fetch: string | null;
+    queue: string | null;
+    scheduled: string | null;
+    email: string | null;
+}
+export declare function resolveWorkerSurfacePaths(cwd: string, config: DevflareConfig): Promise<WorkerSurfacePaths>;
+export declare function prepareComposedWorkerEntrypoint(cwd: string, config: DevflareConfig, environment?: string): Promise<string | null>;
+//# sourceMappingURL=composed-worker.d.ts.map

package/dist/worker-entry/composed-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed-worker.d.ts","sourceRoot":"","sources":["../../src/worker-entry/composed-worker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AA8B/C,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACpB;AA8CD,wBAAsB,yBAAyB,CAC9C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAO7B;AAiHD,wBAAsB,+BAA+B,CACpD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8BxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "devflare",
-	"version": "1.0.0-next.6",
+	"version": "1.0.0-next.7",
 	"description": "Devflare is a developer-first toolkit for Cloudflare Workers that sits on top of Miniflare and Wrangler-compatible config",
 	"type": "module",
 	"main": "./dist/index.js",