devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/index-cv4cvrxe.js

@@ -1,2046 +0,0 @@
-import {
-  discoverEntrypointsSync,
-  resolvePackageSpecifier
-} from "./index-3cpzsr47.js";
-import {
-  DEFAULT_DO_PATTERN,
-  findFiles,
-  findFilesSync
-} from "./index-5dkjffqz.js";
-import {
-  compileBuildConfig,
-  compileConfig,
-  compileToProgrammaticConfig,
-  isolateViteBuildOutputPaths,
-  rebaseWranglerConfigPaths,
-  writeWranglerConfig
-} from "./index-mek9msfv.js";
-import {
-  configSchema,
-  getLocalD1DatabaseIdentifier,
-  getLocalKVNamespaceIdentifier,
-  loadConfig,
-  normalizeArtifactsBinding,
-  normalizeDOBinding,
-  normalizeDispatchNamespaceBinding,
-  normalizeHyperdriveBinding,
-  normalizeImagesBinding,
-  normalizeMediaBinding,
-  normalizeMtlsCertificateBinding,
-  normalizePipelineBinding,
-  normalizeSecretsStoreBinding,
-  normalizeWorkflowBinding,
-  resolveConfigEnvVars,
-  resolveConfigForEnvironment,
-  resolveConfigPath,
-  resolveResources
-} from "./index-x8s9rwfh.js";
-import {
-  SUPPORTED_WORKER_EXTENSIONS,
-  transformWorkerEntrypoint
-} from "./index-7m557715.js";
-import {
-  findDurableObjectClasses
-} from "./index-4mmpccrb.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-// src/vite/plugin.ts
-import { dirname as dirname3, resolve as resolve6 } from "pathe";
-
-// src/vite/plugin-config-hook.ts
-async function tryLoadDevflareConfig(cwd, configPath, command) {
-  try {
-    return await loadConfig({ cwd, configFile: configPath });
-  } catch (error) {
-    if (command === "build") {
-      console.warn("[devflare] Could not load config:", error);
-    }
-    return null;
-  }
-}
-function buildWorkerNameDefine(lfConfig, existing) {
-  const workerNameValue = lfConfig.name ?? "unknown";
-  return {
-    ...existing,
-    __DEVFLARE_WORKER_NAME__: JSON.stringify(workerNameValue)
-  };
-}
-function buildWebSocketProxyConfig(lfConfig, bridgePort, wsProxyPatterns) {
-  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);
-      }
-    }
-  }
-  if (patterns.length === 0)
-    return null;
-  const proxyConfig = {};
-  for (const pattern of patterns) {
-    proxyConfig[pattern] = {
-      target: `http://127.0.0.1:${bridgePort}`,
-      changeOrigin: true,
-      ws: true,
-      configure: (proxy) => {
-        proxy.on("error", (err) => {
-          console.error(`[devflare] Proxy error: ${err.message}`);
-        });
-      }
-    };
-  }
-  if (Object.keys(proxyConfig).length === 0)
-    return null;
-  console.log(`[devflare] WebSocket proxy configured for: ${patterns.join(", ")}`);
-  return proxyConfig;
-}
-async function buildPluginConfigHookResult(cwd, options, command, existingDefine) {
-  const lfConfig = await tryLoadDevflareConfig(cwd, options.configPath, command);
-  const returnConfig = {};
-  if (lfConfig) {
-    returnConfig.define = buildWorkerNameDefine(lfConfig, existingDefine);
-  }
-  if (command === "serve" && process.env.DEVFLARE_DEV && lfConfig) {
-    const port = options.bridgePort ?? 8787;
-    const proxyConfig = buildWebSocketProxyConfig(lfConfig, port, options.wsProxyPatterns);
-    if (proxyConfig) {
-      returnConfig.server = { proxy: proxyConfig };
-    }
-  }
-  return Object.keys(returnConfig).length > 0 ? returnConfig : undefined;
-}
-
-// src/vite/plugin-context.ts
-import { isAbsolute, relative as relative3, resolve as resolve5 } from "pathe";
-
-// src/test/resolve-service-bindings.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-
-// src/dev-server/miniflare-bindings.ts
-function buildQueueProducers(bindings) {
-  if (!bindings.queues?.producers) {
-    return;
-  }
-  const producers = {};
-  for (const [bindingName, queueName] of Object.entries(bindings.queues.producers)) {
-    producers[bindingName] = { queueName };
-  }
-  return producers;
-}
-function buildQueueConsumers(bindings) {
-  if (!bindings.queues?.consumers || bindings.queues.consumers.length === 0) {
-    return;
-  }
-  const consumers = {};
-  for (const consumer of bindings.queues.consumers) {
-    consumers[consumer.queue] = {
-      ...consumer.maxBatchSize !== undefined && { maxBatchSize: consumer.maxBatchSize },
-      ...consumer.maxBatchTimeout !== undefined && { maxBatchTimeout: consumer.maxBatchTimeout },
-      ...consumer.maxRetries !== undefined && { maxRetries: consumer.maxRetries },
-      ...consumer.deadLetterQueue && { deadLetterQueue: consumer.deadLetterQueue },
-      ...consumer.maxConcurrency !== undefined && { maxConcurrency: consumer.maxConcurrency },
-      ...consumer.retryDelay !== undefined && { retryDelay: consumer.retryDelay }
-    };
-  }
-  return consumers;
-}
-function buildRateLimitsConfig(bindings) {
-  if (!bindings.rateLimits) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.rateLimits).map(([name, binding]) => [
-    name,
-    {
-      simple: {
-        limit: binding.simple.limit,
-        period: binding.simple.period
-      }
-    }
-  ]));
-}
-function buildVersionMetadataConfig(bindings) {
-  return bindings.versionMetadata?.binding;
-}
-function buildWorkerLoadersConfig(bindings) {
-  if (!bindings.workerLoaders) {
-    return;
-  }
-  return Object.fromEntries(Object.keys(bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
-}
-function buildMtlsCertificatesConfig(bindings) {
-  if (!bindings.mtlsCertificates) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.mtlsCertificates).map(([bindingName, binding]) => {
-    const normalized = normalizeMtlsCertificateBinding(binding);
-    return [
-      bindingName,
-      {
-        certificate_id: normalized.certificateId
-      }
-    ];
-  }));
-}
-function buildDispatchNamespacesConfig(bindings) {
-  if (!bindings.dispatchNamespaces) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.dispatchNamespaces).map(([bindingName, binding]) => {
-    const normalized = normalizeDispatchNamespaceBinding(binding);
-    return [
-      bindingName,
-      {
-        namespace: normalized.namespace
-      }
-    ];
-  }));
-}
-function buildWorkflowsConfig(bindings) {
-  if (!bindings.workflows) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.workflows).map(([bindingName, binding]) => {
-    const normalized = normalizeWorkflowBinding(binding);
-    return [
-      bindingName,
-      {
-        name: normalized.name,
-        className: normalized.className,
-        ...normalized.scriptName && { scriptName: normalized.scriptName },
-        ...normalized.limits && { stepLimit: normalized.limits.steps }
-      }
-    ];
-  }));
-}
-function buildPipelinesConfig(bindings) {
-  if (!bindings.pipelines) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.pipelines).map(([bindingName, binding]) => {
-    const normalized = normalizePipelineBinding(binding);
-    return [
-      bindingName,
-      typeof binding === "string" ? normalized.pipeline : { pipeline: normalized.pipeline }
-    ];
-  }));
-}
-function getHyperdriveLocalConnectionString(bindingName, binding) {
-  const cloudflareEnvName = `CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
-  const wranglerEnvName = `WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
-  const envValue = process.env[cloudflareEnvName] ?? process.env[wranglerEnvName];
-  if (envValue?.trim()) {
-    return envValue;
-  }
-  const normalized = normalizeHyperdriveBinding(binding);
-  return normalized.localConnectionString;
-}
-function buildHyperdrivesConfig(bindings) {
-  if (!bindings.hyperdrive) {
-    return;
-  }
-  const hyperdrives = Object.fromEntries(Object.entries(bindings.hyperdrive).map(([bindingName, binding]) => {
-    const localConnectionString = getHyperdriveLocalConnectionString(bindingName, binding);
-    return localConnectionString ? [bindingName, localConnectionString] : null;
-  }).filter((entry) => entry !== null));
-  return Object.keys(hyperdrives).length > 0 ? hyperdrives : undefined;
-}
-function buildImagesConfig(bindings) {
-  if (!bindings.images) {
-    return;
-  }
-  const [entry] = Object.entries(bindings.images);
-  if (!entry) {
-    return;
-  }
-  const [bindingName, binding] = entry;
-  const normalized = normalizeImagesBinding(bindingName, binding);
-  return {
-    binding: normalized.binding
-  };
-}
-function buildMediaConfig(bindings) {
-  if (!bindings.media) {
-    return;
-  }
-  const [entry] = Object.entries(bindings.media);
-  if (!entry) {
-    return;
-  }
-  const [bindingName, binding] = entry;
-  const normalized = normalizeMediaBinding(bindingName, binding);
-  return {
-    binding: normalized.binding
-  };
-}
-function buildArtifactsConfig(bindings) {
-  if (!bindings.artifacts) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.artifacts).map(([bindingName, binding]) => {
-    const normalized = normalizeArtifactsBinding(binding);
-    return [
-      bindingName,
-      {
-        namespace: normalized.namespace
-      }
-    ];
-  }));
-}
-function buildAiSearchNamespacesConfig(bindings) {
-  if (!bindings.aiSearchNamespaces) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.aiSearchNamespaces).map(([bindingName, binding]) => [
-    bindingName,
-    {
-      namespace: binding.namespace
-    }
-  ]));
-}
-function buildAiSearchInstancesConfig(bindings) {
-  if (!bindings.aiSearch) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings.aiSearch).map(([bindingName, binding]) => [
-    bindingName,
-    {
-      instance_name: binding.instanceName
-    }
-  ]));
-}
-function buildSecretsStoreConfig(bindings, defaultSecretsStoreId, excludedBindingNames = new Set) {
-  if (!bindings.secretsStore) {
-    return;
-  }
-  const entries = Object.entries(bindings.secretsStore).flatMap(([bindingName, binding]) => {
-    if (excludedBindingNames.has(bindingName)) {
-      return [];
-    }
-    const normalized = normalizeSecretsStoreBinding(binding, defaultSecretsStoreId, bindingName);
-    return [
-      [
-        bindingName,
-        {
-          store_id: normalized.storeId,
-          secret_name: normalized.secretName
-        }
-      ]
-    ];
-  });
-  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function buildSendEmailConfig(bindings) {
-  if (!bindings.sendEmail) {
-    return;
-  }
-  return {
-    send_email: Object.entries(bindings.sendEmail).map(([name, binding]) => ({
-      name,
-      ...binding.destinationAddress && {
-        destination_address: binding.destinationAddress
-      },
-      ...binding.allowedDestinationAddresses && {
-        allowed_destination_addresses: binding.allowedDestinationAddresses
-      },
-      ...binding.allowedSenderAddresses && {
-        allowed_sender_addresses: binding.allowedSenderAddresses
-      }
-    }))
-  };
-}
-
-// src/test/resolve-service-bindings.ts
-function getBunRuntime() {
-  const g = globalThis;
-  if (typeof g.Bun === "object" && g.Bun !== null) {
-    return g.Bun;
-  }
-  return;
-}
-function discoverDOFilesSync(dir, pattern = DEFAULT_DO_PATTERN) {
-  const classToPath = new Map;
-  try {
-    const files = findFilesSync(pattern, { cwd: dir });
-    for (const filePath of files) {
-      try {
-        const code = readFileSync(filePath, "utf-8");
-        const classNames = findDurableObjectClasses(code);
-        for (const className of classNames) {
-          if (!classToPath.has(className)) {
-            classToPath.set(className, filePath);
-          }
-        }
-      } catch {}
-    }
-  } catch {}
-  return classToPath;
-}
-var bundleCache = new Map;
-function findDefaultServiceWorkerEntrypoint(refConfigDir) {
-  for (const candidate of ["worker.ts", "worker.js", "src/worker.ts", "src/worker.js"]) {
-    const absolutePath = resolve(refConfigDir, candidate);
-    if (existsSync(absolutePath)) {
-      return absolutePath;
-    }
-  }
-  return null;
-}
-function buildRawServiceBindings(services) {
-  if (!services || Object.keys(services).length === 0) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(services).map(([bindingName, binding]) => [
-    bindingName,
-    {
-      name: binding.service,
-      ...binding.entrypoint && { entrypoint: binding.entrypoint }
-    }
-  ]));
-}
-function buildReferencedWorkerRuntimeConfig(config) {
-  const bindings = config.bindings ?? {};
-  const queueProducers = buildQueueProducers(bindings);
-  const queueConsumers = buildQueueConsumers(bindings);
-  const rateLimits = buildRateLimitsConfig(bindings);
-  const versionMetadata = buildVersionMetadataConfig(bindings);
-  const workerLoaders = buildWorkerLoadersConfig(bindings);
-  const mtlsCertificates = buildMtlsCertificatesConfig(bindings);
-  const dispatchNamespaces = buildDispatchNamespacesConfig(bindings);
-  const workflows = buildWorkflowsConfig(bindings);
-  const pipelines = buildPipelinesConfig(bindings);
-  const hyperdrives = buildHyperdrivesConfig(bindings);
-  const media = buildMediaConfig(bindings);
-  const artifacts = buildArtifactsConfig(bindings);
-  const aiSearchNamespaces = buildAiSearchNamespacesConfig(bindings);
-  const aiSearchInstances = buildAiSearchInstancesConfig(bindings);
-  const secretsStoreSecrets = buildSecretsStoreConfig(bindings, config.secretsStoreId);
-  const email = buildSendEmailConfig(bindings);
-  const serviceBindings = buildRawServiceBindings(bindings.services);
-  return {
-    ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags },
-    ...config.vars && { bindings: config.vars },
-    ...bindings.kv && {
-      kvNamespaces: Object.fromEntries(Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => [
-        bindingName,
-        getLocalKVNamespaceIdentifier(bindingConfig)
-      ]))
-    },
-    ...bindings.r2 && { r2Buckets: bindings.r2 },
-    ...bindings.d1 && {
-      d1Databases: Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => [
-        bindingName,
-        getLocalD1DatabaseIdentifier(bindingConfig)
-      ]))
-    },
-    ...queueProducers && { queueProducers },
-    ...queueConsumers && { queueConsumers },
-    ...rateLimits && { ratelimits: rateLimits },
-    ...versionMetadata && { versionMetadata },
-    ...workerLoaders && { workerLoaders },
-    ...mtlsCertificates && { mtlsCertificates },
-    ...dispatchNamespaces && { dispatchNamespaces },
-    ...workflows && { workflows },
-    ...pipelines && { pipelines },
-    ...hyperdrives && { hyperdrives },
-    ...media && { media },
-    ...artifacts && { artifacts },
-    ...aiSearchNamespaces && { aiSearchNamespaces },
-    ...aiSearchInstances && { aiSearchInstances },
-    ...secretsStoreSecrets && { secretsStoreSecrets },
-    ...email && { email },
-    ...serviceBindings && { serviceBindings }
-  };
-}
-function normalizeReferencedConfig(config) {
-  return configSchema.parse(config);
-}
-function resolveReferencedConfigDir(ref, parentConfigDir) {
-  const configPath = ref.configPath;
-  if (!configPath || configPath === "<resolved>") {
-    return null;
-  }
-  return dirname(resolvePackageSpecifier(configPath, parentConfigDir));
-}
-async function resolveReferencedLocalDurableObjects(config, configDir, workerName, serviceBindings = {}) {
-  const doPattern = config.files?.durableObjects;
-  const dosConfig = config.bindings?.durableObjects;
-  if (typeof doPattern !== "string" || !dosConfig || Object.keys(dosConfig).length === 0) {
-    return { workers: [], bindings: {} };
-  }
-  const discoveredDOs = discoverDOFilesSync(configDir, doPattern);
-  const doClasses = [];
-  for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
-    const doConfig = normalizeDOBinding(rawDoConfig);
-    if (doConfig.kind !== "local") {
-      continue;
-    }
-    const scriptPath = discoveredDOs.get(doConfig.className);
-    if (!scriptPath) {
-      console.warn(`[devflare] DO "${bindingName}" (class: ${doConfig.className}) not found in files.durableObjects for "${workerName}"`);
-      continue;
-    }
-    doClasses.push({ bindingName, className: doConfig.className, scriptPath });
-  }
-  if (doClasses.length === 0) {
-    return { workers: [], bindings: {} };
-  }
-  const doWorkerName = `${workerName}-durable-objects`;
-  const script = await bundleDOClasses(doClasses, doWorkerName);
-  if (!script) {
-    return { workers: [], bindings: {} };
-  }
-  const durableObjects = Object.fromEntries(doClasses.map((do_) => [do_.bindingName, do_.className]));
-  const runtimeConfig = buildReferencedWorkerRuntimeConfig(config);
-  const doRuntimeConfig = { ...runtimeConfig };
-  delete doRuntimeConfig.queueConsumers;
-  const mergedServiceBindings = {
-    ...runtimeConfig.serviceBindings ?? {},
-    ...serviceBindings
-  };
-  return {
-    workers: [
-      {
-        name: doWorkerName,
-        script,
-        modules: true,
-        compatibilityDate: config.compatibilityDate,
-        ...doRuntimeConfig,
-        ...Object.keys(mergedServiceBindings).length > 0 && {
-          serviceBindings: mergedServiceBindings
-        },
-        durableObjects
-      }
-    ],
-    bindings: Object.fromEntries(doClasses.map((do_) => [
-      do_.bindingName,
-      {
-        className: do_.className,
-        scriptName: doWorkerName
-      }
-    ]))
-  };
-}
-async function resolveServiceBindings(config, configDir, seenWorkers = new Set) {
-  const services = config.bindings?.services;
-  if (!services) {
-    return { workers: [], primaryServiceBindings: {} };
-  }
-  const workersByName = new Map;
-  const primaryServiceBindings = {};
-  for (const [bindingName, binding] of Object.entries(services)) {
-    const workerBinding = binding;
-    const ref = workerBinding.__ref;
-    if (ref) {
-      if ("__import" in ref && typeof ref.__import === "function") {
-        await ref.resolve();
-      }
-      const workerName = ref.name;
-      const entrypoint = workerBinding.entrypoint;
-      if (!workersByName.has(workerName) && !seenWorkers.has(workerName)) {
-        const refConfig = normalizeReferencedConfig(ref.config);
-        const worker = await resolveRefWorker(ref, entrypoint, configDir, refConfig);
-        if (worker) {
-          const refConfigDir = resolveReferencedConfigDir(ref, configDir);
-          if (ref.config && refConfigDir) {
-            const nested = await resolveServiceBindings(refConfig, refConfigDir, new Set([...seenWorkers, workerName]));
-            worker.serviceBindings = {
-              ...worker.serviceBindings ?? {},
-              ...nested.primaryServiceBindings
-            };
-            for (const nestedWorker of nested.workers) {
-              if (!workersByName.has(nestedWorker.name)) {
-                workersByName.set(nestedWorker.name, nestedWorker);
-              }
-            }
-            const localDOs = await resolveReferencedLocalDurableObjects(refConfig, refConfigDir, workerName, nested.primaryServiceBindings);
-            worker.durableObjects = {
-              ...worker.durableObjects ?? {},
-              ...localDOs.bindings
-            };
-            for (const doWorker of localDOs.workers) {
-              if (!workersByName.has(doWorker.name)) {
-                workersByName.set(doWorker.name, doWorker);
-              }
-            }
-          }
-          workersByName.set(workerName, worker);
-        }
-      }
-      primaryServiceBindings[bindingName] = {
-        name: workerName,
-        ...entrypoint && { entrypoint }
-      };
-    } else {
-      primaryServiceBindings[bindingName] = {
-        name: workerBinding.service,
-        ...workerBinding.entrypoint && { entrypoint: workerBinding.entrypoint }
-      };
-    }
-  }
-  return {
-    workers: [...workersByName.values()],
-    primaryServiceBindings
-  };
-}
-async function resolveRefWorker(ref, _entrypoint, parentConfigDir, resolvedConfig) {
-  const config = resolvedConfig ?? normalizeReferencedConfig(ref.config);
-  if (!config)
-    return null;
-  const refConfigDir = resolveReferencedConfigDir(ref, parentConfigDir);
-  if (!refConfigDir) {
-    console.warn(`[devflare] Cannot resolve worker "${ref.name}" - configPath not available`);
-    return null;
-  }
-  const entrypoints = [];
-  const workerEntrypointPath = findDefaultServiceWorkerEntrypoint(refConfigDir);
-  if (workerEntrypointPath) {
-    entrypoints.push({
-      path: workerEntrypointPath,
-      className: "Worker",
-      isWorkerTs: true
-    });
-  }
-  if (config.files?.entrypoints !== false) {
-    const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir, typeof config.files?.entrypoints === "string" ? config.files.entrypoints : undefined);
-    for (const ep of discoveredEntrypoints) {
-      entrypoints.push({
-        path: ep.filePath,
-        className: ep.className,
-        isWorkerTs: false
-      });
-    }
-  }
-  if (entrypoints.length === 0) {
-    console.warn(`[devflare] Worker "${ref.name}" has no entry points`);
-    return null;
-  }
-  const script = await bundleAllEntrypoints(entrypoints, ref.name);
-  if (!script)
-    return null;
-  return {
-    name: ref.name,
-    script,
-    modules: true,
-    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
-    ...buildReferencedWorkerRuntimeConfig(config)
-  };
-}
-async function bundleAllEntrypoints(entrypoints, workerName) {
-  const cacheKey = entrypoints.map((ep) => `${ep.path}::${ep.className}`).join("|");
-  const cached = bundleCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn(`[devflare] Cannot bundle service worker "${workerName}" — the Bun runtime is required to bundle worker scripts, ` + "but this process is not running under Bun. The service binding will be left unresolved. " + "Run your tests with `bun test` (or the devflare test runner) to enable multi-worker service bindings.");
-    return null;
-  }
-  try {
-    const { readFileSync: readFileSync2, writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = [];
-    const exports = [];
-    let defaultExportClass = null;
-    for (let i = 0;i < entrypoints.length; i++) {
-      const ep = entrypoints[i];
-      const sourceCode = readFileSync2(ep.path, "utf-8");
-      if (ep.isWorkerTs) {
-        const result = transformWorkerEntrypoint(sourceCode, ep.path, {
-          className: ep.className,
-          injectContext: false
-        });
-        if (result) {
-          const tempDir2 = join(dirname(ep.path), ".devflare");
-          mkdirSync(tempDir2, { recursive: true });
-          const tempPath = join(tempDir2, `__${ep.className}_${i}.ts`);
-          writeFileSync(tempPath, result.code);
-          imports.push(`import { ${ep.className} } from '${tempPath.replace(/\\/g, "/")}'`);
-          exports.push(ep.className);
-          if (!defaultExportClass) {
-            defaultExportClass = ep.className;
-          }
-        }
-      } else {
-        imports.push(`import { ${ep.className} } from '${ep.path.replace(/\\/g, "/")}'`);
-        exports.push(ep.className);
-      }
-    }
-    const defaultExport = defaultExportClass ? `
-export default ${defaultExportClass}` : "";
-    const entryCode = `
-${imports.join(`
-`)}
-export { ${exports.join(", ")} }${defaultExport}
-`;
-    const tempDir = join(dirname(entrypoints[0].path), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling worker "${workerName}":`, error);
-    return null;
-  }
-}
-async function bundleDOClasses(doClasses, workerName) {
-  const cacheKey = `do:${doClasses.map((d) => `${d.scriptPath}::${d.className}`).join("|")}`;
-  const cached = bundleCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const bun = getBunRuntime();
-  if (!bun) {
-    console.warn(`[devflare] Cannot bundle Durable Object worker "${workerName}" — the Bun runtime is required to bundle DO classes, ` + "but this process is not running under Bun. The Durable Object binding will be left unresolved. Run your tests with `bun test` (or the devflare test runner) to enable cross-worker Durable Objects.");
-    return null;
-  }
-  try {
-    const { writeFileSync, mkdirSync, unlinkSync } = await import("fs");
-    const imports = doClasses.map((d) => `import { ${d.className} } from '${d.scriptPath.replace(/\\/g, "/")}'`).join(`
-`);
-    const exports = doClasses.map((d) => d.className).join(", ");
-    const entryCode = `
-${imports}
-
-// Re-export DO classes for Miniflare binding
-export { ${exports} }
-
-// Default export with fetch handler
-export default {
-	async fetch(request, env) {
-		return new Response('DO Worker: ${workerName}')
-	}
-}
-`;
-    const tempDir = join(dirname(doClasses[0].scriptPath), ".devflare");
-    mkdirSync(tempDir, { recursive: true });
-    const entryPath = join(tempDir, `__do_entry_${workerName}.ts`);
-    writeFileSync(entryPath, entryCode);
-    try {
-      const result = await bun.build({
-        entrypoints: [entryPath],
-        target: "browser",
-        format: "esm",
-        minify: false,
-        external: ["cloudflare:workers", "cloudflare:*"]
-      });
-      if (!result.success) {
-        console.warn(`[devflare] Failed to bundle DO worker "${workerName}": ${result.logs.join(`
-`)}`);
-        return null;
-      }
-      const bundledCode = await result.outputs[0].text();
-      bundleCache.set(cacheKey, bundledCode);
-      return bundledCode;
-    } finally {
-      try {
-        unlinkSync(entryPath);
-      } catch {}
-    }
-  } catch (error) {
-    console.warn(`[devflare] Error bundling DO worker "${workerName}":`, error);
-    return null;
-  }
-}
-
-// src/worker-entry/composed-worker.ts
-import { dirname as dirname2, relative as relative2, resolve as resolve4 } from "pathe";
-
-// src/worker-entry/durable-object-discovery.ts
-async function discoverDurableObjectFiles(cwd, pattern) {
-  const result = new Map;
-  const matchedFiles = await findFiles(pattern, { cwd });
-  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) {
-        result.set(filePath, classNames);
-      }
-    } catch (error) {
-      console.warn(`[devflare] Failed to read DO file: ${filePath}`, error);
-    }
-  }
-  return result;
-}
-async function discoverDurableObjects(projectRoot, pattern, workerName) {
-  const files = await discoverDurableObjectFiles(projectRoot, pattern);
-  return { files, workerName };
-}
-
-// src/worker-entry/routes.ts
-import { relative, resolve as resolve2 } from "pathe";
-var DEFAULT_ROUTE_DIR = "src/routes";
-var DEFAULT_ROUTE_FILE_PATTERNS = SUPPORTED_WORKER_EXTENSIONS.map((ext) => `**/*${ext}`);
-function normalizeRoutePrefix(prefix) {
-  if (!prefix || prefix === "/") {
-    return "";
-  }
-  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
-  return normalized.replace(/\/+$/g, "");
-}
-function createStaticSegmentsFromPrefix(prefix) {
-  if (!prefix) {
-    return [];
-  }
-  return prefix.split("/").filter(Boolean).map((value) => ({
-    type: "static",
-    value
-  }));
-}
-function shouldIgnoreRouteFile(relativePath) {
-  return relativePath.split("/").some((segment) => segment.startsWith("_"));
-}
-function toRoutePath(segments) {
-  if (segments.length === 0) {
-    return "/";
-  }
-  return `/${segments.map((segment) => {
-    if (segment.type === "static") {
-      return segment.value;
-    }
-    if (segment.type === "param") {
-      return `[${segment.name}]`;
-    }
-    if (segment.type === "rest") {
-      return `[...${segment.name}]`;
-    }
-    return `[[...${segment.name}]]`;
-  }).join("/")}`;
-}
-function getRouteSignature(segments) {
-  if (segments.length === 0) {
-    return "/";
-  }
-  return segments.map((segment) => {
-    if (segment.type === "static") {
-      return `static:${segment.value}`;
-    }
-    if (segment.type === "param") {
-      return "param";
-    }
-    if (segment.type === "rest") {
-      return "rest";
-    }
-    return "optional-rest";
-  }).join("/");
-}
-function getSegmentPriority(segment) {
-  if (segment.type === "static") {
-    return 4;
-  }
-  if (segment.type === "param") {
-    return 3;
-  }
-  if (segment.type === "rest") {
-    return 1;
-  }
-  return 0;
-}
-function compareRoutes(a, b) {
-  const maxLength = Math.max(a.segments.length, b.segments.length);
-  for (let index = 0;index < maxLength; index += 1) {
-    const left = a.segments[index];
-    const right = b.segments[index];
-    if (!left && !right) {
-      break;
-    }
-    if (!left) {
-      return 1;
-    }
-    if (!right) {
-      return -1;
-    }
-    const priorityDifference = getSegmentPriority(right) - getSegmentPriority(left);
-    if (priorityDifference !== 0) {
-      return priorityDifference;
-    }
-    if (left.type === "static" && right.type === "static") {
-      const lexicalDifference = left.value.localeCompare(right.value);
-      if (lexicalDifference !== 0) {
-        return lexicalDifference;
-      }
-    }
-  }
-  return a.filePath.localeCompare(b.filePath);
-}
-function parseRouteSegments(relativePath, prefixSegments) {
-  const withoutExtension = relativePath.replace(/\.[^.]+$/u, "");
-  const rawSegments = withoutExtension.split("/").filter(Boolean);
-  const routeSegments = [...prefixSegments];
-  for (let index = 0;index < rawSegments.length; index += 1) {
-    const segment = rawSegments[index];
-    const isLastSegment = index === rawSegments.length - 1;
-    if (segment === "index" && isLastSegment) {
-      continue;
-    }
-    const optionalRestMatch = segment.match(/^\[\[\.\.\.(.+)\]\]$/u);
-    if (optionalRestMatch) {
-      if (!isLastSegment) {
-        throw new Error(`Optional rest segment must be the final segment: ${relativePath}`);
-      }
-      routeSegments.push({
-        type: "optional-rest",
-        name: optionalRestMatch[1]
-      });
-      continue;
-    }
-    const restMatch = segment.match(/^\[\.\.\.(.+)\]$/u);
-    if (restMatch) {
-      if (!isLastSegment) {
-        throw new Error(`Rest segment must be the final segment: ${relativePath}`);
-      }
-      routeSegments.push({
-        type: "rest",
-        name: restMatch[1]
-      });
-      continue;
-    }
-    const dynamicMatch = segment.match(/^\[(.+)\]$/u);
-    if (dynamicMatch) {
-      routeSegments.push({
-        type: "param",
-        name: dynamicMatch[1]
-      });
-      continue;
-    }
-    routeSegments.push({
-      type: "static",
-      value: segment
-    });
-  }
-  return routeSegments;
-}
-async function directoryExists(dirPath) {
-  const fs = await import("node:fs/promises");
-  try {
-    const stat = await fs.stat(dirPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function getRouteDirectoryCandidate(cwd, config) {
-  const routesConfig = config.files?.routes;
-  if (routesConfig === false) {
-    return null;
-  }
-  const dir = routesConfig?.dir ?? DEFAULT_ROUTE_DIR;
-  return {
-    dir,
-    absoluteDir: resolve2(cwd, dir),
-    prefix: normalizeRoutePrefix(routesConfig?.prefix)
-  };
-}
-async function discoverRoutes(cwd, config) {
-  const routeDirectory = getRouteDirectoryCandidate(cwd, config);
-  if (!routeDirectory) {
-    return null;
-  }
-  if (!await directoryExists(routeDirectory.absoluteDir)) {
-    return null;
-  }
-  const prefixSegments = createStaticSegmentsFromPrefix(routeDirectory.prefix);
-  const files = await findFiles(DEFAULT_ROUTE_FILE_PATTERNS, {
-    cwd: routeDirectory.absoluteDir,
-    absolute: true
-  });
-  const discoveredRoutes = [];
-  const routeSignatures = new Map;
-  for (const absolutePath of files) {
-    const relativeToRouteDir = relative(routeDirectory.absoluteDir, absolutePath).replace(/\\/g, "/");
-    if (shouldIgnoreRouteFile(relativeToRouteDir)) {
-      continue;
-    }
-    const segments = parseRouteSegments(relativeToRouteDir, prefixSegments);
-    const routePath = toRoutePath(segments);
-    const filePath = relative(cwd, absolutePath).replace(/\\/g, "/");
-    const signature = getRouteSignature(segments);
-    const existingFilePath = routeSignatures.get(signature);
-    if (existingFilePath) {
-      throw new Error(`Conflicting file routes detected for "${routePath}". Both "${existingFilePath}" and "${filePath}" resolve to the same route.`);
-    }
-    routeSignatures.set(signature, filePath);
-    discoveredRoutes.push({
-      absolutePath,
-      filePath,
-      routePath,
-      segments
-    });
-  }
-  if (discoveredRoutes.length === 0) {
-    return null;
-  }
-  discoveredRoutes.sort(compareRoutes);
-  return {
-    dir: routeDirectory.dir,
-    absoluteDir: routeDirectory.absoluteDir,
-    prefix: routeDirectory.prefix,
-    routes: discoveredRoutes
-  };
-}
-
-// src/worker-entry/surface-paths.ts
-import { resolve as resolve3 } from "pathe";
-var defaultEntriesFor = (surface) => SUPPORTED_WORKER_EXTENSIONS.map((ext) => `src/${surface}${ext}`);
-var DEFAULT_FETCH_ENTRY_FILES = defaultEntriesFor("fetch");
-var DEFAULT_QUEUE_ENTRY_FILES = defaultEntriesFor("queue");
-var DEFAULT_SCHEDULED_ENTRY_FILES = defaultEntriesFor("scheduled");
-var DEFAULT_EMAIL_ENTRY_FILES = defaultEntriesFor("email");
-var DEFAULT_TAIL_ENTRY_FILES = defaultEntriesFor("tail");
-var BUILD_OUTPUT_PATH_PREFIXES = [
-  ".svelte-kit/",
-  ".adapter-cloudflare/",
-  ".next/",
-  ".nuxt/",
-  ".output/",
-  ".vercel/",
-  "dist/",
-  "build/",
-  ".vinxi/",
-  ".solid/"
-];
-function looksLikeBuildArtifactPath(configuredPath) {
-  const normalised = configuredPath.replace(/\\/g, "/").replace(/^\.\//, "");
-  return BUILD_OUTPUT_PATH_PREFIXES.some((prefix) => normalised.startsWith(prefix));
-}
-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 = resolve3(cwd, configuredPath);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      if (looksLikeBuildArtifactPath(configuredPath)) {
-        throw new Error(`Configured ${surfaceName} handler "${configuredPath}" was not found.
-
-This path looks like a framework build output (e.g. SvelteKit / Vite / Next).
-Devflare resolves handler paths BEFORE your framework runs its build, so the file
-does not exist yet at this stage.
-
-` + `Recommended fix — point devflare at the build artifact via wrangler passthrough
-` + `instead of files.${surfaceName}, so devflare skips composition and lets your
-framework write the worker entry that wrangler/vite then picks up:
-
-    files: { ${surfaceName}: false },
-    wrangler: {
-        passthrough: { main: '${configuredPath}' }
-    }
-
-Alternatively, run your framework build (e.g. \`vite build\`) before \`devflare build\`,
-or move the handler to a source file that exists at config time.`);
-      }
-      throw new Error(`Configured ${surfaceName} handler "${configuredPath}" was not found`);
-    }
-  }
-  for (const defaultEntry of defaultEntries) {
-    const absolutePath = resolve3(cwd, defaultEntry);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {}
-  }
-  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"),
-    tail: await resolveWorkerHandlerPath(cwd, config.files?.tail, DEFAULT_TAIL_ENTRY_FILES, "tail")
-  };
-}
-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) {
-				assertExplicitQueueHandlerStyle(__devflareQueueHandler)
-				const __devflareEvent = createQueueEvent(batch, env, ctx)
-				return runWithEventContext(
-					__devflareEvent,
-					() => __devflareQueueHandler(__devflareEvent, env, ctx)
-				)
-			}
-		}
-		: {}),
-	...(__devflareScheduledHandler
-		? {
-			async scheduled(controller, env, ctx) {
-				assertExplicitScheduledHandlerStyle(__devflareScheduledHandler)
-				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)
-				)
-			}
-		}
-		: {}),
-	...(__devflareTailHandler
-		? {
-			async tail(events, env, ctx) {
-				const __devflareEvent = createTailEvent(events, env, ctx)
-				return runWithEventContext(
-					__devflareEvent,
-					() => __devflareTailHandler.length >= 2
-						? __devflareTailHandler(events, env, ctx)
-						: __devflareTailHandler(__devflareEvent, env, ctx)
-				)
-			}
-		}
-		: {})
-}`;
-}
-function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, durableObjectExports = [], routeImports = [], options = {}) {
-  const includeDevOnlyHooks = options.includeDevOnlyHooks ?? options.devInternalEmail === true;
-  const importsBuilder = new CodeBuilder;
-  importsBuilder.importStatement([
-    "assertExplicitQueueHandlerStyle",
-    "assertExplicitScheduledHandlerStyle",
-    "createEmailEvent",
-    "createFetchEvent",
-    "createQueueEvent",
-    "createRouteResolve",
-    "createScheduledEvent",
-    "createTailEvent",
-    "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 },
-    { identifier: "__devflareTailModule", importPath: surfaceImportPaths.tail }
-  ];
-  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')");
-  builder.constDeclaration("__devflareTailHandler", "__devflareResolveHandler(__devflareTailModule, 'tail')");
-  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 = relative2(dirname2(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.kind === "local").map((binding) => binding.className));
-  if (localClassNames.size === 0) {
-    return [];
-  }
-  const pattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
-  const discoveredFiles = await discoverDurableObjectFiles(cwd, pattern);
-  const exports = [];
-  const discoveredClassNames = new Set;
-  for (const [filePath, allClassNames] of discoveredFiles) {
-    const classNames = allClassNames.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
-    });
-  }
-  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 mayRequireCompositionBesidesFetch(config) {
-  const files = config.files ?? {};
-  if (typeof files.queue === "string" && files.queue)
-    return true;
-  if (typeof files.scheduled === "string" && files.scheduled)
-    return true;
-  if (typeof files.email === "string" && files.email)
-    return true;
-  if (typeof files.tail === "string" && files.tail)
-    return true;
-  if (files.durableObjects)
-    return true;
-  if (files.routes)
-    return true;
-  const bindings = config.bindings ?? {};
-  const doBindings = bindings.durableObjects;
-  if (doBindings && Object.keys(doBindings).length > 0)
-    return true;
-  const sendEmail = bindings.sendEmail;
-  if (sendEmail && Object.keys(sendEmail).length > 0)
-    return true;
-  return false;
-}
-function needsComposedWorkerEntrypoint(cwd, surfacePaths, config, routeDiscovery) {
-  const hasAdditionalWorkerSurfaces = Boolean(surfacePaths.queue || surfacePaths.scheduled || surfacePaths.email || surfacePaths.tail || routeDiscovery?.routes.length);
-  if (hasAdditionalWorkerSurfaces) {
-    return true;
-  }
-  if (!surfacePaths.fetch) {
-    return false;
-  }
-  const assetsDirectory = config.assets?.directory;
-  if (assetsDirectory) {
-    const generatedAssetsWorkerPath = resolve4(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 configuredFetch = resolvedConfig.files?.fetch;
-  if (typeof configuredFetch === "string" && looksLikeBuildArtifactPath(configuredFetch)) {
-    const fs2 = await import("node:fs/promises");
-    const fetchAbsolute = resolve4(cwd, configuredFetch);
-    let fetchExists = true;
-    try {
-      await fs2.access(fetchAbsolute);
-    } catch {
-      fetchExists = false;
-    }
-    if (!fetchExists && !mayRequireCompositionBesidesFetch(resolvedConfig)) {
-      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 = resolve4(cwd, ".devflare", "worker-entrypoints");
-  const entryPath = resolve4(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,
-    tail: surfacePaths.tail ? toImportSpecifier(entryPath, surfacePaths.tail) : 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 entryPath;
-}
-
-// src/vite/plugin-durable-objects.ts
-var VIRTUAL_DO_ENTRY = "virtual:devflare-do-entry";
-var RESOLVED_VIRTUAL_DO_ENTRY = "\x00" + VIRTUAL_DO_ENTRY;
-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(", ")}`);
-  }
-}
-
-// src/vite/plugin-service-bindings.ts
-var VIRTUAL_SERVICE_WORKER_PREFIX = "virtual:devflare-service-worker/";
-var RESOLVED_VIRTUAL_SERVICE_WORKER_PREFIX = "\x00" + VIRTUAL_SERVICE_WORKER_PREFIX;
-function virtualServiceWorkerId(workerName) {
-  return `${VIRTUAL_SERVICE_WORKER_PREFIX}${encodeURIComponent(workerName)}`;
-}
-function resolvedVirtualServiceWorkerId(workerName) {
-  return `${RESOLVED_VIRTUAL_SERVICE_WORKER_PREFIX}${encodeURIComponent(workerName)}`;
-}
-function objectEntries(record) {
-  return record ? Object.entries(record) : [];
-}
-function toWranglerDurableObjectBinding(name, value) {
-  if (typeof value === "string") {
-    return { name, class_name: value };
-  }
-  return {
-    name,
-    class_name: value.className,
-    script_name: value.scriptName
-  };
-}
-function toWranglerWorkerConfig(worker) {
-  const queueProducers = worker.queueProducers ? objectEntries(worker.queueProducers).map(([binding, producer]) => ({
-    binding,
-    queue: producer.queueName
-  })) : undefined;
-  const queueConsumers = worker.queueConsumers ? objectEntries(worker.queueConsumers).map(([queue, consumer]) => ({
-    queue,
-    ...consumer.maxBatchSize !== undefined && {
-      max_batch_size: consumer.maxBatchSize
-    },
-    ...consumer.maxBatchTimeout !== undefined && {
-      max_batch_timeout: consumer.maxBatchTimeout
-    },
-    ...consumer.maxRetries !== undefined && { max_retries: consumer.maxRetries },
-    ...typeof consumer.deadLetterQueue === "string" && {
-      dead_letter_queue: consumer.deadLetterQueue
-    },
-    ...consumer.maxConcurrency !== undefined && {
-      max_concurrency: consumer.maxConcurrency
-    },
-    ...consumer.retryDelay !== undefined && { retry_delay: consumer.retryDelay }
-  })) : undefined;
-  const queues = queueProducers || queueConsumers ? {
-    ...queueProducers && { producers: queueProducers },
-    ...queueConsumers && { consumers: queueConsumers }
-  } : undefined;
-  const durableObjectBindings = worker.durableObjects ? objectEntries(worker.durableObjects).map(([name, value]) => toWranglerDurableObjectBinding(name, value)) : [];
-  const serviceBindings = worker.serviceBindings ? objectEntries(worker.serviceBindings).map(([binding, target]) => ({
-    binding,
-    service: target.name,
-    ...target.entrypoint && { entrypoint: target.entrypoint }
-  })) : [];
-  const config = {
-    name: worker.name,
-    main: virtualServiceWorkerId(worker.name),
-    compatibility_date: worker.compatibilityDate,
-    ...worker.compatibilityFlags && { compatibility_flags: worker.compatibilityFlags },
-    ...worker.bindings && { vars: worker.bindings },
-    ...worker.kvNamespaces && {
-      kv_namespaces: objectEntries(worker.kvNamespaces).map(([binding, id]) => ({
-        binding,
-        id
-      }))
-    },
-    ...worker.r2Buckets && {
-      r2_buckets: objectEntries(worker.r2Buckets).map(([binding, bucket_name]) => ({
-        binding,
-        bucket_name
-      }))
-    },
-    ...worker.d1Databases && {
-      d1_databases: objectEntries(worker.d1Databases).map(([binding, database_id]) => ({
-        binding,
-        database_id,
-        database_name: database_id
-      }))
-    },
-    ...durableObjectBindings.length > 0 && {
-      durable_objects: {
-        bindings: durableObjectBindings
-      }
-    },
-    ...serviceBindings.length > 0 && {
-      services: serviceBindings
-    },
-    ...queues && { queues }
-  };
-  return config;
-}
-function createAuxiliaryServiceWorkerConfigs(resolution) {
-  if (!resolution || resolution.workers.length === 0) {
-    return { auxiliaryWorkers: [], virtualModules: new Map };
-  }
-  const virtualModules = new Map;
-  const auxiliaryWorkers = resolution.workers.map((worker) => {
-    virtualModules.set(resolvedVirtualServiceWorkerId(worker.name), worker.script);
-    return {
-      config: toWranglerWorkerConfig(worker)
-    };
-  });
-  return { auxiliaryWorkers, virtualModules };
-}
-
-// src/vite/plugin-context.ts
-var CONFIG_DIR = ".devflare";
-function removeDevflareHandledServeBindings(config) {
-  const next = { ...config };
-  delete next.workflows;
-  delete next.media;
-  return next;
-}
-async function buildPluginContextState(projectRoot, devflareConfig, environment, mode = "serve", configDir = projectRoot) {
-  const resourceResolvedConfig = mode === "build" ? await resolveResources(devflareConfig, { phase: "build", environment }) : await resolveResources(devflareConfig, { phase: "local", environment });
-  const effectiveConfig = await resolveConfigEnvVars(resourceResolvedConfig, {
-    cwd: configDir,
-    mode: mode === "build" ? "build" : "dev"
-  });
-  const compiledWranglerConfig = mode === "build" ? compileBuildConfig(effectiveConfig) : compileConfig(effectiveConfig);
-  const wranglerConfig = mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compiledWranglerConfig) : removeDevflareHandledServeBindings(compiledWranglerConfig);
-  const cloudflareConfig = {
-    ...mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compileToProgrammaticConfig(effectiveConfig, environment, {
-      preserveNamedBindings: true
-    })) : removeDevflareHandledServeBindings(compileToProgrammaticConfig(effectiveConfig, environment))
-  };
-  const composedMainEntry = mode === "build" ? null : await prepareComposedWorkerEntrypoint(projectRoot, effectiveConfig, environment);
-  if (composedMainEntry) {
-    const relativeMain = relative3(projectRoot, composedMainEntry);
-    wranglerConfig.main = relativeMain;
-    cloudflareConfig.main = relativeMain;
-  }
-  let durableObjects = null;
-  let auxiliaryWorkerConfig = null;
-  let serviceWorkerVirtualModules = new Map;
-  let serviceAuxiliaryWorkerConfigs = [];
-  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);
-    }
-  }
-  if (mode === "serve" && effectiveConfig.bindings?.services) {
-    const serviceBindingResolution = await resolveServiceBindings(effectiveConfig, configDir);
-    const serviceWorkers = createAuxiliaryServiceWorkerConfigs(serviceBindingResolution);
-    serviceAuxiliaryWorkerConfigs = serviceWorkers.auxiliaryWorkers;
-    serviceWorkerVirtualModules = serviceWorkers.virtualModules;
-  }
-  const auxiliaryWorkerConfigs = [
-    ...auxiliaryWorkerConfig ? [auxiliaryWorkerConfig] : [],
-    ...serviceAuxiliaryWorkerConfigs
-  ];
-  return {
-    wranglerConfig,
-    cloudflareConfig,
-    auxiliaryWorkerConfigs,
-    serviceWorkerVirtualModules,
-    durableObjects,
-    auxiliaryWorkerConfig
-  };
-}
-async function ensureGeneratedConfigDir(projectRoot) {
-  const configDir = resolve5(projectRoot, CONFIG_DIR);
-  const fs = await import("node:fs/promises");
-  await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve5(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 : resolve5(projectRoot, configPath);
-  }
-  return await resolveConfigPath(projectRoot) ?? null;
-}
-
-// src/vite/plugin-transform.ts
-var TRANSFORMABLE_EXTENSIONS = [".ts", ".tsx", ".js"];
-function isTransformCandidate(id) {
-  if (id.includes("node_modules"))
-    return false;
-  return TRANSFORMABLE_EXTENSIONS.some((ext) => id.endsWith(ext));
-}
-async function runWorkerEntryTransform(code, id) {
-  if (!id.endsWith("worker.ts") && !id.endsWith("worker.js")) {
-    return null;
-  }
-  const { shouldTransformWorker, transformWorkerEntrypoint: transformWorkerEntrypoint2 } = await import("./worker-entrypoint-y8s9kdcx.js");
-  if (!shouldTransformWorker(code, id)) {
-    return null;
-  }
-  const result = transformWorkerEntrypoint2(code, id);
-  if (!result)
-    return null;
-  return {
-    code: result.code,
-    map: result.map
-  };
-}
-async function runDurableObjectTransform(code, id, options) {
-  if (!options.doTransforms)
-    return null;
-  if (!code.includes("DurableObject") && !code.includes("@durableObject")) {
-    return null;
-  }
-  const { transformDurableObject } = await import("./durable-object-0ybmg08a.js");
-  return transformDurableObject(code, id);
-}
-async function runDevflareTransform(code, id, options) {
-  if (!isTransformCandidate(id))
-    return null;
-  const workerResult = await runWorkerEntryTransform(code, id);
-  if (workerResult)
-    return workerResult;
-  return await runDurableObjectTransform(code, id, options);
-}
-
-// src/vite/plugin.ts
-var CONFIG_DIR2 = ".devflare";
-function createPluginState() {
-  return {
-    context: {
-      wranglerConfig: null,
-      cloudflareConfig: null,
-      projectRoot: process.cwd(),
-      auxiliaryWorkerConfig: null,
-      auxiliaryWorkerConfigs: [],
-      serviceWorkerVirtualModules: new Map,
-      durableObjects: null
-    },
-    projectRoot: process.cwd(),
-    devflareConfig: null,
-    resolvedPluginConfigPath: null
-  };
-}
-async function loadAndApplyConfig(state, options, mode, onContextUpdated) {
-  state.devflareConfig = await loadConfig({
-    cwd: state.projectRoot,
-    configFile: options.configPath
-  });
-  const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, options.environment, mode, state.resolvedPluginConfigPath ? dirname3(state.resolvedPluginConfigPath) : state.projectRoot);
-  Object.assign(state.context, {
-    projectRoot: state.projectRoot,
-    ...pluginState
-  });
-  onContextUpdated(state.context);
-  logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
-  await writeGeneratedWranglerConfig(state.projectRoot, pluginState.wranglerConfig);
-}
-var lastPluginContext = createPluginState().context;
-function devflarePlugin(options = {}) {
-  const {
-    configPath,
-    environment,
-    doTransforms = true,
-    watchConfig = true,
-    bridgePort = process.env.DEVFLARE_BRIDGE_PORT ? Number.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();
-      return buildPluginConfigHookResult(cwd, { configPath, bridgePort, wsProxyPatterns }, command, config.define ?? {});
-    },
-    resolveId(id) {
-      if (id === VIRTUAL_DO_ENTRY) {
-        return RESOLVED_VIRTUAL_DO_ENTRY;
-      }
-      if (id.startsWith(VIRTUAL_SERVICE_WORKER_PREFIX)) {
-        return "\x00" + id;
-      }
-      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);
-      }
-      if (id.startsWith(RESOLVED_VIRTUAL_SERVICE_WORKER_PREFIX)) {
-        return state.context.serviceWorkerVirtualModules.get(id) ?? null;
-      }
-      return null;
-    },
-    async configResolved(config) {
-      state.projectRoot = config.root;
-      state.context.projectRoot = state.projectRoot;
-      state.resolvedPluginConfigPath = await resolvePluginConfigPath(state.projectRoot, configPath);
-      try {
-        await loadAndApplyConfig(state, { configPath, environment }, config.command === "build" ? "build" : "serve", (ctx) => {
-          lastPluginContext = ctx;
-        });
-        if (config.command === "serve") {
-          console.log("[devflare] Config generated to .devflare/wrangler.jsonc");
-          if (state.context.auxiliaryWorkerConfig) {
-            console.log("[devflare] ✓ Auxiliary DO worker configured");
-          }
-        }
-        if (config.command === "build") {
-          console.log(`[devflare] Generated ${CONFIG_DIR2}/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 ?? resolve6(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 {
-            await loadAndApplyConfig(state, { configPath, environment }, "serve", (ctx) => {
-              lastPluginContext = ctx;
-            });
-            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) {
-      return runDevflareTransform(code, id, { doTransforms });
-    }
-  };
-}
-
-// src/vite/config-file.ts
-var CONFIG_DIR3 = ".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: resolve7 } = await import("pathe");
-  const configDir = resolve7(cwd, CONFIG_DIR3);
-  await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve7(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: dirname4, resolve: resolve7 } = await import("pathe");
-  let currentDir = dirname4(currentFilePath);
-  while (true) {
-    const packageJsonPath = resolve7(currentDir, "package.json");
-    try {
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
-      if (packageJson.name === "devflare") {
-        return currentDir;
-      }
-    } catch {}
-    const parentDir = dirname4(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: relative4, resolve: resolve7 } = await import("pathe");
-  const currentFilePath = normalize(fileURLToPath(import.meta.url));
-  const currentExtension = extname(currentFilePath);
-  const packageRoot = await resolveDevflarePackageRoot(currentFilePath);
-  const viteEntryPath = currentFilePath.includes("/dist/") ? resolve7(packageRoot, "dist/vite/index.js") : resolve7(packageRoot, `src/vite/index${currentExtension}`);
-  const relativeImportPath = relative4(configDir, viteEntryPath);
-  return relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
-}
-async function writeGeneratedViteConfig(options) {
-  const fs = await import("node:fs/promises");
-  const { resolve: resolve7 } = await import("pathe");
-  const configDir = await ensureGeneratedConfigDir2(options.cwd);
-  const generatedConfigPath = resolve7(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 { discoverDurableObjectFiles, buildQueueProducers, buildQueueConsumers, buildRateLimitsConfig, buildVersionMetadataConfig, buildWorkerLoadersConfig, buildMtlsCertificatesConfig, buildDispatchNamespacesConfig, buildWorkflowsConfig, buildPipelinesConfig, buildHyperdrivesConfig, buildImagesConfig, buildMediaConfig, buildArtifactsConfig, buildAiSearchNamespacesConfig, buildAiSearchInstancesConfig, buildSecretsStoreConfig, buildSendEmailConfig, resolveServiceBindings, getRouteDirectoryCandidate, discoverRoutes, DEFAULT_FETCH_ENTRY_FILES, DEFAULT_QUEUE_ENTRY_FILES, DEFAULT_SCHEDULED_ENTRY_FILES, DEFAULT_EMAIL_ENTRY_FILES, resolveWorkerSurfacePaths, hasWorkerSurfacePaths, prepareComposedWorkerEntrypoint, hasInlineViteConfig, resolveEffectiveViteProject, resolveViteUserConfig, writeGeneratedViteConfig, devflarePlugin2 as devflarePlugin, getPluginContext, getCloudflareConfig, getDevflareConfigs, devflarePlugin3 as devflarePlugin1 };