devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-hjjfxv02.js

@@ -0,0 +1,708 @@
+import {
+  browserBindingSchema,
+  getSingleBrowserBindingName,
+  normalizeArtifactsBinding,
+  normalizeCompatibilityFlags,
+  normalizeD1Binding,
+  normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeKVBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeSecretsStoreBinding,
+  normalizeWorkflowBinding,
+  resolveConfigForEnvironment
+} from "./index-dfcp9hsd.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/config/compiler/paths.ts
+import { basename, isAbsolute, relative, resolve } from "pathe";
+function stringifyConfig(config) {
+  const header = `// Generated by devflare — Do not edit directly
+// Edit devflare.config.ts instead
+
+`;
+  return header + JSON.stringify(config, null, "\t");
+}
+function rebasePathForConfigDir(projectRoot, configDir, pathValue) {
+  const absolutePath = isAbsolute(pathValue) ? pathValue : resolve(projectRoot, pathValue);
+  return relative(configDir, absolutePath).replace(/\\/g, "/");
+}
+function isLocalContainerPath(pathValue) {
+  return pathValue === "Dockerfile" || pathValue.startsWith(".") || pathValue.startsWith("/") || pathValue.startsWith("\\") || isAbsolute(pathValue) || pathValue.endsWith("/Dockerfile") || pathValue.endsWith("\\Dockerfile");
+}
+function pathIsInsideDirectory(directoryPath, candidatePath) {
+  const normalizedDirectoryPath = directoryPath.replace(/\\/g, "/");
+  const normalizedCandidatePath = candidatePath.replace(/\\/g, "/");
+  return normalizedCandidatePath === normalizedDirectoryPath || normalizedCandidatePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function isolateViteBuildOutputPaths(projectRoot, config) {
+  const assetsDirectory = config.assets?.directory;
+  if (!assetsDirectory) {
+    return config;
+  }
+  const isolatedAssetsDirectoryPath = resolve(projectRoot, ".devflare", "vite-build-output", basename(assetsDirectory));
+  const isolatedAssetsDirectory = relative(projectRoot, isolatedAssetsDirectoryPath).replace(/\\/g, "/");
+  const isolatedConfig = {
+    ...config,
+    assets: config.assets ? {
+      ...config.assets,
+      directory: isolatedAssetsDirectory
+    } : config.assets
+  };
+  if (!config.main) {
+    return isolatedConfig;
+  }
+  const originalAssetsDirectoryPath = resolve(projectRoot, assetsDirectory);
+  const originalMainEntryPath = resolve(projectRoot, config.main);
+  if (!pathIsInsideDirectory(originalAssetsDirectoryPath, originalMainEntryPath)) {
+    return isolatedConfig;
+  }
+  const relativeMainEntryPath = relative(originalAssetsDirectoryPath, originalMainEntryPath);
+  const isolatedMainEntryPath = resolve(isolatedAssetsDirectoryPath, relativeMainEntryPath);
+  return {
+    ...isolatedConfig,
+    main: relative(projectRoot, isolatedMainEntryPath).replace(/\\/g, "/")
+  };
+}
+function rebaseWranglerConfigPaths(projectRoot, configDir, config) {
+  return {
+    ...config,
+    ...config.main ? { main: rebasePathForConfigDir(projectRoot, configDir, config.main) } : {},
+    ...config.assets?.directory ? {
+      assets: {
+        ...config.assets,
+        directory: rebasePathForConfigDir(projectRoot, configDir, config.assets.directory)
+      }
+    } : {},
+    ...config.containers ? {
+      containers: config.containers.map((container) => ({
+        ...container,
+        image: isLocalContainerPath(container.image) ? rebasePathForConfigDir(projectRoot, configDir, container.image) : container.image,
+        ...container.image_build_context && {
+          image_build_context: rebasePathForConfigDir(projectRoot, configDir, container.image_build_context)
+        }
+      }))
+    } : {}
+  };
+}
+async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
+  const { resolve: resolve2 } = await import("pathe");
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.mkdir(cwd, { recursive: true });
+  } catch {}
+  const content = stringifyConfig(config);
+  const wranglerPath = resolve2(cwd, filename);
+  await fs.writeFile(wranglerPath, content, "utf-8");
+  return wranglerPath;
+}
+async function readWranglerConfig(filePath) {
+  const fs = await import("node:fs/promises");
+  const { parse } = await import("jsonc-parser");
+  const content = await fs.readFile(filePath, "utf-8");
+  const parsedConfig = parse(content);
+  if (!parsedConfig || typeof parsedConfig !== "object") {
+    throw new Error(`Could not parse Wrangler config at ${filePath}.`);
+  }
+  return parsedConfig;
+}
+
+// src/config/compiler/bindings.ts
+function getWranglerD1DatabaseBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeD1Binding(bindingConfig);
+  if (normalized.databaseId) {
+    return {
+      binding: bindingName,
+      database_id: normalized.databaseId
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      database_name: normalized.name
+    };
+  }
+  throw new Error(`D1 binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerKVNamespaceBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeKVBinding(bindingConfig);
+  if (normalized.namespaceId) {
+    return {
+      binding: bindingName,
+      id: normalized.namespaceId
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      name: normalized.name
+    };
+  }
+  throw new Error(`KV binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerHyperdriveBinding(bindingName, bindingConfig, options = {}) {
+  const normalized = normalizeHyperdriveBinding(bindingConfig);
+  if (normalized.configurationId) {
+    return {
+      binding: bindingName,
+      id: normalized.configurationId,
+      ...normalized.localConnectionString && {
+        localConnectionString: normalized.localConnectionString
+      }
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      name: normalized.name,
+      ...normalized.localConnectionString && {
+        localConnectionString: normalized.localConnectionString
+      }
+    };
+  }
+  throw new Error(`Hyperdrive binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerBrowserBinding(browserBindings) {
+  if (!browserBindings) {
+    return;
+  }
+  const parsed = browserBindingSchema.parse(browserBindings);
+  const bindingName = getSingleBrowserBindingName(parsed);
+  if (!bindingName) {
+    return;
+  }
+  const bindingConfig = parsed[bindingName];
+  return {
+    binding: bindingName,
+    ...typeof bindingConfig === "object" && bindingConfig.remote !== undefined && {
+      remote: bindingConfig.remote
+    }
+  };
+}
+function compileBindings(bindings, result, options = {}, defaultSecretsStoreId) {
+  if (bindings.kv) {
+    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, namespace]) => {
+      return getWranglerKVNamespaceBinding(binding, namespace, options);
+    });
+  }
+  if (bindings.d1) {
+    result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => {
+      return getWranglerD1DatabaseBinding(binding, database_id, options);
+    });
+  }
+  if (bindings.r2) {
+    result.r2_buckets = Object.entries(bindings.r2).map(([binding, bucket_name]) => ({
+      binding,
+      bucket_name
+    }));
+  }
+  if (bindings.durableObjects) {
+    result.durable_objects = {
+      bindings: Object.entries(bindings.durableObjects).map(([name, config]) => {
+        const normalized = normalizeDOBinding(config);
+        const binding = {
+          name,
+          class_name: normalized.className
+        };
+        if (normalized.kind === "cross-worker" && normalized.scriptName) {
+          binding.script_name = normalized.scriptName;
+        }
+        return binding;
+      })
+    };
+  }
+  if (bindings.queues) {
+    result.queues = {};
+    if (bindings.queues.producers) {
+      result.queues.producers = Object.entries(bindings.queues.producers).map(([binding, queue]) => ({ binding, queue }));
+    }
+    if (bindings.queues.consumers) {
+      result.queues.consumers = bindings.queues.consumers.map((consumer) => ({
+        queue: consumer.queue,
+        ...consumer.maxBatchSize && { max_batch_size: consumer.maxBatchSize },
+        ...consumer.maxBatchTimeout && { max_batch_timeout: consumer.maxBatchTimeout },
+        ...consumer.maxRetries && { max_retries: consumer.maxRetries },
+        ...consumer.deadLetterQueue && { dead_letter_queue: consumer.deadLetterQueue },
+        ...consumer.maxConcurrency && { max_concurrency: consumer.maxConcurrency },
+        ...consumer.retryDelay && { retry_delay: consumer.retryDelay }
+      }));
+    }
+  }
+  if (bindings.rateLimits) {
+    result.ratelimits = Object.entries(bindings.rateLimits).map(([name, config]) => ({
+      name,
+      namespace_id: config.namespaceId,
+      simple: {
+        limit: config.simple.limit,
+        period: config.simple.period
+      }
+    }));
+  }
+  if (bindings.versionMetadata) {
+    result.version_metadata = {
+      binding: bindings.versionMetadata.binding
+    };
+  }
+  if (bindings.workerLoaders) {
+    result.worker_loaders = Object.keys(bindings.workerLoaders).map((binding) => ({ binding }));
+  }
+  if (bindings.mtlsCertificates) {
+    result.mtls_certificates = Object.entries(bindings.mtlsCertificates).map(([binding, config]) => {
+      const normalized = normalizeMtlsCertificateBinding(config);
+      return {
+        binding,
+        certificate_id: normalized.certificateId,
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    });
+  }
+  if (bindings.dispatchNamespaces) {
+    result.dispatch_namespaces = Object.entries(bindings.dispatchNamespaces).map(([binding, config]) => {
+      const normalized = normalizeDispatchNamespaceBinding(config);
+      return {
+        binding,
+        namespace: normalized.namespace,
+        ...normalized.outbound && { outbound: normalized.outbound },
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    });
+  }
+  if (bindings.workflows) {
+    result.workflows = Object.entries(bindings.workflows).map(([binding, config]) => {
+      const normalized = normalizeWorkflowBinding(config);
+      return {
+        binding,
+        name: normalized.name,
+        class_name: normalized.className,
+        ...normalized.scriptName && { script_name: normalized.scriptName },
+        ...normalized.remote !== undefined && { remote: normalized.remote },
+        ...normalized.limits && { limits: normalized.limits }
+      };
+    });
+  }
+  if (bindings.pipelines) {
+    result.pipelines = Object.entries(bindings.pipelines).map(([binding, config]) => {
+      const normalized = normalizePipelineBinding(config);
+      return {
+        binding,
+        pipeline: normalized.pipeline,
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    });
+  }
+  if (bindings.images) {
+    const [entry] = Object.entries(bindings.images);
+    if (entry) {
+      const [binding, config] = entry;
+      const normalized = normalizeImagesBinding(binding, config);
+      result.images = {
+        binding: normalized.binding,
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    }
+  }
+  if (bindings.media) {
+    const [entry] = Object.entries(bindings.media);
+    if (entry) {
+      const [binding, config] = entry;
+      const normalized = normalizeMediaBinding(binding, config);
+      result.media = {
+        binding: normalized.binding,
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    }
+  }
+  if (bindings.artifacts) {
+    result.artifacts = Object.entries(bindings.artifacts).map(([binding, config]) => {
+      const normalized = normalizeArtifactsBinding(config);
+      return {
+        binding,
+        namespace: normalized.namespace,
+        ...normalized.remote !== undefined && { remote: normalized.remote }
+      };
+    });
+  }
+  if (bindings.secretsStore) {
+    result.secrets_store_secrets = Object.entries(bindings.secretsStore).map(([binding, config]) => {
+      const normalized = normalizeSecretsStoreBinding(config, defaultSecretsStoreId, binding);
+      return {
+        binding,
+        store_id: normalized.storeId,
+        secret_name: normalized.secretName
+      };
+    });
+  }
+  if (bindings.services) {
+    result.services = Object.entries(bindings.services).map(([binding, config]) => ({
+      binding,
+      service: config.service,
+      ...config.entrypoint && { entrypoint: config.entrypoint },
+      ...config.environment && { environment: config.environment }
+    }));
+  }
+  if (bindings.ai?.binding) {
+    result.ai = {
+      binding: bindings.ai.binding,
+      ...bindings.ai.remote !== undefined && { remote: bindings.ai.remote },
+      ...bindings.ai.staging !== undefined && { staging: bindings.ai.staging }
+    };
+  }
+  if (bindings.aiSearchNamespaces) {
+    result.ai_search_namespaces = Object.entries(bindings.aiSearchNamespaces).map(([binding, config]) => ({
+      binding,
+      namespace: config.namespace,
+      ...config.remote !== undefined && { remote: config.remote }
+    }));
+  }
+  if (bindings.aiSearch) {
+    result.ai_search = Object.entries(bindings.aiSearch).map(([binding, config]) => ({
+      binding,
+      instance_name: config.instanceName,
+      ...config.remote !== undefined && { remote: config.remote }
+    }));
+  }
+  if (bindings.vectorize) {
+    result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
+      binding,
+      index_name: config.indexName,
+      ...config.remote !== undefined && { remote: config.remote }
+    }));
+  }
+  if (bindings.hyperdrive) {
+    result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => {
+      return getWranglerHyperdriveBinding(binding, config, options);
+    });
+  }
+  const browserBinding = getWranglerBrowserBinding(bindings.browser);
+  if (browserBinding) {
+    result.browser = browserBinding;
+  }
+  if (bindings.analyticsEngine) {
+    result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
+      binding,
+      dataset: config.dataset
+    }));
+  }
+  if (bindings.sendEmail) {
+    result.send_email = Object.entries(bindings.sendEmail).map(([name, config]) => ({
+      name,
+      ...config.destinationAddress && {
+        destination_address: config.destinationAddress
+      },
+      ...config.allowedDestinationAddresses && {
+        allowed_destination_addresses: config.allowedDestinationAddresses
+      },
+      ...config.allowedSenderAddresses && {
+        allowed_sender_addresses: config.allowedSenderAddresses
+      }
+    }));
+  }
+}
+
+// src/config/compiler/core-helpers.ts
+function compileWranglerMigrations(migrations) {
+  return migrations.map((migration) => ({
+    tag: migration.tag,
+    ...migration.new_classes && { new_classes: migration.new_classes },
+    ...migration.renamed_classes && {
+      renamed_classes: migration.renamed_classes.map((renamedClass) => ({
+        from: renamedClass.from,
+        to: renamedClass.to
+      }))
+    },
+    ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
+    ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
+  }));
+}
+function compileModuleOptions(config, result) {
+  if (config.rules && config.rules.length > 0) {
+    result.rules = config.rules;
+  }
+  if (config.findAdditionalModules !== undefined) {
+    result.find_additional_modules = config.findAdditionalModules;
+  }
+  if (config.baseDir) {
+    result.base_dir = config.baseDir;
+  }
+  if (config.preserveFileNames !== undefined) {
+    result.preserve_file_names = config.preserveFileNames;
+  }
+  if (config.logpush !== undefined) {
+    result.logpush = config.logpush;
+  }
+  if (config.uploadSourceMaps !== undefined) {
+    result.upload_source_maps = config.uploadSourceMaps;
+  }
+  if (config.keepVars !== undefined) {
+    result.keep_vars = config.keepVars;
+  }
+}
+function compileContainers(config, result) {
+  if (!config.containers || config.containers.length === 0) {
+    return;
+  }
+  result.containers = config.containers.map((container) => ({
+    class_name: container.className,
+    image: container.image,
+    ...container.maxInstances !== undefined && { max_instances: container.maxInstances },
+    ...container.instanceType && { instance_type: container.instanceType },
+    ...container.name && { name: container.name },
+    ...container.imageBuildContext && { image_build_context: container.imageBuildContext },
+    ...container.imageVars && { image_vars: container.imageVars },
+    ...container.rolloutActiveGracePeriod !== undefined && {
+      rollout_active_grace_period: container.rolloutActiveGracePeriod
+    },
+    ...container.rolloutStepPercentage !== undefined && {
+      rollout_step_percentage: container.rolloutStepPercentage
+    }
+  }));
+}
+
+// src/config/local-dev-vars.ts
+import { readFile } from "node:fs/promises";
+import { resolve as resolve2 } from "pathe";
+function parseEnvValue(value) {
+  const trimmed = value.trim();
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
+    const inner = trimmed.slice(1, -1);
+    return quote === '"' ? inner.replace(/\\n/g, `
+`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\") : inner;
+  }
+  const commentIndex = trimmed.search(/\s+#/);
+  return (commentIndex >= 0 ? trimmed.slice(0, commentIndex) : trimmed).trimEnd();
+}
+function parseEnvFile(contents) {
+  const vars = {};
+  for (const line of contents.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const assignment = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trimStart() : trimmed;
+    const equalsIndex = assignment.indexOf("=");
+    if (equalsIndex <= 0) {
+      continue;
+    }
+    const key = assignment.slice(0, equalsIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      continue;
+    }
+    vars[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
+  }
+  return vars;
+}
+async function readOptionalEnvFile(filePath) {
+  try {
+    return parseEnvFile(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function loadWranglerCompatibleLocalVars(cwd, environment) {
+  const environmentDevVars = environment ? await readOptionalEnvFile(resolve2(cwd, `.dev.vars.${environment}`)) : null;
+  if (environmentDevVars) {
+    return environmentDevVars;
+  }
+  const devVars = await readOptionalEnvFile(resolve2(cwd, ".dev.vars"));
+  if (devVars) {
+    return devVars;
+  }
+  const envFiles = [
+    ".env",
+    ".env.local",
+    ...environment ? [`.env.${environment}`, `.env.${environment}.local`] : []
+  ];
+  const merged = {};
+  for (const fileName of envFiles) {
+    const values = await readOptionalEnvFile(resolve2(cwd, fileName));
+    if (values) {
+      Object.assign(merged, values);
+    }
+  }
+  return merged;
+}
+function toWranglerSecretsConfig(secrets) {
+  if (!secrets) {
+    return;
+  }
+  const required = Object.entries(secrets).filter(([, config]) => config.required !== false).map(([name]) => name).sort();
+  return required.length > 0 ? { required } : undefined;
+}
+async function loadLocalDevVars(options) {
+  const activeEnvironment = options.environment ?? process.env.CLOUDFLARE_ENV;
+  const localVars = await loadWranglerCompatibleLocalVars(options.cwd, activeEnvironment);
+  const secretNames = toWranglerSecretsConfig(options.secrets)?.required;
+  const filteredLocalVars = secretNames ? Object.fromEntries(Object.entries(localVars).filter(([name]) => secretNames.includes(name))) : localVars;
+  return {
+    ...options.vars ?? {},
+    ...filteredLocalVars
+  };
+}
+async function applyLocalDevVarsToConfig(config, options) {
+  const vars = await loadLocalDevVars({
+    ...options,
+    vars: config.vars,
+    secrets: config.secrets
+  });
+  if (Object.keys(vars).length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    vars
+  };
+}
+
+// src/config/compiler/do-workers.ts
+import { resolve as resolve3 } from "pathe";
+
+// src/config/compiler.ts
+function compileConfig(config, environment) {
+  return compileConfigInternal(config, environment);
+}
+function compileBuildConfig(config, environment, options = {}) {
+  return compileConfigInternal(config, environment, {
+    preserveNamedBindings: true,
+    alreadyResolved: options.alreadyResolved
+  });
+}
+function compileConfigInternal(config, environment, options = {}) {
+  const resolvedConfig = options.alreadyResolved ? config : resolveConfigForEnvironment(config, environment);
+  const mergedConfig = {
+    ...resolvedConfig,
+    compatibilityFlags: normalizeCompatibilityFlags(resolvedConfig.compatibilityFlags)
+  };
+  const result = {
+    name: mergedConfig.name,
+    compatibility_date: mergedConfig.compatibilityDate,
+    preview_urls: true,
+    workers_dev: true
+  };
+  if (mergedConfig.accountId) {
+    result.account_id = mergedConfig.accountId;
+  }
+  const mainEntry = mergedConfig.files?.fetch;
+  if (typeof mainEntry === "string") {
+    result.main = mainEntry;
+  }
+  compileModuleOptions(mergedConfig, result);
+  if (mergedConfig.compatibilityFlags && mergedConfig.compatibilityFlags.length > 0) {
+    result.compatibility_flags = mergedConfig.compatibilityFlags;
+  }
+  if (mergedConfig.bindings) {
+    compileBindings(mergedConfig.bindings, result, options, mergedConfig.secretsStoreId);
+  }
+  if (mergedConfig.triggers?.crons && mergedConfig.triggers.crons.length > 0) {
+    result.triggers = { crons: mergedConfig.triggers.crons };
+  }
+  if (mergedConfig.tailConsumers && mergedConfig.tailConsumers.length > 0) {
+    result.tail_consumers = mergedConfig.tailConsumers.map((consumer) => typeof consumer === "string" ? { service: consumer } : {
+      service: consumer.service,
+      ...consumer.environment && { environment: consumer.environment }
+    });
+  }
+  if (mergedConfig.vars && Object.keys(mergedConfig.vars).length > 0) {
+    result.vars = mergedConfig.vars;
+  }
+  const secrets = toWranglerSecretsConfig(mergedConfig.secrets);
+  if (secrets) {
+    result.secrets = secrets;
+  }
+  if (mergedConfig.routes && mergedConfig.routes.length > 0) {
+    result.routes = mergedConfig.routes.map((route) => ({
+      pattern: route.pattern,
+      ...route.zone_name && { zone_name: route.zone_name },
+      ...route.zone_id && { zone_id: route.zone_id },
+      ...route.custom_domain !== undefined && { custom_domain: route.custom_domain }
+    }));
+  }
+  if (mergedConfig.assets?.directory) {
+    result.assets = {
+      directory: mergedConfig.assets.directory,
+      ...mergedConfig.assets.binding && { binding: mergedConfig.assets.binding },
+      ...mergedConfig.assets.html_handling && {
+        html_handling: mergedConfig.assets.html_handling
+      },
+      ...mergedConfig.assets.not_found_handling && {
+        not_found_handling: mergedConfig.assets.not_found_handling
+      },
+      ...mergedConfig.assets.run_worker_first !== undefined && {
+        run_worker_first: mergedConfig.assets.run_worker_first
+      }
+    };
+  }
+  if (mergedConfig.placement) {
+    result.placement = mergedConfig.placement;
+  }
+  if (mergedConfig.observability) {
+    result.observability = mergedConfig.observability;
+  }
+  if (mergedConfig.limits) {
+    result.limits = mergedConfig.limits;
+  }
+  compileContainers(mergedConfig, result);
+  if (mergedConfig.migrations && mergedConfig.migrations.length > 0) {
+    result.migrations = compileWranglerMigrations(mergedConfig.migrations);
+  }
+  if (mergedConfig.wrangler?.passthrough) {
+    Object.assign(result, mergedConfig.wrangler.passthrough);
+  }
+  return result;
+}
+function compileToProgrammaticConfig(config, environment, options = {}) {
+  return options.preserveNamedBindings ? compileBuildConfig(config, environment) : compileConfig(config, environment);
+}
+// src/config/service-bindings-validation.ts
+class ServiceBindingValidationError extends Error {
+  code = "SERVICE_BINDING_VALIDATION_ERROR";
+  missing;
+  constructor(missing, accountId) {
+    super(`Service binding(s) reference worker(s) that do not exist in Cloudflare account ${accountId}: ` + missing.join(", ") + `. Check the 'services' map in devflare.config.ts for typos or deploy the target worker(s) first.`);
+    this.name = "ServiceBindingValidationError";
+    this.missing = missing;
+  }
+}
+function collectReferencedServiceNames(config) {
+  const services = config.bindings?.services;
+  if (!services) {
+    return [];
+  }
+  const names = new Set;
+  for (const binding of Object.values(services)) {
+    if (binding && typeof binding === "object" && typeof binding.service === "string") {
+      const name = binding.service.trim();
+      if (name.length > 0) {
+        names.add(name);
+      }
+    }
+  }
+  return [...names];
+}
+async function validateServiceBindings(config, accountId, options) {
+  const referenced = collectReferencedServiceNames(config);
+  if (referenced.length === 0) {
+    return;
+  }
+  const selfName = options.selfWorkerName?.trim();
+  const toValidate = selfName ? referenced.filter((name) => name !== selfName) : referenced;
+  if (toValidate.length === 0) {
+    return;
+  }
+  const workers = await options.listWorkers(accountId);
+  const workerNames = new Set(workers.map((worker) => worker.name));
+  const missing = toValidate.filter((name) => !workerNames.has(name));
+  if (missing.length > 0) {
+    throw new ServiceBindingValidationError(missing, accountId);
+  }
+}
+export { applyLocalDevVarsToConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig, readWranglerConfig, compileConfig, compileBuildConfig, compileToProgrammaticConfig, ServiceBindingValidationError, validateServiceBindings };