devflare 1.0.0-next.24 → 1.0.0-next.27

package/dist/index-e7kakw0j.js

@@ -1,1033 +0,0 @@
-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-0bv2qjs1.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 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
-      }
-    ]))
-  };
-}
-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 };