devflare 1.0.0-next.15 → 1.0.0-next.17

package/dist/{index-zvgc3e0c.js → index-p97s12vf.js}

@@ -11,25 +11,30 @@ import {
 import {
   compileConfig,
   compileToProgrammaticConfig,
+  isolateViteBuildOutputPaths,
+  rebaseWranglerConfigPaths,
   writeWranglerConfig
-} from "./index-5s1bz1e0.js";
+} from "./index-n8k8chde.js";
 import {
   loadConfig,
   loadResolvedConfig,
+  normalizeDOBinding,
   resolveConfigForEnvironment,
   resolveConfigForLocalRuntime,
-  resolveConfigPath,
-  resolveConfigResources
-} from "./index-tksw7gpy.js";
+  resolveConfigPath
+} from "./index-dmbdj6va.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/vite/plugin.ts
-import { isAbsolute, relative as relative2, resolve as resolve2 } from "pathe";
+import { isAbsolute, resolve as resolve3 } from "pathe";
 
 // src/worker-entry/composed-worker.ts
-import { dirname, relative, resolve } from "pathe";
+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",
@@ -54,20 +59,22 @@ var DEFAULT_EMAIL_ENTRY_FILES = [
   "src/email.mts",
   "src/email.mjs"
 ];
-async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
+async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries, surfaceName = "worker") {
   if (configuredPath === false) {
     return null;
   }
   const fs = await import("node:fs/promises");
-  const candidates = new Set;
   if (typeof configuredPath === "string" && configuredPath) {
-    candidates.add(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) {
-    candidates.add(defaultEntry);
-  }
-  for (const candidate of candidates) {
-    const absolutePath = resolve(cwd, candidate);
+    const absolutePath = resolve(cwd, defaultEntry);
     try {
       await fs.access(absolutePath);
       return absolutePath;
@@ -79,12 +86,17 @@ async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries) {
 }
 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)
+    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
 function toImportSpecifier(fromFilePath, toFilePath) {
   const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
   return specifier.startsWith(".") ? specifier : `./${specifier}`;
@@ -101,12 +113,67 @@ function createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
     segmentsJson: JSON.stringify(route.segments)
   }));
 }
-function needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery) {
-  return Boolean(surfacePaths.fetch || surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || routeDiscovery?.routes.length);
+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);
 }
