devflare 1.0.0-next.23 → 1.0.0-next.27

package/dist/index-rjc5z3w6.js

@@ -1,971 +0,0 @@
-import {
-  discoverRoutes
-} from "./index-1p814k7s.js";
-import {
-  DEFAULT_DO_PATTERN,
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-vhqww6tt.js";
-import {
-  compileBuildConfig,
-  compileConfig,
-  compileToProgrammaticConfig,
-  isolateViteBuildOutputPaths,
-  rebaseWranglerConfigPaths,
-  writeWranglerConfig
-} from "./index-zgrqest7.js";
-import {
-  loadConfig,
-  loadResolvedConfig,
-  normalizeDOBinding,
-  resolveConfigForEnvironment,
-  resolveConfigForLocalRuntime,
-  resolveConfigPath
-} from "./index-5p3bgjwr.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 = mode === "build" ? resolveConfigForEnvironment(devflareConfig, environment) : resolveConfigForLocalRuntime(devflareConfig, environment);
-  const compiledWranglerConfig = mode === "build" ? compileBuildConfig(effectiveConfig) : compileConfig(effectiveConfig);
-  const wranglerConfig = mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compiledWranglerConfig) : compiledWranglerConfig;
-  const cloudflareConfig = {
-    ...mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compileToProgrammaticConfig(effectiveConfig, environment, { preserveNamedBindings: true })) : compileToProgrammaticConfig(effectiveConfig, environment)
-  };
-  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-v3gsnybk.js");
-          return transformDurableObject(code, id);
-        }
-      }
-      return null;
-    }
-  };
-}
-async function getCloudflareConfig(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const strategy = options.resolve ?? "offline-local";
-  const devflareConfig = strategy === "remote" ? await loadResolvedConfig({
-    cwd,
-    configFile: options.configPath,
-    environment: options.environment
-  }) : resolveConfigForLocalRuntime(await loadConfig({ cwd, configFile: options.configPath }), 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 strategy = options.resolve ?? "offline-local";
-  const devflareConfig = strategy === "remote" ? await loadResolvedConfig({
-    cwd,
-    configFile: options.configPath,
-    environment: options.environment
-  }) : resolveConfigForLocalRuntime(await loadConfig({ cwd, configFile: options.configPath }), 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 };