devflare 1.0.0-next.15 → 1.0.0-next.16

package/dist/index-72mve6vh.js

@@ -0,0 +1,168 @@
+import {
+  apiDelete,
+  apiGetAll,
+  apiPost,
+  apiPut
+} from "./index-0w826dsr.js";
+
+// src/cloudflare/tokens.ts
+var MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS = 300;
+var DEVFLARE_MANAGED_TOKEN_PREFIX = "devflare-";
+var ACCOUNT_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account";
+var ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN = /^Account API Tokens\b/i;
+var DEVFLARE_MANAGED_TOKEN_NAME_PATTERN = /^devflare-/i;
+var DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS = [
+  /^Account Analytics Read$/i,
+  /^Account Settings Read$/i,
+  /^Analytics Read$/i,
+  /^AI /i,
+  /^Browser Rendering /i,
+  /^D1 (Metadata Read|Read|Write)$/i,
+  /^Email (Routing|Sending) /i,
+  /^Hyperdrive /i,
+  /^Queues /i,
+  /^Vectorize /i,
+  /^Workers /i
+];
+function dedupePermissionGroups(permissionGroups) {
+  const seenIds = new Set;
+  return permissionGroups.filter((permissionGroup) => {
+    if (seenIds.has(permissionGroup.id)) {
+      return false;
+    }
+    seenIds.add(permissionGroup.id);
+    return true;
+  });
+}
+function dedupePermissionGroupIds(permissionGroupIds) {
+  return Array.from(new Set(permissionGroupIds.map((id) => id.trim()).filter(Boolean)));
+}
+function excludeAccountApiTokensPermissionGroups(permissionGroups) {
+  return permissionGroups.filter((permissionGroup) => {
+    return !ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN.test(permissionGroup.name);
+  });
+}
+function keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups) {
+  return permissionGroups.filter((permissionGroup) => {
+    return permissionGroup.scopes.some((scope) => scope.trim() === ACCOUNT_OWNED_TOKEN_SCOPE);
+  });
+}
+function selectReusableAccountOwnedTokenPermissionGroups(permissionGroups) {
+  return dedupePermissionGroups(excludeAccountApiTokensPermissionGroups(keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups)));
+}
+function parseOptionalDate(value) {
+  if (!value) {
+    return;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function mapAccountOwnedAPITokenPolicy(policy) {
+  return {
+    id: policy.id,
+    effect: policy.effect,
+    permissionGroups: policy.permission_groups?.map((permissionGroup) => ({
+      id: permissionGroup.id,
+      name: permissionGroup.name
+    }))
+  };
+}
+function mapAccountOwnedAPIToken(token) {
+  return {
+    id: token.id,
+    name: token.name ?? token.id,
+    status: token.status,
+    value: token.value,
+    issuedOn: parseOptionalDate(token.issued_on),
+    modifiedOn: parseOptionalDate(token.modified_on),
+    lastUsedOn: parseOptionalDate(token.last_used_on),
+    policies: token.policies?.map(mapAccountOwnedAPITokenPolicy)
+  };
+}
+function isDevflareManagedTokenName(name) {
+  return DEVFLARE_MANAGED_TOKEN_NAME_PATTERN.test(name.trim());
+}
+function normalizeDevflareTokenName(name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw new Error("Devflare token name cannot be empty");
+  }
+  const suffix = isDevflareManagedTokenName(trimmedName) ? trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "") : trimmedName;
+  if (!suffix) {
+    throw new Error("Devflare token name cannot be empty");
+  }
+  return `${DEVFLARE_MANAGED_TOKEN_PREFIX}${suffix}`;
+}
+function stripDevflareTokenNamePrefix(name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    return trimmedName;
+  }
+  const strippedName = trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "");
+  return strippedName || trimmedName;
+}
+function filterDevflareManagedTokens(tokens) {
+  return tokens.filter((token) => isDevflareManagedTokenName(token.name));
+}
+function selectDevflarePermissionGroups(permissionGroups) {
+  const selectedPermissionGroups = dedupePermissionGroups(selectReusableAccountOwnedTokenPermissionGroups(permissionGroups).filter((permissionGroup) => {
+    return DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS.some((pattern) => {
+      return pattern.test(permissionGroup.name);
+    });
+  }));
+  if (selectedPermissionGroups.length === 0) {
+    throw new Error("Could not map the available Cloudflare permission groups to a Devflare token policy.");
+  }
+  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
+  }
+  return selectedPermissionGroups;
+}
+function selectAllReusablePermissionGroups(permissionGroups) {
+  const selectedPermissionGroups = selectReusableAccountOwnedTokenPermissionGroups(permissionGroups);
+  if (selectedPermissionGroups.length === 0) {
+    throw new Error("Could not find any reusable account-scoped Cloudflare permission groups for this Devflare token.");
+  }
+  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
+  }
+  return selectedPermissionGroups;
+}
+async function listAccountTokenPermissionGroups(accountId, options) {
+  const permissionGroups = await apiGetAll(`/accounts/${accountId}/tokens/permission_groups`, options);
+  return dedupePermissionGroups(permissionGroups);
+}
+async function listAccountOwnedAPITokens(accountId, options) {
+  const tokens = await apiGetAll(`/accounts/${accountId}/tokens`, options);
+  return tokens.map(mapAccountOwnedAPIToken);
+}
+async function deleteAccountOwnedAPIToken(accountId, tokenId, options) {
+  return apiDelete(`/accounts/${accountId}/tokens/${tokenId}`, options);
+}
+async function rollAccountOwnedAPITokenValue(accountId, tokenId, options) {
+  return apiPut(`/accounts/${accountId}/tokens/${tokenId}/value`, {}, options);
+}
+async function createAccountOwnedAPIToken(accountId, options, clientOptions) {
+  const permissionGroupIds = dedupePermissionGroupIds(options.permissionGroupIds);
+  if (permissionGroupIds.length === 0) {
+    throw new Error("Cannot create a Devflare token without any permission groups");
+  }
+  if (permissionGroupIds.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
+    throw new Error(`Cannot create a Devflare token with more than ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS} permission groups.`);
+  }
+  const createdToken = await apiPost(`/accounts/${accountId}/tokens`, {
+    name: options.name,
+    policies: [
+      {
+        effect: "allow",
+        resources: {
+          [`com.cloudflare.api.account.${accountId}`]: "*"
+        },
+        permission_groups: permissionGroupIds.map((id) => ({ id }))
+      }
+    ]
+  }, clientOptions);
+  return mapAccountOwnedAPIToken(createdToken);
+}
+
+export { normalizeDevflareTokenName, stripDevflareTokenNamePrefix, filterDevflareManagedTokens, selectDevflarePermissionGroups, selectAllReusablePermissionGroups, listAccountTokenPermissionGroups, listAccountOwnedAPITokens, deleteAccountOwnedAPIToken, rollAccountOwnedAPITokenValue, createAccountOwnedAPIToken };

