devflare 1.0.0-next.2 → 1.0.0-next.20

package/dist/index-8052df4m.js

@@ -0,0 +1,627 @@
+import {
+  browserBindingSchema,
+  getSingleBrowserBindingName,
+  normalizeArtifactsBinding,
+  normalizeCompatibilityFlags,
+  normalizeD1Binding,
+  normalizeDOBinding,
+  normalizeDispatchNamespaceBinding,
+  normalizeHyperdriveBinding,
+  normalizeImagesBinding,
+  normalizeKVBinding,
+  normalizeMediaBinding,
+  normalizeMtlsCertificateBinding,
+  normalizePipelineBinding,
+  normalizeWorkflowBinding,
+  resolveConfigForEnvironment
+} from "./index-g5aq66bj.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/config/compiler.ts
+import { basename, isAbsolute as isAbsolute2, relative, resolve as resolve2 } from "pathe";
+
+// src/config/local-dev-vars.ts
+import { isAbsolute, resolve } from "pathe";
+function resolveConfigPath(cwd, configPath) {
+  if (!configPath) {
+    return resolve(cwd, "devflare.config.ts");
+  }
+  return isAbsolute(configPath) ? configPath : resolve(cwd, configPath);
+}
+function stringifyBindingValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+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 wrangler = await import("wrangler");
+  const configPath = resolveConfigPath(options.cwd, options.configPath);
+  const activeEnvironment = options.environment ?? process.env.CLOUDFLARE_ENV;
+  const bindings = wrangler.unstable_getVarsForDev(configPath, undefined, options.vars ?? {}, activeEnvironment, options.silent ?? true, toWranglerSecretsConfig(options.secrets));
+  return Object.fromEntries(Object.entries(bindings).map(([name, binding]) => [name, stringifyBindingValue(binding.value)]));
+}
+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.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 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;
+  }
+}
+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
+    }
+  }));
+}
+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);
+  }
+  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 && 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);
+}
+function compileBindings(bindings, result, options = {}) {
+  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]) => ({
+      binding,
+      store_id: config.storeId,
+      secret_name: config.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 && 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
+      }
+    }));
+  }
+}
+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 = isAbsolute2(pathValue) ? pathValue : resolve2(projectRoot, pathValue);
+  return relative(configDir, absolutePath).replace(/\\/g, "/");
+}
+function isLocalContainerPath(pathValue) {
+  return pathValue === "Dockerfile" || pathValue.startsWith(".") || pathValue.startsWith("/") || pathValue.startsWith("\\") || isAbsolute2(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 = resolve2(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 = resolve2(projectRoot, assetsDirectory);
+  const originalMainEntryPath = resolve2(projectRoot, config.main);
+  if (!pathIsInsideDirectory(originalAssetsDirectoryPath, originalMainEntryPath)) {
+    return isolatedConfig;
+  }
+  const relativeMainEntryPath = relative(originalAssetsDirectoryPath, originalMainEntryPath);
+  const isolatedMainEntryPath = resolve2(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: resolve3 } = await import("pathe");
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.mkdir(cwd, { recursive: true });
+  } catch {}
+  const content = stringifyConfig(config);
+  const wranglerPath = resolve3(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/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, compileConfig, compileBuildConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig, readWranglerConfig, ServiceBindingValidationError, validateServiceBindings };