devflare 1.0.0-next.34 → 1.0.0-next.35

package/dist/{index-bhxj7ff6.js → index-e251zhns.js}

@@ -1,15 +1,12 @@
 import {
-  discoverDurableObjectFiles,
-  discoverDurableObjects,
-  discoverRoutes,
-  resolveServiceBindings
-} from "./index-dgx495pv.js";
+  discoverEntrypointsSync,
+  resolvePackageSpecifier
+} from "./index-by27mzra.js";
 import {
-  DEFAULT_DO_PATTERN
+  DEFAULT_DO_PATTERN,
+  findFiles,
+  findFilesSync
 } from "./index-5dkjffqz.js";
-import {
-  SUPPORTED_WORKER_EXTENSIONS
-} from "./index-7m557715.js";
 import {
   compileBuildConfig,
   compileConfig,
@@ -17,24 +14,39 @@ import {
   isolateViteBuildOutputPaths,
   rebaseWranglerConfigPaths,
   writeWranglerConfig
-} from "./index-w8c8tjc5.js";
+} from "./index-mek9msfv.js";
 import {
+  configSchema,
+  getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
   loadConfig,
-  loadResolvedConfig,
+  normalizeArtifactsBinding,
   normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding,
+  resolveConfigEnvVars,
   resolveConfigForEnvironment,
   resolveConfigPath,
   resolveResources
-} from "./index-pd97hk2j.js";
+} from "./index-x8s9rwfh.js";
 import {
-  resolveConfigEnvVars
-} from "./index-wxdcrzcp.js";
+  SUPPORTED_WORKER_EXTENSIONS,
+  transformWorkerEntrypoint
+} from "./index-7m557715.js";
+import {
+  findDurableObjectClasses
+} from "./index-p93cngdp.js";
 import {
   __require
 } from "./index-37x76zdn.js";
-
 // src/vite/plugin.ts