package/dist/{index-zvgc3e0c.js → index-74198nxd.js}

@@ -11,25 +11,31 @@ import {
 import {
   compileConfig,
   compileToProgrammaticConfig,
+  isolateViteBuildOutputPaths,
+  rebaseWranglerConfigPaths,
   writeWranglerConfig
-} from "./index-5s1bz1e0.js";
+} from "./index-pnbs1b8k.js";
 import {
   loadConfig,
   loadResolvedConfig,
+  normalizeDOBinding,
   resolveConfigForEnvironment,
   resolveConfigForLocalRuntime,
   resolveConfigPath,
   resolveConfigResources
-} from "./index-tksw7gpy.js";
+} from "./index-6psz1h4c.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 +60,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 +87,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 +114,65 @@ 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 getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, routeImports = [], options = {}) {
+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 = {}, 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 +266,8 @@ ${importLines.join(`
 `)}
 ${moduleFallbackLines.join(`
 `)}
+${durableObjectExportLines.join(`
+`)}
 
 setLocalSendEmailBindings(${localSendEmailBindings})
 
@@ -306,12 +374,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 +387,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";
 }
 
@@ -395,13 +464,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;
@@ -413,9 +475,12 @@ 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 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 +516,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 +530,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;
 }
@@ -598,7 +658,7 @@ export default { fetch: () => new Response("No DOs") }`;
     configureServer(server) {
       if (!watchConfig)
         return;
-      const fullConfigPath = resolvedPluginConfigPath ?? resolve2(projectRoot, configPath || "devflare.config.ts");
+      const fullConfigPath = resolvedPluginConfigPath ?? resolve3(projectRoot, configPath || "devflare.config.ts");
       server.watcher.add(fullConfigPath);
       server.watcher.on("change", async (changedPath) => {
         if (changedPath === fullConfigPath) {
@@ -704,7 +764,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 +779,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 +828,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 +840,46 @@ async function ensureGeneratedConfigDir2(cwd) {
   }
   return configDir;
 }
+async function resolveDevflarePackageRoot(currentFilePath) {
+  const fs = await import("node:fs/promises");
+  const { dirname: dirname2 } = await import("node:path");
+  const { 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 { extname, sep } = await import("node:path");
+  const { fileURLToPath } = await import("node:url");
+  const { relative: relative3, resolve: resolve4 } = await import("pathe");
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentExtension = extname(currentFilePath);
+  const packageRoot = await resolveDevflarePackageRoot(currentFilePath);
+  const viteEntryPath = currentFilePath.includes(`${sep}dist${sep}`) ? resolve4(packageRoot, "dist/src/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 +894,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 };

package/dist/{index-7bq4xq84.js → index-7g8zyws4.js}

@@ -1,15 +1,16 @@
 import {
-  apiGet,
-  apiPost,
+  DEVFLARE_KV_NAMESPACE_TITLE,
   getEffectiveAccountId,
-  getPrimaryAccount,
+  getOrCreateNamedKVNamespace,
+  getPrimaryAccount
+} from "./index-xk9djfjp.js";
+import {
   isAuthenticated,
   kvGet,
   kvPut
-} from "./index-xdq9ery1.js";
+} from "./index-0w826dsr.js";
 
 // src/cloudflare/usage.ts
-var DEVFLARE_KV_NAMESPACE_TITLE = "devflare-usage";
 var USAGE_KEY_PREFIX = "usage:";
 var LIMITS_KEY = "limits";
 var DEFAULT_LIMITS = {
@@ -19,13 +20,7 @@ var DEFAULT_LIMITS = {
   enabled: true
 };
 async function getOrCreateUsageNamespace(accountId) {
-  const namespaces = await apiGet(`/accounts/${accountId}/storage/kv/namespaces`);
-  const existing = namespaces.find((ns) => ns.title === DEVFLARE_KV_NAMESPACE_TITLE);
-  if (existing) {
-    return existing.id;
-  }
-  const created = await apiPost(`/accounts/${accountId}/storage/kv/namespaces`, { title: DEVFLARE_KV_NAMESPACE_TITLE });
-  return created.id;
+  return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
 }
 function getTodayDate() {
   return new Date().toISOString().split("T")[0];