devflare 1.0.0-next.20 → 1.0.0-next.21

package/dist/index-50em8s6c.js

@@ -0,0 +1,898 @@
+import {
+  bundleWorkerEntry
+} from "./index-gq39t0rx.js";
+import {
+  discoverEntrypointsSync
+} from "./index-gj5qh491.js";
+import {
+  resolvePackageSpecifier
+} from "./index-t4fhcx1n.js";
+import {
+  transformWorkerEntrypoint
+} from "./index-7k278fgz.js";
+import {
+  DEFAULT_DO_PATTERN,
+  DEFAULT_WORKFLOW_PATTERN,
+  findFiles,
+  findFilesSync
+} from "./index-qwgr4q7s.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/workflows/local-workflow-entrypoints.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join as join2, relative, resolve as resolve2 } from "pathe";
+function findExportedClasses(code) {
+  const classes = [];
+  const classPattern = /export\s+class\s+(\w+)/g;
+  let match;
+  while ((match = classPattern.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function toImportSpecifier(fromDir, filePath) {
+  const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function discoverWorkflowClasses(config, configDir) {
+  const classToFilePath = new Map;
+  const workflowPatternConfig = config.files?.workflows;
+  const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
+  if (workflowPatternConfig === false) {
+    return classToFilePath;
+  }
+  const files = await findFiles(workflowPattern, { cwd: configDir });
+  for (const filePath of files) {
+    try {
+      const code = await readFile(filePath, "utf-8");
+      for (const className of findExportedClasses(code)) {
+        classToFilePath.set(className, filePath);
+      }
+    } catch {}
+  }
+  return classToFilePath;
+}
+async function resolveLocalWorkflowEntrypoints(config, configDir) {
+  const workflows = config.bindings?.workflows;
+  if (!workflows || Object.keys(workflows).length === 0) {
+    return [];
+  }
+  const classToFilePath = await discoverWorkflowClasses(config, configDir);
+  const entrypoints = [];
+  for (const [bindingName, binding] of Object.entries(workflows)) {
+    const normalized = normalizeWorkflowBinding(binding);
+    if (normalized.scriptName) {
+      continue;
+    }
+    const scriptPath = classToFilePath.get(normalized.className);
+    if (!scriptPath) {
+      throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.
+` + `Either set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
+    }
+    entrypoints.push({
+      bindingName,
+      className: normalized.className,
+      scriptPath
+    });
+  }
+  return entrypoints;
+}
+function buildWorkflowVirtualEntry(entrypoints, entryDir) {
+  const imports = entrypoints.map((entrypoint, index) => {
+    const importName = `__DevflareWorkflow${index}`;
+    const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
+    return {
+      importName,
+      className: entrypoint.className,
+      line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
+    };
+  });
+  const exports = imports.map((entrypoint) => {
+    return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
+  });
+  return [...imports.map((entrypoint) => entrypoint.line), "", ...exports].join(`
+`);
+}
+async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
+  const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
+  if (entrypoints.length === 0) {
+    return "";
+  }
+  const entryDir = resolve2(configDir, ".devflare", "workflow-entrypoints");
+  const entryPath = join2(entryDir, "__entry.ts");
+  const outFile = join2(entryDir, "index.js");
+  await mkdir(entryDir, { recursive: true });
+  await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
+  await bundleWorkerEntry({
+    cwd: configDir,
+    inputFile: entryPath,
+    outFile,
+    rolldownOptions: config.rolldown?.options,
+    sourcemap: config.rolldown?.sourcemap,
+    minify: config.rolldown?.minify,
+    logger: options.logger
+  });
+  return await readFile(outFile, "utf-8");
+}
+
+export { buildQueueProducers, buildQueueConsumers, buildRateLimitsConfig, buildVersionMetadataConfig, buildWorkerLoadersConfig, buildMtlsCertificatesConfig, buildDispatchNamespacesConfig, buildWorkflowsConfig, buildPipelinesConfig, buildHyperdrivesConfig, buildImagesConfig, buildMediaConfig, buildArtifactsConfig, buildAiSearchNamespacesConfig, buildAiSearchInstancesConfig, buildSecretsStoreConfig, buildSendEmailConfig, bundleWorkflowEntrypointScript, clearBundleCache, hasServiceBindings, resolveServiceBindings, hasCrossWorkerDOs, resolveDOBindings };