-function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, routeImports = [], options = {}) {
-  const importLines = [`import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`];
+function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, durableObjectExports = [], routeImports = [], options = {}) {
+  const importLines = [
+    `import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`
+  ];
   const moduleFallbackLines = [];
+  const durableObjectExportLines = durableObjectExports.map(({ classNames, importPath }) => `export { ${classNames.join(", ")} } from '${importPath}'`);
   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} }`;
@@ -200,6 +267,8 @@ ${importLines.join(`
 `)}
 ${moduleFallbackLines.join(`
 `)}
+${durableObjectExportLines.join(`
+`)}
 
 setLocalSendEmailBindings(${localSendEmailBindings})
 
@@ -306,12 +375,12 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
   }
   const surfacePaths = await resolveWorkerSurfacePaths(cwd, resolvedConfig);
   const routeDiscovery = await discoverRoutes(cwd, resolvedConfig);
-  if (!needsComposedWorkerEntrypoint(surfacePaths, routeDiscovery)) {
+  if (!needsComposedWorkerEntrypoint(cwd, surfacePaths, resolvedConfig, routeDiscovery)) {
     return null;
   }
   const fs = await import("node:fs/promises");
-  const entryDir = resolve(cwd, ".devflare", "worker-entrypoints");
-  const entryPath = resolve(entryDir, "main.ts");
+  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,
@@ -319,8 +388,9 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
     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 ?? {}, routeImports, options));
+  await fs.writeFile(entryPath, getComposedWorkerEntrypointSource(surfaceImportPaths, resolvedConfig.bindings?.sendEmail ?? {}, durableObjectExports, routeImports, options));
   return ".devflare/worker-entrypoints/main.ts";
 }
 
@@ -328,15 +398,23 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
 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 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 pluginContext;
+  return lastPluginContext;
 }
 async function discoverDurableObjects(projectRoot, pattern, workerName) {
   const files = new Map;
@@ -395,13 +473,6 @@ function createAuxiliaryWorkerConfig(wranglerConfig, discovery) {
     }
   };
 }
-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;
@@ -412,10 +483,13 @@ function logDiscoveredDurableObjects(projectRoot, discovery) {
   }
 }
 async function buildPluginContextState(projectRoot, devflareConfig, environment, mode = "serve") {
-  const effectiveConfig = mode === "build" ? await resolveConfigResources(devflareConfig, { environment }) : resolveConfigForLocalRuntime(devflareConfig, environment);
-  const wranglerConfig = compileConfig(effectiveConfig);
-  const cloudflareConfig = compileToProgrammaticConfig(effectiveConfig);
-  const composedMainEntry = await prepareComposedWorkerEntrypoint(projectRoot, effectiveConfig);
+  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;
@@ -451,10 +525,10 @@ async function buildPluginContextState(projectRoot, devflareConfig, environment,
   };
 }
 async function ensureGeneratedConfigDir(projectRoot) {
-  const configDir = resolve2(projectRoot, CONFIG_DIR);
+  const configDir = resolve3(projectRoot, CONFIG_DIR);
   const fs = await import("node:fs/promises");
   await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve2(configDir, ".gitignore");
+  const gitignorePath = resolve3(configDir, ".gitignore");
   try {
     await fs.access(gitignorePath);
   } catch {
@@ -465,17 +539,12 @@ async function ensureGeneratedConfigDir(projectRoot) {
 }
 async function writeGeneratedWranglerConfig(projectRoot, wranglerConfig) {
   const configDir = await ensureGeneratedConfigDir(projectRoot);
-  const wranglerFileConfig = {
-    ...wranglerConfig,
-    ...wranglerConfig.main && {
-      main: rebaseMainPathForConfigDir(projectRoot, configDir, wranglerConfig.main)
-    }
-  };
+  const wranglerFileConfig = rebaseWranglerConfigPaths(projectRoot, configDir, wranglerConfig);
   await writeWranglerConfig(configDir, wranglerFileConfig, "wrangler.jsonc");
 }
 async function resolvePluginConfigPath(projectRoot, configPath) {
   if (configPath) {
-    return isAbsolute(configPath) ? configPath : resolve2(projectRoot, configPath);
+    return isAbsolute(configPath) ? configPath : resolve3(projectRoot, configPath);
   }
   return await resolveConfigPath(projectRoot) ?? null;
 }
@@ -488,9 +557,7 @@ function devflarePlugin(options = {}) {
     bridgePort = process.env.DEVFLARE_BRIDGE_PORT ? parseInt(process.env.DEVFLARE_BRIDGE_PORT, 10) : undefined,
     wsProxyPatterns = []
   } = options;
-  let projectRoot;
-  let devflareConfig;
-  let resolvedPluginConfigPath = null;
+  const state = createPluginState();
   return {
     name: "devflare",
     enforce: "pre",
@@ -555,30 +622,31 @@ function devflarePlugin(options = {}) {
     },
     async load(id) {
       if (id === RESOLVED_VIRTUAL_DO_ENTRY) {
-        if (!pluginContext.durableObjects) {
+        if (!state.context.durableObjects) {
           return `// No Durable Objects configured
 export default { fetch: () => new Response("No DOs") }`;
         }
-        return generateVirtualDOEntry(pluginContext.durableObjects);
+        return generateVirtualDOEntry(state.context.durableObjects);
       }
       return null;
     },
     async configResolved(config) {
-      projectRoot = config.root;
-      pluginContext.projectRoot = projectRoot;
-      resolvedPluginConfigPath = await resolvePluginConfigPath(projectRoot, configPath);
+      state.projectRoot = config.root;
+      state.context.projectRoot = state.projectRoot;
+      state.resolvedPluginConfigPath = await resolvePluginConfigPath(state.projectRoot, configPath);
       try {
-        devflareConfig = await loadConfig({
-          cwd: projectRoot,
+        state.devflareConfig = await loadConfig({
+          cwd: state.projectRoot,
           configFile: configPath
         });
-        const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment, config.command === "build" ? "build" : "serve");
-        Object.assign(pluginContext, {
-          projectRoot,
+        const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, config.command === "build" ? "build" : "serve");
+        Object.assign(state.context, {
+          projectRoot: state.projectRoot,
           ...pluginState
         });
-        logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
-        await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
+        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) {
@@ -598,23 +666,24 @@ export default { fetch: () => new Response("No DOs") }`;
     configureServer(server) {
       if (!watchConfig)
         return;
-      const fullConfigPath = resolvedPluginConfigPath ?? resolve2(projectRoot, configPath || "devflare.config.ts");
+      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 {
-            devflareConfig = await loadConfig({
-              cwd: projectRoot,
+            state.devflareConfig = await loadConfig({
+              cwd: state.projectRoot,
               configFile: configPath
             });
-            const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment, "serve");
-            Object.assign(pluginContext, {
-              projectRoot,
+            const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, "serve");
+            Object.assign(state.context, {
+              projectRoot: state.projectRoot,
               ...pluginState
             });
-            logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
-            await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
+            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",
@@ -704,7 +773,6 @@ async function getDevflareConfigs(options = {}) {
   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) {
@@ -720,30 +788,34 @@ function resolveEffectiveViteProject(detection, config, environment) {
     wantsViteIntegration: detection.wantsViteIntegration || hasDevflareConfig
   };
 }
-function collectPlugins(pluginOption, plugins = []) {
-  if (Array.isArray(pluginOption)) {
-    for (const nestedPlugin of pluginOption) {
-      collectPlugins(nestedPlugin, plugins);
-    }
-    return plugins;
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function normalizePluginOptions(pluginOption) {
+  if (typeof pluginOption === "undefined") {
+    return [];
   }
-  if (!pluginOption || typeof pluginOption === "boolean") {
-    return plugins;
+  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 (typeof pluginOption.then === "function") {
-    return plugins;
+  if (!pluginOption || typeof pluginOption === "boolean" || isPromiseLike(pluginOption)) {
+    return pluginOption;
   }
-  plugins.push(pluginOption);
-  return plugins;
+  return pluginOption.name === pluginName ? undefined : pluginOption;
 }
 function withInjectedDevflarePlugin(config, pluginOptions) {
-  const existingPlugins = collectPlugins(config.plugins).filter((plugin) => plugin.name !== "devflare");
+  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,
@@ -765,10 +837,10 @@ async function resolveViteUserConfig(configEnv, options = {}) {
 }
 async function ensureGeneratedConfigDir2(cwd) {
   const fs = await import("node:fs/promises");
-  const { resolve: resolve3 } = await import("pathe");
-  const configDir = resolve3(cwd, CONFIG_DIR2);
+  const { resolve: resolve4 } = await import("pathe");
+  const configDir = resolve4(cwd, CONFIG_DIR2);
   await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve3(configDir, ".gitignore");
+  const gitignorePath = resolve4(configDir, ".gitignore");
   try {
     await fs.access(gitignorePath);
   } catch {
@@ -777,13 +849,44 @@ async function ensureGeneratedConfigDir2(cwd) {
   }
   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: resolve3 } = await import("pathe");
+  const { resolve: resolve4 } = await import("pathe");
   const configDir = await ensureGeneratedConfigDir2(options.cwd);
-  const generatedConfigPath = resolve3(configDir, GENERATED_VITE_CONFIG_FILENAME);
+  const generatedConfigPath = resolve4(configDir, GENERATED_VITE_CONFIG_FILENAME);
+  const viteImportPath = await resolveGeneratedViteImportPath(configDir);
   const content = `import { defineConfig } from 'vite'
-import { resolveViteUserConfig } from 'devflare/vite'
+import { resolveViteUserConfig } from ${JSON.stringify(viteImportPath)}
 
 export default defineConfig(async (env) => {
 	return await resolveViteUserConfig(env, {
@@ -798,4 +901,4 @@ export default defineConfig(async (env) => {
   await fs.writeFile(generatedConfigPath, content, "utf-8");
   return generatedConfigPath;
 }
-export { prepareComposedWorkerEntrypoint, getPluginContext, devflarePlugin, getCloudflareConfig, getDevflareConfigs, hasInlineViteConfig, resolveEffectiveViteProject, resolveViteUserConfig, writeGeneratedViteConfig };
+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 };