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

package/dist/index-w3azfsa0.js

@@ -1,695 +0,0 @@
-import {
-  ConfigResourceResolutionError,
-  getLocalD1DatabaseIdentifier,
-  getLocalHyperdriveConfigIdentifier,
-  getLocalKVNamespaceIdentifier,
-  getSingleBrowserBindingName,
-  mergeConfigForEnvironment,
-  normalizeD1Binding,
-  normalizeDOBinding,
-  normalizeHyperdriveBinding,
-  normalizeKVBinding,
-  resolveConfigForEnvironment
-} from "./index-m2d74gqg.js";
-import {
-  createD1Database,
-  createKVNamespace,
-  createQueue,
-  createR2Bucket,
-  getEffectiveAccountId,
-  getPrimaryAccount,
-  listD1Databases,
-  listHyperdrives,
-  listKVNamespaces,
-  listQueues,
-  listR2Buckets,
-  listVectorizeIndexes
-} from "./index-95mmvbw7.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) {
-  return 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 resolveDeployResourcePreparationApi(overrides) {
-  return {
-    ...defaultDeployResourcePreparationApi,
-    ...overrides ?? {}
-  };
-}
-function materializeIdBindings(bindings, resolveId) {
-  return Object.fromEntries(Object.entries(bindings).map(([bindingName, bindingConfig]) => {
-    return [bindingName, { id: resolveId(bindingConfig) }];
-  }));
-}
-function collectPendingNameBindings(bindings, normalizeBinding) {
-  if (!bindings) {
-    return [];
-  }
-  return Object.entries(bindings).map(([bindingName, bindingConfig]) => {
-    const normalized = normalizeBinding(bindingConfig);
-    return normalized.id ? null : {
-      bindingName,
-      resourceName: normalized.name ?? ""
-    };
-  }).filter((binding) => binding !== null);
-}
-function materializeResolvedNameBindings(bindings, normalizeBinding, idsByName) {
-  if (!bindings) {
-    return;
-  }
-  return materializeIdBindings(bindings, (bindingConfig) => {
-    const normalized = normalizeBinding(bindingConfig);
-    return normalized.id ?? idsByName.get(normalized.name ?? "") ?? "";
-  });
-}
-function withResolvedIdBindings(resolvedConfig, bindings) {
-  return {
-    ...resolvedConfig,
-    bindings: {
-      ...resolvedConfig.bindings,
-      ...bindings.kv ? { kv: bindings.kv } : {},
-      ...bindings.d1 ? { d1: bindings.d1 } : {},
-      ...bindings.hyperdrive ? { hyperdrive: bindings.hyperdrive } : {}
-    }
-  };
-}
-function normalizeKVNameBinding(bindingConfig) {
-  const normalized = normalizeKVBinding(bindingConfig);
-  return {
-    id: normalized.namespaceId,
-    name: normalized.name
-  };
-}
-function normalizeD1NameBinding(bindingConfig) {
-  const normalized = normalizeD1Binding(bindingConfig);
-  return {
-    id: normalized.databaseId,
-    name: normalized.name
-  };
-}
-function normalizeHyperdriveNameBinding(bindingConfig) {
-  const normalized = normalizeHyperdriveBinding(bindingConfig);
-  return {
-    id: normalized.configurationId,
-    name: normalized.name
-  };
-}
-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 formatMissingBindings(missing) {
-  return missing.map(({ bindingName, resourceName }) => `${bindingName} → ${resourceName}`).join(", ");
-}
-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);
-  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 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 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 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 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
-  };
-}
-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
-  });
-}
-export { compileConfig, compileBuildConfig, compileToProgrammaticConfig, stringifyConfig, isolateViteBuildOutputPaths, rebaseWranglerConfigPaths, writeWranglerConfig, readWranglerConfig, prepareConfigResourcesForDeploy };