devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-p7q23nce.js

@@ -0,0 +1,1031 @@
+import {
+  discoverEntrypointsSync,
+  resolvePackageSpecifier
+} from "./index-3edvz3hs.js";
+import {
+  DEFAULT_DO_PATTERN,
+  findFiles,
+  findFilesSync
+} from "./index-qwgr4q7s.js";
+import {
+  SUPPORTED_WORKER_EXTENSIONS,
+  transformWorkerEntrypoint
+} from "./index-aqrwyy57.js";
+import {
+  findDurableObjectClasses
+} from "./index-vhqww6tt.js";
+import {
+  configSchema,
+  getLocalD1DatabaseIdentifier,
+  getLocalKVNamespaceIdentifier,
+  normalizeArtifactsBinding,
+  normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding
+} from "./index-syscwrjp.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/test/resolve-service-bindings.ts
+import { dirname, join, resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+
+// 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 clearBundleCache() {
+  bundleCache.clear();
+}
+function findDefaultServiceWorkerEntrypoint(refConfigDir) {
+  for (const candidate of ["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 mergedServiceBindings = {
+    ...runtimeConfig.serviceBindings ?? {},
+    ...serviceBindings
+  };
+  return {
+    workers: [{
+      name: doWorkerName,
+      script,
+      modules: true,
+      compatibilityDate: config.compatibilityDate,
+      ...runtimeConfig,
+      ...Object.keys(mergedServiceBindings).length > 0 && {
+        serviceBindings: mergedServiceBindings
+      },
+      durableObjects
+    }],
+    bindings: Object.fromEntries(doClasses.map((do_) => [
+      do_.bindingName,
+      {
+        className: do_.className,
+        scriptName: doWorkerName
+      }
+    ]))
+  };
+}
+function hasServiceBindings(config) {
+  const services = config.bindings?.services;
+  if (!services)
+    return false;
+  return Object.keys(services).length > 0;
+}
+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;
+  }
+}
+function hasCrossWorkerDOs(config) {
+  const dos = config.bindings?.durableObjects;
+  if (!dos)
+    return false;
+  for (const doConfig of Object.values(dos)) {
+    const normalized = normalizeDOBinding(doConfig);
+    if (normalized.__ref)
+      return true;
+  }
+  return false;
+}
+async function resolveDOBindings(config, configDir) {
+  const dos = config.bindings?.durableObjects;
+  if (!dos) {
+    return { workers: [], crossWorkerDOBindings: {} };
+  }
+  const workersByName = new Map;
+  const crossWorkerDOBindings = {};
+  for (const [bindingName, rawDoConfig] of Object.entries(dos)) {
+    const hasRef = typeof rawDoConfig === "object" && "__ref" in rawDoConfig;
+    if (!hasRef) {
+      continue;
+    }
+    const ref = rawDoConfig.__ref;
+    if ("__import" in ref && typeof ref.__import === "function") {
+      await ref.resolve();
+    }
+    const doConfig = normalizeDOBinding(rawDoConfig);
+    const workerName = ref.name;
+    if (!workersByName.has(workerName)) {
+      const worker = await resolveDORefWorker(ref, configDir);
+      if (worker) {
+        workersByName.set(workerName, worker);
+      }
+    }
+    crossWorkerDOBindings[bindingName] = {
+      className: doConfig.className,
+      scriptName: workerName
+    };
+  }
+  return {
+    workers: [...workersByName.values()],
+    crossWorkerDOBindings
+  };
+}
+async function resolveDORefWorker(ref, parentConfigDir) {
+  const config = ref.config;
+  if (!config)
+    return null;
+  const configPath = ref.configPath;
+  if (!configPath || configPath === "<resolved>") {
+    console.warn(`[devflare] Cannot resolve DO worker "${ref.name}" - configPath not available`);
+    return null;
+  }
+  const resolvedConfigPath = resolvePackageSpecifier(configPath, parentConfigDir);
+  const refConfigDir = dirname(resolvedConfigPath);
+  const dosConfig = config.bindings?.durableObjects;
+  if (!dosConfig || Object.keys(dosConfig).length === 0) {
+    console.warn(`[devflare] Referenced worker "${ref.name}" has no Durable Objects`);
+    return null;
+  }
+  const discoveredDOs = discoverDOFilesSync(refConfigDir);
+  const doClasses = [];
+  for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
+    const doConfig = normalizeDOBinding(rawDoConfig);
+    const className = doConfig.className;
+    const scriptName = doConfig.scriptName;
+    if (scriptName) {
+      const scriptPath = resolve(refConfigDir, "src", scriptName);
+      if (!existsSync(scriptPath)) {
+        const altPath = resolve(refConfigDir, scriptName);
+        if (!existsSync(altPath)) {
+          console.warn(`[devflare] DO script not found: ${scriptPath} or ${altPath}`);
+          continue;
+        }
+        doClasses.push({ bindingName, className, scriptPath: altPath });
+      } else {
+        doClasses.push({ bindingName, className, scriptPath });
+      }
+    } else {
+      const discoveredPath = discoveredDOs.get(className);
+      if (discoveredPath) {
+        doClasses.push({ bindingName, className, scriptPath: discoveredPath });
+      } else {
+        console.warn(`[devflare] DO "${bindingName}" (class: ${className}) not found in do.*.ts files in "${ref.name}"`);
+        continue;
+      }
+    }
+  }
+  if (doClasses.length === 0) {
+    console.warn(`[devflare] No valid DO classes found in "${ref.name}"`);
+    return null;
+  }
+  const script = await bundleDOClasses(doClasses, ref.name);
+  if (!script)
+    return null;
+  const durableObjects = {};
+  for (const do_ of doClasses) {
+    durableObjects[do_.bindingName] = do_.className;
+  }
+  return {
+    name: ref.name,
+    script,
+    modules: true,
+    compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+    durableObjects
+  };
+}
+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/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
+  };
+}
+
+export { discoverDurableObjectFiles, discoverDurableObjects, getRouteDirectoryCandidate, discoverRoutes, buildQueueProducers, buildQueueConsumers, buildRateLimitsConfig, buildVersionMetadataConfig, buildWorkerLoadersConfig, buildMtlsCertificatesConfig, buildDispatchNamespacesConfig, buildWorkflowsConfig, buildPipelinesConfig, buildHyperdrivesConfig, buildImagesConfig, buildMediaConfig, buildArtifactsConfig, buildAiSearchNamespacesConfig, buildAiSearchInstancesConfig, buildSecretsStoreConfig, buildSendEmailConfig, clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings };