devflare 1.0.0-next.11 → 1.0.0-next.13

package/dist/index-zbvmtcn2.js

@@ -0,0 +1,795 @@
+import {
+  discoverRoutes
+} from "./index-1p814k7s.js";
+import {
+  DEFAULT_DO_PATTERN,
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses
+} from "./index-9wt9x09k.js";
+import {
+  compileConfig,
+  compileToProgrammaticConfig,
+  resolveConfigForEnvironment,
+  writeWranglerConfig
+} from "./index-rfhx0yd5.js";
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./index-wyf3s77s.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/vite/plugin.ts
+import { isAbsolute, relative as relative2, resolve as resolve2 } from "pathe";
+
+// src/worker-entry/composed-worker.ts
+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"
+];
+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 createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
+  if (!routeDiscovery) {
+    return [];
+  }
+  return routeDiscovery.routes.map((route, index) => ({
+    identifier: `__devflareRouteModule${index}`,
+    importPath: toImportSpecifier(entryPath, route.absolutePath),
+    filePath: route.filePath,
+    routePath: route.routePath,
+    segmentsJson: JSON.stringify(route.segments)
+  }));
+}
+function needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery) {
+  return Boolean(surfacePaths.fetch || surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || routeDiscovery?.routes.length);
+}
+function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, routeImports = [], options = {}) {
+  const importLines = [`import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`];
+  const moduleFallbackLines = [];
+  const localSendEmailBindings = JSON.stringify(configuredLocalSendEmailBindings);
+  const routeManifestEntries = routeImports.map(({ identifier, filePath, routePath, segmentsJson }) => {
+    return `	{ filePath: ${JSON.stringify(filePath)}, routePath: ${JSON.stringify(routePath)}, segments: ${segmentsJson}, module: ${identifier} }`;
+  });
+  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);
+  for (const routeImport of routeImports) {
+    importLines.push(`import * as ${routeImport.identifier} from '${routeImport.importPath}'`);
+  }
+  const includeDevInternalEmail = options.devInternalEmail === true;
+  const devInternalEmailHelpers = includeDevInternalEmail ? `
+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()
+		}
+	}
+
+	const __devflareEvent = createEmailEvent(emailMessage, env, ctx)
+
+	await runWithEventContext(
+		__devflareEvent,
+		() => __devflareEmailHandler(__devflareEvent, env, ctx)
+	)
+
+	return new Response(JSON.stringify({ ok: true, from, to }), {
+		headers: { 'Content-Type': 'application/json' }
+	})
+}
+` : "";
+  return `
+${importLines.join(`
+`)}
+${moduleFallbackLines.join(`
+`)}
+
+setLocalSendEmailBindings(${localSendEmailBindings})
+
+const __devflareHasFetchModule = ${surfaceImportPaths.fetch ? "true" : "false"}
+const __devflareRoutes = [
+${routeManifestEntries.join(`,
+`)}
+]
+const __devflareHasRoutes = __devflareRoutes.length > 0
+
+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 __devflareQueueHandler = __devflareResolveHandler(__devflareQueueModule, 'queue')
+const __devflareScheduledHandler = __devflareResolveHandler(__devflareScheduledModule, 'scheduled')
+const __devflareEmailHandler = __devflareResolveHandler(__devflareEmailModule, 'email')
+${devInternalEmailHelpers}
+
+export default {
+	...(${surfaceImportPaths.fetch || routeImports.length > 0 || includeDevInternalEmail ? "true" : "false"}
+		? {
+			async fetch(request, env, ctx) {
+				${includeDevInternalEmail ? `const url = new URL(request.url)
+
+				if (
+					request.headers.get('x-devflare-event') === 'email'
+					&& url.pathname === '/_devflare/internal/email'
+				) {
+					return __devflareHandleInternalEmail(request, env, ctx)
+				}
+
+				` : ""}const __devflareInitialRouteMatch = __devflareHasRoutes ? matchFetchRoute(__devflareRoutes, request) : null
+				const __devflareEvent = createFetchEvent(request, env, ctx, {
+					params: __devflareInitialRouteMatch?.params ?? {}
+				})
+				return runWithEventContext(
+					__devflareEvent,
+					() => invokeFetchModule(
+						__devflareFetchModule,
+						__devflareEvent,
+						__devflareHasRoutes
+							? createRouteResolve(__devflareRoutes, __devflareEvent)
+							: undefined
+					)
+				)
+			}
+		}
+		: {}),
+	...(__devflareQueueHandler
+		? {
+			async queue(batch, env, ctx) {
+				const __devflareEvent = createQueueEvent(batch, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareQueueHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareScheduledHandler
+		? {
+			async scheduled(controller, env, ctx) {
+				const __devflareEvent = createScheduledEvent(controller, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareScheduledHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {}),
+	...(__devflareEmailHandler
+		? {
+			async email(message, env, ctx) {
+				const __devflareEvent = createEmailEvent(message, env, ctx)
+				return runWithEventContext(
+					__devflareEvent,
+					() => __devflareEmailHandler(__devflareEvent, env, ctx)
+				)
+			}
+		}
+		: {})
+}
+`.trimStart();
+}
+async function prepareComposedWorkerEntrypoint(cwd, config, environment, options = {}) {
+  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);
+  const routeDiscovery = await discoverRoutes(cwd, resolvedConfig);
+  if (!needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery)) {
+    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
+  };
+  const routeImports = createGeneratedRouteModuleImports(entryPath, routeDiscovery);
+  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, routeImports, options));
+  return ".devflare/worker-entrypoints/main.ts";
+}
+
+// src/vite/plugin.ts
+var CONFIG_DIR = ".devflare";
+var VIRTUAL_DO_ENTRY = "virtual:devflare-do-entry";
+var RESOLVED_VIRTUAL_DO_ENTRY = "\x00" + VIRTUAL_DO_ENTRY;
+var pluginContext = {
+  wranglerConfig: null,
+  cloudflareConfig: null,
+  projectRoot: process.cwd(),
+  auxiliaryWorkerConfig: null,
+  durableObjects: null
+};
+function getPluginContext() {
+  return pluginContext;
+}
+async function discoverDurableObjects(projectRoot, pattern, workerName) {
+  const files = new Map;
+  const matchedFiles = await findFiles(pattern, { cwd: projectRoot });
+  const fs = await import("node:fs/promises");
+  for (const filePath of matchedFiles) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findDurableObjectClasses(code);
+      if (classNames.length > 0) {
+        files.set(filePath, classNames);
+      }
+    } catch (error) {
+      console.warn(`[devflare] Failed to read DO file: ${filePath}`, error);
+    }
+  }
+  return { files, workerName };
+}
+function generateVirtualDOEntry(discovery) {
+  const lines = [
+    "// Auto-generated by devflare — DO entry module",
+    "// Re-exports all Durable Object classes discovered from files.durableObjects pattern",
+    ""
+  ];
+  for (const [filePath, classNames] of discovery.files) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    lines.push(`export { ${classNames.join(", ")} } from '${normalizedPath}'`);
+  }
+  lines.push("");
+  lines.push("// Default fetch handler for DO worker");
+  lines.push("export default {");
+  lines.push("\tasync fetch(request: Request): Promise<Response> {");
+  lines.push('\t\treturn new Response("Devflare DO Worker", { status: 200 })');
+  lines.push("\t}");
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function createAuxiliaryWorkerConfig(wranglerConfig, discovery) {
+  const doBindings = wranglerConfig.durable_objects?.bindings?.map((binding) => ({
+    name: binding.name,
+    class_name: binding.class_name
+  })) ?? [];
+  return {
+    config: {
+      name: discovery.workerName,
+      main: VIRTUAL_DO_ENTRY,
+      compatibility_date: wranglerConfig.compatibility_date,
+      compatibility_flags: wranglerConfig.compatibility_flags,
+      durable_objects: { bindings: doBindings },
+      migrations: wranglerConfig.migrations,
+      kv_namespaces: wranglerConfig.kv_namespaces,
+      d1_databases: wranglerConfig.d1_databases,
+      r2_buckets: wranglerConfig.r2_buckets,
+      browser: wranglerConfig.browser
+    }
+  };
+}
+function rebaseMainPathForConfigDir(projectRoot, configDir, mainEntry) {
+  if (!mainEntry) {
+    return mainEntry;
+  }
+  const absoluteMainPath = isAbsolute(mainEntry) ? mainEntry : resolve2(projectRoot, mainEntry);
+  return relative2(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 = resolve2(projectRoot, CONFIG_DIR);
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(configDir, { recursive: true });
+  const gitignorePath = resolve2(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 : resolve2(projectRoot, configPath);
+  }
+  return await resolveConfigPath(projectRoot) ?? null;
+}
+function devflarePlugin(options = {}) {
+  const {
+    configPath,
+    environment,
+    doTransforms = true,
+    watchConfig = true,
+    bridgePort = process.env.DEVFLARE_BRIDGE_PORT ? parseInt(process.env.DEVFLARE_BRIDGE_PORT, 10) : undefined,
+    wsProxyPatterns = []
+  } = options;
+  let projectRoot;
+  let devflareConfig;
+  let resolvedPluginConfigPath = null;
+  return {
+    name: "devflare",
+    enforce: "pre",
+    async config(config, { command }) {
+      const cwd = config.root ?? process.cwd();
+      const returnConfig = {};
+      let lfConfig = null;
+      try {
+        lfConfig = await loadConfig({
+          cwd,
+          configFile: configPath
+        });
+      } catch (error) {
+        if (command === "build") {
+          console.warn("[devflare] Could not load config:", error);
+        }
+      }
+      if (lfConfig) {
+        const workerNameValue = lfConfig.name ?? "unknown";
+        returnConfig.define = {
+          ...config.define ?? {},
+          __DEVFLARE_WORKER_NAME__: JSON.stringify(workerNameValue)
+        };
+      }
+      if (command === "serve" && process.env.DEVFLARE_DEV && lfConfig) {
+        const port = bridgePort ?? 8787;
+        const patterns = [...wsProxyPatterns];
+        if (lfConfig.wsRoutes && lfConfig.wsRoutes.length > 0) {
+          for (const route of lfConfig.wsRoutes) {
+            if (!patterns.includes(route.pattern)) {
+              patterns.push(route.pattern);
+            }
+          }
+        }
+        const proxyConfig = {};
+        for (const pattern of patterns) {
+          proxyConfig[pattern] = {
+            target: `http://127.0.0.1:${port}`,
+            changeOrigin: true,
+            ws: true,
+            configure: (proxy) => {
+              proxy.on("error", (err) => {
+                console.error(`[devflare] Proxy error: ${err.message}`);
+              });
+            }
+          };
+        }
+        if (Object.keys(proxyConfig).length > 0) {
+          console.log(`[devflare] WebSocket proxy configured for: ${patterns.join(", ")}`);
+          returnConfig.server = {
+            proxy: proxyConfig
+          };
+        }
+      }
+      return Object.keys(returnConfig).length > 0 ? returnConfig : undefined;
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_DO_ENTRY) {
+        return RESOLVED_VIRTUAL_DO_ENTRY;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id === RESOLVED_VIRTUAL_DO_ENTRY) {
+        if (!pluginContext.durableObjects) {
+          return `// No Durable Objects configured
+export default { fetch: () => new Response("No DOs") }`;
+        }
+        return generateVirtualDOEntry(pluginContext.durableObjects);
+      }
+      return null;
+    },
+    async configResolved(config) {
+      projectRoot = config.root;
+      pluginContext.projectRoot = projectRoot;
+      resolvedPluginConfigPath = await resolvePluginConfigPath(projectRoot, configPath);
+      try {
+        devflareConfig = await loadConfig({
+          cwd: projectRoot,
+          configFile: configPath
+        });
+        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 (pluginState.auxiliaryWorkerConfig) {
+            console.log("[devflare] ✓ Auxiliary DO worker configured");
+          }
+        }
+        if (config.command === "build") {
+          console.log(`[devflare] Generated ${CONFIG_DIR}/wrangler.jsonc`);
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error("[devflare] Config error:", error.message);
+        }
+        throw error;
+      }
+    },
+    configureServer(server) {
+      if (!watchConfig)
+        return;
+      const fullConfigPath = resolvedPluginConfigPath ?? resolve2(projectRoot, configPath || "devflare.config.ts");
+      server.watcher.add(fullConfigPath);
+      server.watcher.on("change", async (changedPath) => {
+        if (changedPath === fullConfigPath) {
+          console.log("[devflare] Config changed, reloading...");
+          try {
+            devflareConfig = await loadConfig({
+              cwd: projectRoot,
+              configFile: configPath
+            });
+            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",
+              path: "*"
+            });
+          } catch (error) {
+            console.error("[devflare] Failed to reload config:", error);
+          }
+        }
+      });
+    },
+    async transform(code, id) {
+      if (id.includes("node_modules"))
+        return null;
+      if (!id.endsWith(".ts") && !id.endsWith(".tsx") && !id.endsWith(".js")) {
+        return null;
+      }
+      if (id.endsWith("worker.ts") || id.endsWith("worker.js")) {
+        const {
+          shouldTransformWorker,
+          transformWorkerEntrypoint
+        } = await import("./worker-entrypoint-c259fmfs.js");
+        if (shouldTransformWorker(code, id)) {
+          const result = transformWorkerEntrypoint(code, id);
+          if (result) {
+            return {
+              code: result.code,
+              map: result.map
+            };
+          }
+        }
+      }
+      if (doTransforms) {
+        if (code.includes("DurableObject") || code.includes("@durableObject")) {
+          const { transformDurableObject } = await import("./durable-object-yt8v1dyn.js");
+          return transformDurableObject(code, id);
+        }
+      }
+      return null;
+    }
+  };
+}
+async function getCloudflareConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const devflareConfig = await loadConfig({
+    cwd,
+    configFile: options.configPath
+  });
+  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();
+  const devflareConfig = await loadConfig({
+    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;
+  if (doPatternConfig !== false) {
+    const doWorkerName = `${wranglerConfig.name}-do`;
+    const discovery = await discoverDurableObjects(cwd, doPattern, doWorkerName);
+    if (discovery.files.size > 0) {
+      if (cloudflareConfig.durable_objects) {
+        const doConfig = cloudflareConfig.durable_objects;
+        for (const binding of doConfig.bindings) {
+          binding.script_name = doWorkerName;
+        }
+      }
+      auxiliaryWorkers.push(createAuxiliaryWorkerConfig(wranglerConfig, discovery));
+    }
+  }
+  return { cloudflareConfig, auxiliaryWorkers };
+}
+// src/vite/config-file.ts
+import { loadConfigFromFile, mergeConfig } from "vite";
+var CONFIG_DIR2 = ".devflare";
+var GENERATED_VITE_CONFIG_FILENAME = "vite.config.mjs";
+function hasInlineViteConfig(viteConfig) {
+  return Boolean(viteConfig && Object.keys(viteConfig).length > 0);
+}
+function resolveEffectiveViteProject(detection, config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const hasDevflareConfig = hasInlineViteConfig(resolvedConfig.vite);
+  return {
+    ...detection,
+    hasDevflareViteConfig: hasDevflareConfig,
+    shouldStartVite: detection.shouldStartVite || hasDevflareConfig,
+    wantsViteIntegration: detection.wantsViteIntegration || hasDevflareConfig
+  };
+}
+function collectPlugins(pluginOption, plugins = []) {
+  if (Array.isArray(pluginOption)) {
+    for (const nestedPlugin of pluginOption) {
+      collectPlugins(nestedPlugin, plugins);
+    }
+    return plugins;
+  }
+  if (!pluginOption || typeof pluginOption === "boolean") {
+    return plugins;
+  }
+  if (typeof pluginOption.then === "function") {
+    return plugins;
+  }
+  plugins.push(pluginOption);
+  return plugins;
+}
+function withInjectedDevflarePlugin(config, pluginOptions) {
+  const existingPlugins = collectPlugins(config.plugins).filter((plugin) => plugin.name !== "devflare");
+  return {
+    ...config,
+    plugins: [devflarePlugin(pluginOptions), ...existingPlugins]
+  };
+}
+async function resolveViteUserConfig(configEnv, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const devflareConfig = await loadConfig({
+    cwd,
+    configFile: options.configPath
+  });
+  const resolvedDevflareConfig = resolveConfigForEnvironment(devflareConfig, options.environment);
+  const inlineViteConfig = resolvedDevflareConfig.vite ?? {};
+  const localConfig = options.localConfigPath ? (await loadConfigFromFile(configEnv, options.localConfigPath, cwd))?.config ?? {} : {};
+  const mergedConfig = mergeConfig(localConfig, inlineViteConfig);
+  const normalizedConfig = mergedConfig.root ? mergedConfig : {
+    ...mergedConfig,
+    root: cwd
+  };
+  return withInjectedDevflarePlugin(normalizedConfig, {
+    configPath: options.configPath,
+    environment: options.environment,
+    bridgePort: options.bridgePort
+  });
+}
+async function ensureGeneratedConfigDir2(cwd) {
+  const fs = await import("node:fs/promises");
+  const { resolve: resolve3 } = await import("pathe");
+  const configDir = resolve3(cwd, CONFIG_DIR2);
+  await fs.mkdir(configDir, { recursive: true });
+  const gitignorePath = resolve3(configDir, ".gitignore");
+  try {
+    await fs.access(gitignorePath);
+  } catch {
+    await fs.writeFile(gitignorePath, `*
+`, "utf-8");
+  }
+  return configDir;
+}
+async function writeGeneratedViteConfig(options) {
+  const fs = await import("node:fs/promises");
+  const { resolve: resolve3 } = await import("pathe");
+  const configDir = await ensureGeneratedConfigDir2(options.cwd);
+  const generatedConfigPath = resolve3(configDir, GENERATED_VITE_CONFIG_FILENAME);
+  const content = `import { defineConfig } from 'vite'
+import { resolveViteUserConfig } from 'devflare/vite'
+
+export default defineConfig(async (env) => {
+	return await resolveViteUserConfig(env, {
+		cwd: ${JSON.stringify(options.cwd)},
+		configPath: ${JSON.stringify(options.configPath)},
+		environment: ${JSON.stringify(options.environment)},
+		localConfigPath: ${JSON.stringify(options.localConfigPath)},
+		bridgePort: ${JSON.stringify(options.bridgePort)}
+	})
+})
+`;
+  await fs.writeFile(generatedConfigPath, content, "utf-8");
+  return generatedConfigPath;
+}
+export { prepareComposedWorkerEntrypoint, getPluginContext, devflarePlugin, getCloudflareConfig, getDevflareConfigs, hasInlineViteConfig, resolveEffectiveViteProject, resolveViteUserConfig, writeGeneratedViteConfig };