-import { dirname as dirname2, resolve as resolve4 } from "pathe";
+import { dirname as dirname3, resolve as resolve6 } from "pathe";
 
 // src/vite/plugin-config-hook.ts
 async function tryLoadDevflareConfig(cwd, configPath, command) {
@@ -100,13 +112,897 @@ async function buildPluginConfigHookResult(cwd, options, command, existingDefine
 }
 
 // src/vite/plugin-context.ts
-import { isAbsolute, relative as relative2, resolve as resolve3 } from "pathe";
+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] Bun runtime required for bundling worker scripts");
+    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] Bun runtime required for bundling DO classes");
+    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, relative, resolve as resolve2 } from "pathe";
+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 } from "pathe";
+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");
@@ -135,7 +1031,7 @@ async function resolveWorkerHandlerPath(cwd, configuredPath, defaultEntries, sur
   }
   const fs = await import("node:fs/promises");
   if (typeof configuredPath === "string" && configuredPath) {
-    const absolutePath = resolve(cwd, configuredPath);
+    const absolutePath = resolve3(cwd, configuredPath);
     try {
       await fs.access(absolutePath);
       return absolutePath;
@@ -163,7 +1059,7 @@ or move the handler to a source file that exists at config time.`);
     }
   }
   for (const defaultEntry of defaultEntries) {
-    const absolutePath = resolve(cwd, defaultEntry);
+    const absolutePath = resolve3(cwd, defaultEntry);
     try {
       await fs.access(absolutePath);
       return absolutePath;
@@ -470,7 +1366,7 @@ ${routeManifestEntries.join(`,
   return builder.toString();
 }
 function toImportSpecifier(fromFilePath, toFilePath) {
-  const specifier = relative(dirname(fromFilePath), toFilePath).replace(/\\/g, "/");
+  const specifier = relative2(dirname2(fromFilePath), toFilePath).replace(/\\/g, "/");
   return specifier.startsWith(".") ? specifier : `./${specifier}`;
 }
 function createGeneratedRouteModuleImports(entryPath, routeDiscovery) {
@@ -550,7 +1446,7 @@ function needsComposedWorkerEntrypoint(cwd, surfacePaths, config, routeDiscovery
   }
   const assetsDirectory = config.assets?.directory;
   if (assetsDirectory) {
-    const generatedAssetsWorkerPath = resolve2(cwd, assetsDirectory, "_worker.js");
+    const generatedAssetsWorkerPath = resolve4(cwd, assetsDirectory, "_worker.js");
     if (surfacePaths.fetch === generatedAssetsWorkerPath) {
       return false;
     }
@@ -565,7 +1461,7 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
   const configuredFetch = resolvedConfig.files?.fetch;
   if (typeof configuredFetch === "string" && looksLikeBuildArtifactPath(configuredFetch)) {
     const fs2 = await import("node:fs/promises");
-    const fetchAbsolute = resolve2(cwd, configuredFetch);
+    const fetchAbsolute = resolve4(cwd, configuredFetch);
     let fetchExists = true;
     try {
       await fs2.access(fetchAbsolute);
@@ -582,8 +1478,8 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
     return null;
   }
   const fs = await import("node:fs/promises");
-  const entryDir = resolve2(cwd, ".devflare", "worker-entrypoints");
-  const entryPath = resolve2(entryDir, "main.ts");
+  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,
@@ -779,7 +1675,7 @@ async function buildPluginContextState(projectRoot, devflareConfig, environment,
   };
   const composedMainEntry = mode === "build" ? null : await prepareComposedWorkerEntrypoint(projectRoot, effectiveConfig, environment);
   if (composedMainEntry) {
-    const relativeMain = relative2(projectRoot, composedMainEntry);
+    const relativeMain = relative3(projectRoot, composedMainEntry);
     wranglerConfig.main = relativeMain;
     cloudflareConfig.main = relativeMain;
   }
@@ -828,10 +1724,10 @@ async function buildPluginContextState(projectRoot, devflareConfig, environment,
   };
 }
 async function ensureGeneratedConfigDir(projectRoot) {
-  const configDir = resolve3(projectRoot, CONFIG_DIR);
+  const configDir = resolve5(projectRoot, CONFIG_DIR);
   const fs = await import("node:fs/promises");
   await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve3(configDir, ".gitignore");
+  const gitignorePath = resolve5(configDir, ".gitignore");
   try {
     await fs.access(gitignorePath);
   } catch {
@@ -847,7 +1743,7 @@ async function writeGeneratedWranglerConfig(projectRoot, wranglerConfig) {
 }
 async function resolvePluginConfigPath(projectRoot, configPath) {
   if (configPath) {
-    return isAbsolute(configPath) ? configPath : resolve3(projectRoot, configPath);
+    return isAbsolute(configPath) ? configPath : resolve5(projectRoot, configPath);
   }
   return await resolveConfigPath(projectRoot) ?? null;
 }
@@ -863,11 +1759,11 @@ async function runWorkerEntryTransform(code, id) {
   if (!id.endsWith("worker.ts") && !id.endsWith("worker.js")) {
     return null;
   }
-  const { shouldTransformWorker, transformWorkerEntrypoint } = await import("./worker-entrypoint-y8s9kdcx.js");
+  const { shouldTransformWorker, transformWorkerEntrypoint: transformWorkerEntrypoint2 } = await import("./worker-entrypoint-y8s9kdcx.js");
   if (!shouldTransformWorker(code, id)) {
     return null;
   }
-  const result = transformWorkerEntrypoint(code, id);
+  const result = transformWorkerEntrypoint2(code, id);
   if (!result)
     return null;
   return {
@@ -893,74 +1789,6 @@ async function runDevflareTransform(code, id, options) {
   return await runDurableObjectTransform(code, id, options);
 }
 
-// src/vite/plugin-programmatic.ts
-import { relative as relative3 } from "pathe";
-async function loadProgrammaticDevflareConfig(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const strategy = options.resolve ?? "offline-local";
-  const resourceResolvedConfig = strategy === "remote" ? await loadResolvedConfig({
-    cwd,
-    configFile: options.configPath,
-    environment: options.environment
-  }) : await resolveResources(await loadConfig({ cwd, configFile: options.configPath }), {
-    phase: "local",
-    environment: options.environment
-  });
-  const devflareConfig = await resolveConfigEnvVars(resourceResolvedConfig, {
-    cwd,
-    configPath: options.configPath,
-    mode: strategy === "remote" ? "build" : "dev"
-  });
-  return { cwd, devflareConfig };
-}
-async function buildProgrammaticArtifacts(options, mode) {
-  const { cwd, devflareConfig } = await loadProgrammaticDevflareConfig(options);
-  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, devflareConfig);
-  const wranglerConfig = compileConfig(devflareConfig);
-  const cloudflareConfig = mode === "programmatic" ? compileToProgrammaticConfig(devflareConfig) : { ...wranglerConfig };
-  if (composedMainEntry) {
-    const relativeMain = relative3(cwd, composedMainEntry);
-    wranglerConfig.main = relativeMain;
-    cloudflareConfig.main = relativeMain;
-  }
-  const auxiliaryWorkers = [];
-  const doPatternConfig = devflareConfig.files?.durableObjects;
-  const doPattern = typeof doPatternConfig === "string" ? doPatternConfig : DEFAULT_DO_PATTERN;
-  if (doPatternConfig !== false) {
-    const doWorkerName = `${wranglerConfig.name}-do`;
-    const discovery = await discoverDurableObjects(cwd, doPattern, doWorkerName);
-    if (discovery.files.size > 0) {
-      if (cloudflareConfig.durable_objects) {
-        const doConfig = cloudflareConfig.durable_objects;
-        for (const binding of doConfig.bindings) {
-          binding.script_name = doWorkerName;
-        }
-      }
-      auxiliaryWorkers.push(createAuxiliaryWorkerConfig(wranglerConfig, discovery));
-    }
-  }
-  if (devflareConfig.bindings?.services) {
-    const serviceBindingResolution = await resolveServiceBindings(devflareConfig, cwd);
-    auxiliaryWorkers.push(...createAuxiliaryServiceWorkerConfigs(serviceBindingResolution).auxiliaryWorkers);
-  }
-  return {
-    cwd,
-    devflareConfig,
-    composedMainEntry,
-    wranglerConfig,
-    cloudflareConfig,
-    auxiliaryWorkers
-  };
-}
-async function getCloudflareConfig(options = {}) {
-  const { cloudflareConfig } = await buildProgrammaticArtifacts(options, "programmatic");
-  return cloudflareConfig;
-}
-async function getDevflareConfigs(options = {}) {
-  const { cloudflareConfig, auxiliaryWorkers } = await buildProgrammaticArtifacts(options, "wrangler");
-  return { cloudflareConfig, auxiliaryWorkers };
-}
-
 // src/vite/plugin.ts
 var CONFIG_DIR2 = ".devflare";
 function createPluginState() {
@@ -984,7 +1812,7 @@ async function loadAndApplyConfig(state, options, mode, onContextUpdated) {
     cwd: state.projectRoot,
     configFile: options.configPath
   });
-  const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, options.environment, mode, state.resolvedPluginConfigPath ? dirname2(state.resolvedPluginConfigPath) : state.projectRoot);
+  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
@@ -994,9 +1822,6 @@ async function loadAndApplyConfig(state, options, mode, onContextUpdated) {
   await writeGeneratedWranglerConfig(state.projectRoot, pluginState.wranglerConfig);
 }
 var lastPluginContext = createPluginState().context;
-function getPluginContext() {
-  return lastPluginContext;
-}
 function devflarePlugin(options = {}) {
   const {
     configPath,
@@ -1063,7 +1888,7 @@ export default { fetch: () => new Response("No DOs") }`;
     configureServer(server) {
       if (!watchConfig)
         return;
-      const fullConfigPath = state.resolvedPluginConfigPath ?? resolve4(state.projectRoot, configPath || "devflare.config.ts");
+      const fullConfigPath = state.resolvedPluginConfigPath ?? resolve6(state.projectRoot, configPath || "devflare.config.ts");
       server.watcher.add(fullConfigPath);
       server.watcher.on("change", async (changedPath) => {
         if (changedPath === fullConfigPath) {
@@ -1088,6 +1913,7 @@ export default { fetch: () => new Response("No DOs") }`;
     }
   };
 }
+
 // src/vite/config-file.ts
 var CONFIG_DIR3 = ".devflare";
 var GENERATED_VITE_CONFIG_FILENAME = "vite.config.mjs";
@@ -1153,10 +1979,10 @@ async function resolveViteUserConfig(configEnv, options = {}) {
 }
 async function ensureGeneratedConfigDir2(cwd) {
   const fs = await import("node:fs/promises");
-  const { resolve: resolve5 } = await import("pathe");
-  const configDir = resolve5(cwd, CONFIG_DIR3);
+  const { resolve: resolve7 } = await import("pathe");
+  const configDir = resolve7(cwd, CONFIG_DIR3);
   await fs.mkdir(configDir, { recursive: true });
-  const gitignorePath = resolve5(configDir, ".gitignore");
+  const gitignorePath = resolve7(configDir, ".gitignore");
   try {
     await fs.access(gitignorePath);
   } catch {
@@ -1167,17 +1993,17 @@ async function ensureGeneratedConfigDir2(cwd) {
 }
 async function resolveDevflarePackageRoot(currentFilePath) {
   const fs = await import("node:fs/promises");
-  const { dirname: dirname3, resolve: resolve5 } = await import("pathe");
-  let currentDir = dirname3(currentFilePath);
+  const { dirname: dirname4, resolve: resolve7 } = await import("pathe");
+  let currentDir = dirname4(currentFilePath);
   while (true) {
-    const packageJsonPath = resolve5(currentDir, "package.json");
+    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 = dirname3(currentDir);
+    const parentDir = dirname4(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -1187,19 +2013,19 @@ async function resolveDevflarePackageRoot(currentFilePath) {
 }
 async function resolveGeneratedViteImportPath(configDir) {
   const { fileURLToPath } = await import("node:url");
-  const { extname, normalize, relative: relative4, resolve: resolve5 } = await import("pathe");
+  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/") ? resolve5(packageRoot, "dist/vite/index.js") : resolve5(packageRoot, `src/vite/index${currentExtension}`);
+  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: resolve5 } = await import("pathe");
+  const { resolve: resolve7 } = await import("pathe");
   const configDir = await ensureGeneratedConfigDir2(options.cwd);
-  const generatedConfigPath = resolve5(configDir, GENERATED_VITE_CONFIG_FILENAME);
+  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)}
@@ -1217,4 +2043,4 @@ export default defineConfig(async (env) => {
   await fs.writeFile(generatedConfigPath, content, "utf-8");
   return generatedConfigPath;
 }
-export { DEFAULT_FETCH_ENTRY_FILES, DEFAULT_QUEUE_ENTRY_FILES, DEFAULT_SCHEDULED_ENTRY_FILES, DEFAULT_EMAIL_ENTRY_FILES, resolveWorkerSurfacePaths, hasWorkerSurfacePaths, prepareComposedWorkerEntrypoint, getCloudflareConfig, getDevflareConfigs, getPluginContext, devflarePlugin, hasInlineViteConfig, resolveEffectiveViteProject, resolveViteUserConfig, writeGeneratedViteConfig };
+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 };