devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-ymz3cfab.js

@@ -0,0 +1,968 @@
+import {
+  discoverRoutes
+} from "./index-1p814k7s.js";
+import {
+  DEFAULT_DO_PATTERN,
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses
+} from "./index-pac7wv88.js";
+import {
+  compileConfig,
+  compileToProgrammaticConfig,
+  isolateViteBuildOutputPaths,
+  rebaseWranglerConfigPaths,
+  writeWranglerConfig
+} from "./index-xvk5n96q.js";
+import {
+  loadConfig,
+  loadResolvedConfig,
+  normalizeDOBinding,
+  resolveConfigForEnvironment,
+  resolveConfigForLocalRuntime,
+  resolveConfigPath
+} from "./index-1wn8mjep.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/vite/plugin.ts
+import { isAbsolute, resolve as resolve3 } from "pathe";
+
+// src/worker-entry/composed-worker.ts
+import { dirname, relative, resolve as resolve2 } from "pathe";
+
+// src/worker-entry/surface-paths.ts
+import { 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, surfaceName = "worker") {
+  if (configuredPath === false) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  if (typeof configuredPath === "string" && configuredPath) {
+    const absolutePath = resolve(cwd, configuredPath);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      throw new Error(`Configured ${surfaceName} handler "${configuredPath}" was not found`);
+    }
+  }
+  for (const defaultEntry of defaultEntries) {
+    const absolutePath = resolve(cwd, defaultEntry);
+    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, "fetch"),
+    queue: await resolveWorkerHandlerPath(cwd, config.files?.queue, DEFAULT_QUEUE_ENTRY_FILES, "queue"),
+    scheduled: await resolveWorkerHandlerPath(cwd, config.files?.scheduled, DEFAULT_SCHEDULED_ENTRY_FILES, "scheduled"),
+    email: await resolveWorkerHandlerPath(cwd, config.files?.email, DEFAULT_EMAIL_ENTRY_FILES, "email")
+  };
+}
+function hasWorkerSurfacePaths(surfacePaths) {
+  return Object.values(surfacePaths).some((surfacePath) => typeof surfacePath === "string" && surfacePath.length > 0);
+}
+
+// src/worker-entry/composed-worker.ts
+class CodeBuilder {
+  sections = [];
+  importStatement(specifiers, from) {
+    this.sections.push(`import { ${specifiers.join(", ")} } from '${from}'`);
+    return this;
+  }
+  importNamespace(identifier, from) {
+    this.sections.push(`import * as ${identifier} from '${from}'`);
+    return this;
+  }
+  reExport(names, from) {
+    this.sections.push(`export { ${names.join(", ")} } from '${from}'`);
+    return this;
+  }
+  constDeclaration(name, value) {
+    this.sections.push(`const ${name} = ${value}`);
+    return this;
+  }
+  classDeclaration(body) {
+    this.sections.push(body);
+    return this;
+  }
+  exportDefault(body) {
+    this.sections.push(`export default ${body}`);
+    return this;
+  }
+  raw(text) {
+    this.sections.push(text);
+    return this;
+  }
+  blank() {
+    this.sections.push("");
+    return this;
+  }
+  toString() {
+    return this.sections.join(`
+`);
+  }
+}
+var DEV_ONLY_EMAIL_HOOKS_SOURCE = `
+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' }
+	})
+}
+`;
+function emitDevOnlyEmailHooks(builder, options) {
+  if (!options.enabled) {
+    return;
+  }
+  builder.raw(DEV_ONLY_EMAIL_HOOKS_SOURCE);
+}
+var RESOLVE_HANDLER_DECLARATION = `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
+}`;
+function buildDefaultExportBody(options) {
+  const devOnlyEmailEntry = options.includeDevOnlyHooks ? `const url = new URL(request.url)
+
+				if (
+					request.headers.get('x-devflare-event') === 'email'
+					&& url.pathname === '/_devflare/internal/email'
+				) {
+					return __devflareHandleInternalEmail(request, env, ctx)
+				}
+
+				` : "";
+  return `{
+	...(${options.hasFetchDispatch ? "true" : "false"}
+		? {
+			async fetch(request, env, ctx) {
+				${devOnlyEmailEntry}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)
+				)
+			}
+		}
+		: {})
+}`;
+}
+function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, durableObjectExports = [], routeImports = [], options = {}) {
+  const includeDevOnlyHooks = options.includeDevOnlyHooks ?? options.devInternalEmail === true;
+  const importsBuilder = new CodeBuilder;
+  importsBuilder.importStatement([
+    "createEmailEvent",
+    "createFetchEvent",
+    "createQueueEvent",
+    "createRouteResolve",
+    "createScheduledEvent",
+    "invokeFetchModule",
+    "matchFetchRoute",
+    "runWithEventContext",
+    "setLocalSendEmailBindings"
+  ], "devflare/runtime");
+  const fallbackModules = [
+    { identifier: "__devflareFetchModule", importPath: surfaceImportPaths.fetch },
+    { identifier: "__devflareQueueModule", importPath: surfaceImportPaths.queue },
+    { identifier: "__devflareScheduledModule", importPath: surfaceImportPaths.scheduled },
+    { identifier: "__devflareEmailModule", importPath: surfaceImportPaths.email }
+  ];
+  const fallbacksBuilder = new CodeBuilder;
+  for (const { identifier, importPath } of fallbackModules) {
+    if (importPath) {
+      importsBuilder.importNamespace(identifier, importPath);
+    } else {
+      fallbacksBuilder.constDeclaration(identifier, "{}");
+    }
+  }
+  for (const routeImport of routeImports) {
+    importsBuilder.importNamespace(routeImport.identifier, routeImport.importPath);
+  }
+  const reExportsBuilder = new CodeBuilder;
+  for (const { classNames, importPath } of durableObjectExports) {
+    reExportsBuilder.reExport(classNames, importPath);
+  }
+  const routeManifestEntries = routeImports.map(({ identifier, filePath, routePath, segmentsJson }) => {
+    return `	{ filePath: ${JSON.stringify(filePath)}, routePath: ${JSON.stringify(routePath)}, segments: ${segmentsJson}, module: ${identifier} }`;
+  });
+  const builder = new CodeBuilder;
+  builder.raw(importsBuilder.toString());
+  builder.raw(fallbacksBuilder.toString());
+  builder.raw(reExportsBuilder.toString());
+  builder.blank();
+  builder.raw(`setLocalSendEmailBindings(${JSON.stringify(configuredLocalSendEmailBindings)})`);
+  builder.blank();
+  builder.constDeclaration("__devflareHasFetchModule", surfaceImportPaths.fetch ? "true" : "false");
+  builder.raw(`const __devflareRoutes = [
+${routeManifestEntries.join(`,
+`)}
+]`);
+  builder.constDeclaration("__devflareHasRoutes", "__devflareRoutes.length > 0");
+  builder.blank();
+  builder.raw(RESOLVE_HANDLER_DECLARATION);
+  builder.blank();
+  builder.constDeclaration("__devflareQueueHandler", "__devflareResolveHandler(__devflareQueueModule, 'queue')");
+  builder.constDeclaration("__devflareScheduledHandler", "__devflareResolveHandler(__devflareScheduledModule, 'scheduled')");
+  builder.constDeclaration("__devflareEmailHandler", "__devflareResolveHandler(__devflareEmailModule, 'email')");
+  emitDevOnlyEmailHooks(builder, { enabled: includeDevOnlyHooks });
+  builder.blank();
+  builder.exportDefault(buildDefaultExportBody({
+    hasFetchDispatch: Boolean(surfaceImportPaths.fetch) || routeImports.length > 0 || includeDevOnlyHooks,
+    includeDevOnlyHooks
+  }));
+  builder.raw("");
+  return builder.toString();
+}
+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)
+  }));
+}
+async function createGeneratedDurableObjectExports(entryPath, cwd, config) {
+  if (config.files?.durableObjects === false || !config.bindings?.durableObjects) {
+    return [];
+  }
+  const localClassNames = new Set(Object.values(config.bindings.durableObjects).map((binding) => normalizeDOBinding(binding)).filter((binding) => !binding.scriptName).map((binding) => binding.className));
+  if (localClassNames.size === 0) {
+    return [];
+  }
+  const fs = await import("node:fs/promises");
+  const pattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
+  const matchedFiles = await findFiles(pattern, { cwd });
+  const exports = [];
+  const discoveredClassNames = new Set;
+  for (const filePath of matchedFiles) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findDurableObjectClasses(code).filter((className) => localClassNames.has(className));
+      if (classNames.length === 0) {
+        continue;
+      }
+      for (const className of classNames) {
+        discoveredClassNames.add(className);
+      }
+      exports.push({
+        importPath: toImportSpecifier(entryPath, filePath),
+        filePath,
+        classNames
+      });
+    } catch {
+      continue;
+    }
+  }
+  const missingClassNames = Array.from(localClassNames).filter((className) => !discoveredClassNames.has(className));
+  if (missingClassNames.length > 0) {
+    throw new Error(`Failed to discover local Durable Object class${missingClassNames.length === 1 ? "" : "es"} ${missingClassNames.join(", ")} for worker composition. Ensure files.durableObjects matches the source file pattern for your do.* files.`);
+  }
+  return exports;
+}
+function needsComposedWorkerEntrypoint(cwd, surfacePaths, config, routeDiscovery) {
+  const hasAdditionalWorkerSurfaces = Boolean(surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || routeDiscovery?.routes.length);
+  if (hasAdditionalWorkerSurfaces) {
+    return true;
+  }
+  if (!surfacePaths.fetch) {
+    return false;
+  }
+  const assetsDirectory = config.assets?.directory;
+  if (assetsDirectory) {
+    const generatedAssetsWorkerPath = resolve2(cwd, assetsDirectory, "_worker.js");
+    if (surfacePaths.fetch === generatedAssetsWorkerPath) {
+      return false;
+    }
+  }
+  return Boolean(surfacePaths.fetch);
+}
+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(cwd, surfacePaths, resolvedConfig, routeDiscovery)) {
+    return null;
+  }
+  const fs = await import("node:fs/promises");
+  const entryDir = resolve2(cwd, ".devflare", "worker-entrypoints");
+  const entryPath = resolve2(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 durableObjectExports = await createGeneratedDurableObjectExports(entryPath, cwd, resolvedConfig);
+  const routeImports = createGeneratedRouteModuleImports(entryPath, routeDiscovery);
+  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, durableObjectExports, 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;
+function createPluginState() {
+  return {
+    context: {
+      wranglerConfig: null,
+      cloudflareConfig: null,
+      projectRoot: process.cwd(),
+      auxiliaryWorkerConfig: null,
+      durableObjects: null
+    },
+    projectRoot: process.cwd(),
+    devflareConfig: null,
+    resolvedPluginConfigPath: null
+  };
+}
+var lastPluginContext = createPluginState().context;
+function getPluginContext() {
+  return lastPluginContext;
+}
+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 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, mode = "serve") {
+  const effectiveConfig = resolveConfigForLocalRuntime(devflareConfig, environment);
+  const compiledWranglerConfig = compileConfig(effectiveConfig);
+  const wranglerConfig = mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compiledWranglerConfig) : compiledWranglerConfig;
+  const cloudflareConfig = {
+    ...mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compileToProgrammaticConfig(effectiveConfig)) : compileToProgrammaticConfig(effectiveConfig)
+  };
+  const composedMainEntry = mode === "build" ? null : await prepareComposedWorkerEntrypoint(projectRoot, effectiveConfig, environment);
+  if (composedMainEntry) {
+    wranglerConfig.main = composedMainEntry;
+    cloudflareConfig.main = composedMainEntry;
+  }
+  let durableObjects = null;
+  let auxiliaryWorkerConfig = null;
+  const doPatternConfig = effectiveConfig.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 = resolve3(projectRoot, CONFIG_DIR);
+  const fs = await import("node:fs/promises");
+  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 writeGeneratedWranglerConfig(projectRoot, wranglerConfig) {
+  const configDir = await ensureGeneratedConfigDir(projectRoot);
+  const wranglerFileConfig = rebaseWranglerConfigPaths(projectRoot, configDir, wranglerConfig);
+  await writeWranglerConfig(configDir, wranglerFileConfig, "wrangler.jsonc");
+}
+async function resolvePluginConfigPath(projectRoot, configPath) {
+  if (configPath) {
+    return isAbsolute(configPath) ? configPath : resolve3(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;
+  const state = createPluginState();
+  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 (!state.context.durableObjects) {
+          return `// No Durable Objects configured
+export default { fetch: () => new Response("No DOs") }`;
+        }
+        return generateVirtualDOEntry(state.context.durableObjects);
+      }
+      return null;
+    },
+    async configResolved(config) {
+      state.projectRoot = config.root;
+      state.context.projectRoot = state.projectRoot;
+      state.resolvedPluginConfigPath = await resolvePluginConfigPath(state.projectRoot, configPath);
+      try {
+        state.devflareConfig = await loadConfig({
+          cwd: state.projectRoot,
+          configFile: configPath
+        });
+        const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, config.command === "build" ? "build" : "serve");
+        Object.assign(state.context, {
+          projectRoot: state.projectRoot,
+          ...pluginState
+        });
+        lastPluginContext = state.context;
+        logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
+        await writeGeneratedWranglerConfig(state.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 = state.resolvedPluginConfigPath ?? resolve3(state.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 {
+            state.devflareConfig = await loadConfig({
+              cwd: state.projectRoot,
+              configFile: configPath
+            });
+            const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, "serve");
+            Object.assign(state.context, {
+              projectRoot: state.projectRoot,
+              ...pluginState
+            });
+            lastPluginContext = state.context;
+            logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
+            await writeGeneratedWranglerConfig(state.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-f1v9y4s8.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-4hey8fgy.js");
+          return transformDurableObject(code, id);
+        }
+      }
+      return null;
+    }
+  };
+}
+async function getCloudflareConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const devflareConfig = await loadResolvedConfig({
+    cwd,
+    configFile: options.configPath,
+    environment: options.environment
+  });
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig);
+  const cloudflareConfig = compileToProgrammaticConfig(devflareConfig);
+  if (composedMainEntry) {
+    cloudflareConfig.main = composedMainEntry;
+  }
+  return cloudflareConfig;
+}
+async function getDevflareConfigs(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const devflareConfig = await loadResolvedConfig({
+    cwd,
+    configFile: options.configPath,
+    environment: options.environment
+  });
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig);
+  const wranglerConfig = compileConfig(devflareConfig);
+  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
+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 isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function normalizePluginOptions(pluginOption) {
+  if (typeof pluginOption === "undefined") {
+    return [];
+  }
+  return Array.isArray(pluginOption) ? pluginOption : [pluginOption];
+}
+function removePluginByName(pluginOption, pluginName) {
+  if (Array.isArray(pluginOption)) {
+    const filteredPlugins = pluginOption.map((nestedPlugin) => removePluginByName(nestedPlugin, pluginName)).filter((nestedPlugin) => typeof nestedPlugin !== "undefined");
+    return filteredPlugins.length > 0 ? filteredPlugins : undefined;
+  }
+  if (!pluginOption || typeof pluginOption === "boolean" || isPromiseLike(pluginOption)) {
+    return pluginOption;
+  }
+  return pluginOption.name === pluginName ? undefined : pluginOption;
+}
+function withInjectedDevflarePlugin(config, pluginOptions) {
+  const existingPlugins = normalizePluginOptions(config.plugins).map((pluginOption) => removePluginByName(pluginOption, "devflare")).filter((pluginOption) => typeof pluginOption !== "undefined");
+  return {
+    ...config,
+    plugins: [devflarePlugin(pluginOptions), ...existingPlugins]
+  };
+}
+async function resolveViteUserConfig(configEnv, options = {}) {
+  const { loadConfigFromFile, mergeConfig } = await import("vite");
+  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: resolve4 } = await import("pathe");
+  const configDir = resolve4(cwd, CONFIG_DIR2);
+  await fs.mkdir(configDir, { recursive: true });
+  const gitignorePath = resolve4(configDir, ".gitignore");
+  try {
+    await fs.access(gitignorePath);
+  } catch {
+    await fs.writeFile(gitignorePath, `*
+`, "utf-8");
+  }
+  return configDir;
+}
+async function resolveDevflarePackageRoot(currentFilePath) {
+  const fs = await import("node:fs/promises");
+  const { dirname: dirname2, resolve: resolve4 } = await import("pathe");
+  let currentDir = dirname2(currentFilePath);
+  while (true) {
+    const packageJsonPath = resolve4(currentDir, "package.json");
+    try {
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+      if (packageJson.name === "devflare") {
+        return currentDir;
+      }
+    } catch {}
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  throw new Error("Could not resolve the devflare package root for generated Vite config imports.");
+}
+async function resolveGeneratedViteImportPath(configDir) {
+  const { fileURLToPath } = await import("node:url");
+  const { extname, normalize, relative: relative3, resolve: resolve4 } = await import("pathe");
+  const currentFilePath = normalize(fileURLToPath(import.meta.url));
+  const currentExtension = extname(currentFilePath);
+  const packageRoot = await resolveDevflarePackageRoot(currentFilePath);
+  const viteEntryPath = currentFilePath.includes("/dist/") ? resolve4(packageRoot, "dist/vite/index.js") : resolve4(packageRoot, `src/vite/index${currentExtension}`);
+  const relativeImportPath = relative3(configDir, viteEntryPath);
+  return relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
+}
+async function writeGeneratedViteConfig(options) {
+  const fs = await import("node:fs/promises");
+  const { resolve: resolve4 } = await import("pathe");
+  const configDir = await ensureGeneratedConfigDir2(options.cwd);
+  const generatedConfigPath = resolve4(configDir, GENERATED_VITE_CONFIG_FILENAME);
+  const viteImportPath = await resolveGeneratedViteImportPath(configDir);
+  const content = `import { defineConfig } from 'vite'
+import { resolveViteUserConfig } from ${JSON.stringify(viteImportPath)}
+
+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 { DEFAULT_FETCH_ENTRY_FILES, DEFAULT_QUEUE_ENTRY_FILES, DEFAULT_SCHEDULED_ENTRY_FILES, DEFAULT_EMAIL_ENTRY_FILES, resolveWorkerSurfacePaths, hasWorkerSurfacePaths, prepareComposedWorkerEntrypoint, getPluginContext, devflarePlugin, getCloudflareConfig, getDevflareConfigs, hasInlineViteConfig, resolveEffectiveViteProject, resolveViteUserConfig, writeGeneratedViteConfig };