devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/index-9an9qqr1.js

@@ -0,0 +1,728 @@
+import {
+  ConfigResourceResolutionError,
+  collectPendingNameBindings,
+  formatMissingBindings,
+  getLocalD1DatabaseIdentifier,
+  getLocalHyperdriveConfigIdentifier,
+  getLocalKVNamespaceIdentifier,
+  getSingleBrowserBindingName,
+  materializeIdBindings,
+  materializeResolvedNameBindings,
+  mergeConfigForEnvironment,
+  normalizeD1Binding,
+  normalizeD1NameBinding,
+  normalizeDOBinding,
+  normalizeHyperdriveBinding,
+  normalizeHyperdriveNameBinding,
+  normalizeKVBinding,
+  normalizeKVNameBinding,
+  resolveConfigForEnvironment,
+  withResolvedIdBindings
+} from "./index-5eswe8yv.js";
+import {
+  createD1Database,
+  createKVNamespace,
+  createQueue,
+  createR2Bucket,
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  listD1Databases,
+  listHyperdrives,
+  listKVNamespaces,
+  listQueues,
+  listR2Buckets,
+  listVectorizeIndexes
+} from "./index-gba371j7.js";
+import {
+  materializePreviewScopedConfig
+} from "./index-p296ban8.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/config/compiler.ts
+import { basename, isAbsolute, relative, resolve } from "pathe";
+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
+    };
+  }
+  if (options.preserveNamedBindings && normalized.name) {
+    return {
+      binding: bindingName,
+      name: normalized.name
+    };
+  }
+  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) {
+  const bindingName = getSingleBrowserBindingName(browserBindings);
+  return bindingName ? { binding: bindingName } : undefined;
+}
+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 compileConfig(config, environment) {
+  return compileConfigInternal(config, environment);
+}
+function compileBuildConfig(config, environment) {
+  return compileConfigInternal(config, environment, {
+    preserveNamedBindings: true
+  });
+}
+function compileConfigInternal(config, environment, options = {}) {
+  const mergedConfig = resolveConfigForEnvironment(config, environment);
+  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;
+  }
+  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.vars && Object.keys(mergedConfig.vars).length > 0) {
+    result.vars = mergedConfig.vars;
+  }
+  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 }
+    };
+  }
+  if (mergedConfig.observability) {
+    result.observability = mergedConfig.observability;
+  }
+  if (mergedConfig.limits) {
+    result.limits = mergedConfig.limits;
+  }
+  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.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.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 };
+  }
+  if (bindings.vectorize) {
+    result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
+      binding,
+      index_name: config.indexName
+    }));
+  }
+  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 = isAbsolute(pathValue) ? pathValue : resolve(projectRoot, pathValue);
+  return relative(configDir, absolutePath).replace(/\\/g, "/");
+}
+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)
+      }
+    } : {}
+  };
+}
+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/deploy-resources.ts
+var defaultDeployResourcePreparationApi = {
+  getPrimaryAccount,
+  getEffectiveAccountId,
+  listKVNamespaces,
+  createKVNamespace,
+  listD1Databases,
+  createD1Database,
+  listR2Buckets,
+  createR2Bucket,
+  listQueues,
+  createQueue,
+  listHyperdrives,
+  listVectorizeIndexes
+};
+function createEmptyDeployResourceNames() {
+  return {
+    kv: [],
+    d1: [],
+    r2: [],
+    queues: [],
+    vectorize: [],
+    hyperdrive: []
+  };
+}
+function decorateOrphanError(err, created) {
+  const summaryParts = [];
+  if (created.kv.length > 0)
+    summaryParts.push(`KV: ${created.kv.join(", ")}`);
+  if (created.d1.length > 0)
+    summaryParts.push(`D1: ${created.d1.join(", ")}`);
+  if (created.hyperdrive.length > 0)
+    summaryParts.push(`Hyperdrive: ${created.hyperdrive.join(", ")}`);
+  if (created.r2.length > 0)
+    summaryParts.push(`R2: ${created.r2.join(", ")}`);
+  if (created.queues.length > 0)
+    summaryParts.push(`Queues: ${created.queues.join(", ")}`);
+  if (created.vectorize.length > 0)
+    summaryParts.push(`Vectorize: ${created.vectorize.join(", ")}`);
+  const base = err instanceof Error ? err : new Error(String(err));
+  if (summaryParts.length === 0)
+    return base;
+  const orphanFooter = `
+
+Deploy preparation failed AFTER provisioning the following Cloudflare resources, ` + `which were left in your account:
+  - ${summaryParts.join(`
+  - `)}
+` + `Re-run \`devflare deploy\` after fixing the error to reuse them, or delete them manually if abandoning the deploy.`;
+  const decorated = new Error(`${base.message}${orphanFooter}`);
+  if ("cause" in base && base.cause !== undefined) {
+    decorated.cause = base.cause;
+  } else {
+    decorated.cause = base;
+  }
+  return decorated;
+}
+function resolveDeployResourcePreparationApi(overrides) {
+  return {
+    ...defaultDeployResourcePreparationApi,
+    ...overrides ?? {}
+  };
+}
+function resolveUniqueNames(values) {
+  const names = new Set;
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+      continue;
+    }
+    names.add(trimmed);
+  }
+  return [...names];
+}
+function collectQueueNames(config) {
+  const queues = config.bindings?.queues;
+  if (!queues) {
+    return [];
+  }
+  return resolveUniqueNames([
+    ...Object.values(queues.producers ?? {}),
+    ...(queues.consumers ?? []).flatMap((consumer) => [consumer.queue, consumer.deadLetterQueue])
+  ]);
+}
+function collectVectorizeIndexNames(config) {
+  return resolveUniqueNames(Object.values(config.bindings?.vectorize ?? {}).map((binding) => binding.indexName));
+}
+function resolveUniquePendingBindings(pendingBindings) {
+  return [...new Map(pendingBindings.map((binding) => [binding.resourceName, binding])).values()];
+}
+async function resolveLookupAccountId(config, options, cloudflareApi) {
+  const envAccountId = typeof process !== "undefined" ? process.env?.CLOUDFLARE_ACCOUNT_ID?.trim() : undefined;
+  const explicitAccountId = options.accountId ?? config.accountId ?? (envAccountId || undefined);
+  if (explicitAccountId) {
+    return explicitAccountId;
+  }
+  let primaryAccount;
+  try {
+    primaryAccount = await cloudflareApi.getPrimaryAccount();
+  } catch (error) {
+    throw new ConfigResourceResolutionError("Could not prepare Cloudflare-backed deploy resources because Devflare could not read your Cloudflare accounts. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.", error);
+  }
+  if (!primaryAccount) {
+    throw new ConfigResourceResolutionError("Could not prepare Cloudflare-backed deploy resources because no Cloudflare account is available. Set accountId in devflare.config.ts, configure a workspace/global default account, or log in with Wrangler.");
+  }
+  try {
+    const { accountId } = await cloudflareApi.getEffectiveAccountId(primaryAccount.id);
+    return accountId;
+  } catch (error) {
+    throw new ConfigResourceResolutionError(`Could not determine the effective Cloudflare account for deploy-time resource preparation after selecting primary account ${primaryAccount.id}.`, error);
+  }
+}
+async function resolveOrCreateResourceIdsByName(pendingBindings, options) {
+  if (pendingBindings.length === 0) {
+    return {
+      idsByName: new Map,
+      created: [],
+      existing: []
+    };
+  }
+  let resources;
+  try {
+    resources = await options.listResources();
+  } catch (error) {
+    throw new ConfigResourceResolutionError(options.listFailureMessage, error);
+  }
+  const idsByName = new Map(resources.map((resource) => [resource.name, resource.id]));
+  const created = [];
+  const existing = resolveUniquePendingBindings(pendingBindings).filter(({ resourceName }) => idsByName.has(resourceName)).map(({ resourceName }) => resourceName);
+  const missingBindings = resolveUniquePendingBindings(pendingBindings).filter(({ resourceName }) => !idsByName.has(resourceName));
+  if (missingBindings.length === 0) {
+    return {
+      idsByName,
+      created,
+      existing
+    };
+  }
+  if (!options.createResource) {
+    throw new ConfigResourceResolutionError(options.missingFailureMessage(missingBindings));
+  }
+  for (const missingBinding of missingBindings) {
+    try {
+      const createdResource = await options.createResource(missingBinding.resourceName);
+      idsByName.set(createdResource.name, createdResource.id);
+      created.push(createdResource.name);
+    } catch (error) {
+      throw new ConfigResourceResolutionError(options.createFailureMessage?.(missingBinding.resourceName) ?? `Could not create Cloudflare resource "${missingBinding.resourceName}" during deploy preparation.`, error);
+    }
+  }
+  return {
+    idsByName,
+    created,
+    existing
+  };
+}
+async function ensureNamedResourcesExist(resourceNames, options) {
+  if (resourceNames.length === 0) {
+    return {
+      created: [],
+      existing: []
+    };
+  }
+  let resources;
+  try {
+    resources = await options.listResources();
+  } catch (error) {
+    throw new ConfigResourceResolutionError(options.listFailureMessage, error);
+  }
+  const existingNames = new Set(resources.map((resource) => resource.name));
+  const existing = resourceNames.filter((resourceName) => existingNames.has(resourceName));
+  const missingNames = resourceNames.filter((resourceName) => !existingNames.has(resourceName));
+  const created = [];
+  if (missingNames.length === 0) {
+    return {
+      created,
+      existing
+    };
+  }
+  if (!options.createResource) {
+    throw new ConfigResourceResolutionError(options.missingFailureMessage(missingNames));
+  }
+  for (const resourceName of missingNames) {
+    try {
+      const createdResource = await options.createResource(resourceName);
+      created.push(createdResource.name);
+    } catch (error) {
+      throw new ConfigResourceResolutionError(options.createFailureMessage?.(resourceName) ?? `Could not create Cloudflare resource "${resourceName}" during deploy preparation.`, error);
+    }
+  }
+  return {
+    created,
+    existing
+  };
+}
+async function prepareMaterializedConfigResourcesForDeploy(resolvedConfig, options = {}) {
+  const created = createEmptyDeployResourceNames();
+  const existing = createEmptyDeployResourceNames();
+  const warnings = [];
+  const kvBindings = resolvedConfig.bindings?.kv;
+  const d1Bindings = resolvedConfig.bindings?.d1;
+  const hyperdriveBindings = resolvedConfig.bindings?.hyperdrive;
+  const r2Names = resolveUniqueNames(Object.values(resolvedConfig.bindings?.r2 ?? {}));
+  const queueNames = collectQueueNames(resolvedConfig);
+  const vectorizeNames = collectVectorizeIndexNames(resolvedConfig);
+  if (!kvBindings && !d1Bindings && !hyperdriveBindings && r2Names.length === 0 && queueNames.length === 0 && vectorizeNames.length === 0) {
+    return {
+      config: resolvedConfig,
+      created,
+      existing,
+      warnings
+    };
+  }
+  const pendingKVNameBindings = collectPendingNameBindings(kvBindings, normalizeKVNameBinding);
+  const pendingD1NameBindings = collectPendingNameBindings(d1Bindings, normalizeD1NameBinding);
+  const pendingHyperdriveNameBindings = collectPendingNameBindings(hyperdriveBindings, normalizeHyperdriveNameBinding);
+  if (pendingKVNameBindings.length === 0 && pendingD1NameBindings.length === 0 && pendingHyperdriveNameBindings.length === 0 && r2Names.length === 0 && queueNames.length === 0 && vectorizeNames.length === 0) {
+    return {
+      config: withResolvedIdBindings(resolvedConfig, {
+        kv: kvBindings ? materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : undefined,
+        d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : undefined,
+        hyperdrive: hyperdriveBindings ? materializeIdBindings(hyperdriveBindings, getLocalHyperdriveConfigIdentifier) : undefined
+      }),
+      created,
+      existing,
+      warnings
+    };
+  }
+  const cloudflareApi = resolveDeployResourcePreparationApi(options.cloudflare);
+  const accountId = await resolveLookupAccountId(resolvedConfig, options, cloudflareApi);
+  if (options.describeOnly) {
+    cloudflareApi.createKVNamespace = async (_acc, name) => ({ id: `<would-create:${name}>`, name });
+    cloudflareApi.createD1Database = async (_acc, name) => ({ id: `<would-create:${name}>`, name, version: "", tableCount: 0, sizeBytes: 0 });
+    cloudflareApi.createR2Bucket = async (_acc, name) => ({ name });
+    cloudflareApi.createQueue = async (_acc, name) => ({ id: `<would-create:${name}>`, name });
+  }
+  try {
+    const hyperdriveIdsByName = await resolveOrCreateResourceIdsByName(pendingHyperdriveNameBindings, {
+      listResources: async () => cloudflareApi.listHyperdrives(accountId),
+      listFailureMessage: `Could not list Hyperdrive configurations for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingBindings) => {
+        return `Could not find Hyperdrive configuration(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}. Cloudflare does not expose a create API that Devflare can use from only a binding name, so create the Hyperdrive config first or configure the binding with an explicit id.`;
+      }
+    });
+    created.hyperdrive.push(...hyperdriveIdsByName.created);
+    existing.hyperdrive.push(...hyperdriveIdsByName.existing);
+    const vectorizeState = await ensureNamedResourcesExist(vectorizeNames, {
+      listResources: async () => cloudflareApi.listVectorizeIndexes(accountId),
+      listFailureMessage: `Could not list Vectorize indexes for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingNames) => {
+        return `Could not find Vectorize index(es) ${missingNames.join(", ")} in Cloudflare account ${accountId}. Devflare can only auto-provision preview-scoped Vectorize indexes by cloning an existing base index; for normal deploys create the index first.`;
+      }
+    });
+    created.vectorize.push(...vectorizeState.created);
+    existing.vectorize.push(...vectorizeState.existing);
+    const namespaceIdsByName = await resolveOrCreateResourceIdsByName(pendingKVNameBindings, {
+      listResources: async () => cloudflareApi.listKVNamespaces(accountId),
+      createResource: async (resourceName) => cloudflareApi.createKVNamespace(accountId, resourceName),
+      listFailureMessage: `Could not list KV namespaces for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingBindings) => {
+        return `Could not find KV namespace(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}.`;
+      },
+      createFailureMessage: (resourceName) => {
+        return `Could not create KV namespace "${resourceName}" in Cloudflare account ${accountId} during deploy preparation.`;
+      }
+    });
+    created.kv.push(...namespaceIdsByName.created);
+    existing.kv.push(...namespaceIdsByName.existing);
+    const databaseIdsByName = await resolveOrCreateResourceIdsByName(pendingD1NameBindings, {
+      listResources: async () => cloudflareApi.listD1Databases(accountId),
+      createResource: async (resourceName) => cloudflareApi.createD1Database(accountId, resourceName),
+      listFailureMessage: `Could not list D1 databases for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingBindings) => {
+        return `Could not find D1 database(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}.`;
+      },
+      createFailureMessage: (resourceName) => {
+        return `Could not create D1 database "${resourceName}" in Cloudflare account ${accountId} during deploy preparation.`;
+      }
+    });
+    created.d1.push(...databaseIdsByName.created);
+    existing.d1.push(...databaseIdsByName.existing);
+    const r2State = await ensureNamedResourcesExist(r2Names, {
+      listResources: async () => cloudflareApi.listR2Buckets(accountId),
+      createResource: async (resourceName) => cloudflareApi.createR2Bucket(accountId, resourceName),
+      listFailureMessage: `Could not list R2 buckets for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingNames) => {
+        return `Could not find R2 bucket(s) ${missingNames.join(", ")} in Cloudflare account ${accountId}.`;
+      },
+      createFailureMessage: (resourceName) => {
+        return `Could not create R2 bucket "${resourceName}" in Cloudflare account ${accountId} during deploy preparation.`;
+      }
+    });
+    created.r2.push(...r2State.created);
+    existing.r2.push(...r2State.existing);
+    const queueState = await ensureNamedResourcesExist(queueNames, {
+      listResources: async () => cloudflareApi.listQueues(accountId),
+      createResource: async (resourceName) => cloudflareApi.createQueue(accountId, resourceName),
+      listFailureMessage: `Could not list Queues for Cloudflare account ${accountId} while preparing deploy resources.`,
+      missingFailureMessage: (missingNames) => {
+        return `Could not find Queue(s) ${missingNames.join(", ")} in Cloudflare account ${accountId}.`;
+      },
+      createFailureMessage: (resourceName) => {
+        return `Could not create Queue "${resourceName}" in Cloudflare account ${accountId} during deploy preparation.`;
+      }
+    });
+    created.queues.push(...queueState.created);
+    existing.queues.push(...queueState.existing);
+    const config = withResolvedIdBindings(resolvedConfig, {
+      kv: kvBindings ? pendingKVNameBindings.length > 0 ? materializeResolvedNameBindings(kvBindings, normalizeKVNameBinding, namespaceIdsByName.idsByName) : materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : undefined,
+      d1: d1Bindings ? pendingD1NameBindings.length > 0 ? materializeResolvedNameBindings(d1Bindings, normalizeD1NameBinding, databaseIdsByName.idsByName) : materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : undefined,
+      hyperdrive: hyperdriveBindings ? pendingHyperdriveNameBindings.length > 0 ? materializeResolvedNameBindings(hyperdriveBindings, normalizeHyperdriveNameBinding, hyperdriveIdsByName.idsByName) : materializeIdBindings(hyperdriveBindings, getLocalHyperdriveConfigIdentifier) : undefined
+    });
+    return {
+      config,
+      created,
+      existing,
+      warnings
+    };
+  } catch (err) {
+    throw decorateOrphanError(err, created);
+  }
+}
+async function prepareConfigResourcesForDeploy(config, options = {}) {
+  const resolvedConfig = materializePreviewScopedConfig(mergeConfigForEnvironment(config, options.environment), {
+    environment: options.environment,
+    env: options.env,
+    identifier: options.identifier
+  });
+  return prepareMaterializedConfigResourcesForDeploy(resolvedConfig, {
+    accountId: options.accountId,
+    cloudflare: options.cloudflare,
+    describeOnly: options.describeOnly
+  });
+}
+
+// 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 { compileConfig, compileBuildConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig, readWranglerConfig, prepareConfigResourcesForDeploy, ServiceBindingValidationError, validateServiceBindings };