devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-6zd89k6y.js

@@ -0,0 +1,1230 @@
+import {
+  createD1Database,
+  createKVNamespace,
+  createQueue,
+  createR2Bucket,
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  listD1Databases,
+  listHyperdrives,
+  listKVNamespaces,
+  listQueues,
+  listR2Buckets,
+  listVectorizeIndexes
+} from "./index-gba371j7.js";
+import {
+  materializePreviewScopedConfig
+} from "./index-p296ban8.js";
+
+// src/config/schema-bindings.ts
+import { z } from "zod";
+var durableObjectBindingSchema = z.custom((val) => {
+  if (typeof val === "string") {
+    return true;
+  }
+  if (val && typeof val === "object" && "className" in val) {
+    const obj = val;
+    return typeof obj.className === "string";
+  }
+  return false;
+}, {
+  message: "Expected string or { className: string, scriptName?: string }"
+});
+var queueConsumerSchema = z.object({
+  queue: z.string(),
+  maxBatchSize: z.number().optional(),
+  maxBatchTimeout: z.number().optional(),
+  maxRetries: z.number().optional(),
+  deadLetterQueue: z.string().optional(),
+  maxConcurrency: z.number().optional(),
+  retryDelay: z.number().optional()
+});
+var queuesConfigSchema = z.object({
+  producers: z.record(z.string(), z.string()).optional(),
+  consumers: z.array(queueConsumerSchema).optional()
+});
+var serviceBindingSchema = z.custom((val) => {
+  if (typeof val !== "object" && typeof val !== "function") {
+    return false;
+  }
+  const obj = val;
+  return typeof obj.service === "string";
+}, {
+  message: "Expected service binding object with { service: string } or ref().worker"
+});
+var aiBindingSchema = z.object({
+  binding: z.string()
+});
+var vectorizeBindingSchema = z.object({
+  indexName: z.string()
+});
+var hyperdriveBindingByIdSchema = z.object({
+  id: z.string()
+}).strict();
+var hyperdriveBindingByNameSchema = z.object({
+  name: z.string(),
+  previewFallback: z.literal("base").optional(),
+  previewId: z.string().optional(),
+  previewLocalConnectionString: z.string().optional()
+}).strict();
+var hyperdriveBindingSchema = z.union([
+  z.string(),
+  hyperdriveBindingByIdSchema,
+  hyperdriveBindingByNameSchema
+]);
+var SINGLE_BROWSER_BINDING_ERROR_MESSAGE = "Devflare currently supports exactly one browser binding because Wrangler only supports a single browser binding.";
+function formatBrowserBindingLimitMessage(bindingNames) {
+  if (bindingNames.length <= 1) {
+    return SINGLE_BROWSER_BINDING_ERROR_MESSAGE;
+  }
+  return `${SINGLE_BROWSER_BINDING_ERROR_MESSAGE} Configured bindings: ${bindingNames.join(", ")}`;
+}
+function getBrowserBindingNames(bindings) {
+  return bindings ? Object.keys(bindings) : [];
+}
+var browserBindingSchema = z.record(z.string(), z.string()).superRefine((bindings, ctx) => {
+  const bindingNames = getBrowserBindingNames(bindings);
+  if (bindingNames.length > 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: formatBrowserBindingLimitMessage(bindingNames)
+    });
+  }
+});
+var analyticsBindingSchema = z.object({
+  dataset: z.string()
+});
+var sendEmailBindingSchema = z.object({
+  destinationAddress: z.string().optional(),
+  allowedDestinationAddresses: z.array(z.string()).optional(),
+  allowedSenderAddresses: z.array(z.string()).optional()
+}).refine((binding) => {
+  return !(binding.destinationAddress && binding.allowedDestinationAddresses);
+}, {
+  message: "sendEmail bindings must use either destinationAddress or allowedDestinationAddresses, not both",
+  path: ["allowedDestinationAddresses"]
+});
+var d1BindingByIdSchema = z.object({
+  id: z.string()
+}).strict();
+var d1BindingByNameSchema = z.object({
+  name: z.string()
+}).strict();
+var d1BindingSchema = z.union([
+  z.string(),
+  d1BindingByIdSchema,
+  d1BindingByNameSchema
+]);
+var kvBindingByIdSchema = z.object({
+  id: z.string()
+}).strict();
+var kvBindingByNameSchema = z.object({
+  name: z.string()
+}).strict();
+var kvBindingSchema = z.union([
+  z.string(),
+  kvBindingByIdSchema,
+  kvBindingByNameSchema
+]);
+var mtlsCertificateBindingSchema = z.union([
+  z.string(),
+  z.object({
+    certificate_id: z.string()
+  }).strict()
+]);
+var dispatchNamespaceBindingSchema = z.union([
+  z.string(),
+  z.object({
+    namespace: z.string(),
+    outbound: z.object({
+      service: z.string(),
+      environment: z.string().optional(),
+      parameters: z.array(z.string()).optional()
+    }).optional()
+  }).strict()
+]);
+var workflowBindingSchema = z.object({
+  name: z.string(),
+  className: z.string(),
+  scriptName: z.string().optional()
+}).strict();
+var pipelineBindingSchema = z.union([
+  z.string(),
+  z.object({
+    pipeline: z.string()
+  }).strict()
+]);
+var imagesBindingSchema = z.object({}).strict().or(z.literal(true));
+var bindingsSchema = z.object({
+  kv: z.record(z.string(), kvBindingSchema).optional(),
+  d1: z.record(z.string(), d1BindingSchema).optional(),
+  r2: z.record(z.string(), z.string()).optional(),
+  durableObjects: z.record(z.string(), durableObjectBindingSchema).optional(),
+  queues: queuesConfigSchema.optional(),
+  services: z.record(z.string(), serviceBindingSchema).optional(),
+  ai: aiBindingSchema.optional(),
+  vectorize: z.record(z.string(), vectorizeBindingSchema).optional(),
+  hyperdrive: z.record(z.string(), hyperdriveBindingSchema).optional(),
+  browser: browserBindingSchema.optional(),
+  analyticsEngine: z.record(z.string(), analyticsBindingSchema).optional(),
+  sendEmail: z.record(z.string(), sendEmailBindingSchema).optional(),
+  mtlsCertificates: z.record(z.string(), mtlsCertificateBindingSchema).optional(),
+  dispatchNamespaces: z.record(z.string(), dispatchNamespaceBindingSchema).optional(),
+  workflows: z.record(z.string(), workflowBindingSchema).optional(),
+  pipelines: z.record(z.string(), pipelineBindingSchema).optional(),
+  images: z.record(z.string(), imagesBindingSchema).optional()
+}).optional();
+
+// src/config/schema-normalization.ts
+function getSingleBrowserBindingName(bindings) {
+  const bindingNames = getBrowserBindingNames(bindings);
+  if (bindingNames.length === 0) {
+    return;
+  }
+  return bindingNames[0];
+}
+function normalizeDOBinding(config) {
+  if (typeof config === "string") {
+    return { className: config, kind: "local" };
+  }
+  const scriptName = config.scriptName;
+  const __ref = config.__ref;
+  const kind = scriptName || __ref ? "cross-worker" : "local";
+  return {
+    className: config.className,
+    scriptName,
+    __ref,
+    kind
+  };
+}
+function normalizeD1Binding(config) {
+  if (typeof config === "string") {
+    return { name: config };
+  }
+  if ("id" in config) {
+    return { databaseId: config.id };
+  }
+  return { name: config.name };
+}
+function normalizeKVBinding(config) {
+  if (typeof config === "string") {
+    return { name: config };
+  }
+  if ("id" in config) {
+    return { namespaceId: config.id };
+  }
+  return { name: config.name };
+}
+function normalizeHyperdriveBinding(config) {
+  if (typeof config === "string") {
+    return { name: config };
+  }
+  if ("id" in config) {
+    return { configurationId: config.id };
+  }
+  return { name: config.name };
+}
+function getLocalKVNamespaceIdentifier(config) {
+  const normalized = normalizeKVBinding(config);
+  return normalized.namespaceId ?? normalized.name ?? "";
+}
+function getLocalD1DatabaseIdentifier(config) {
+  const normalized = normalizeD1Binding(config);
+  return normalized.databaseId ?? normalized.name ?? "";
+}
+function getLocalHyperdriveConfigIdentifier(config) {
+  const normalized = normalizeHyperdriveBinding(config);
+  return normalized.configurationId ?? normalized.name ?? "";
+}
+
+// src/config/schema.ts
+import { z as z5 } from "zod";
+
+// src/config/compatibility.ts
+var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
+function normalizeCompatibilityFlags(flags = []) {
+  return [...new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags])];
+}
+
+// src/config/schema-build.ts
+import { z as z2 } from "zod";
+var rolldownOptionsSchema = z2.custom((value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}, {
+  message: "Expected Rolldown options object"
+});
+var rolldownConfigSchema = z2.object({
+  target: z2.string().optional(),
+  minify: z2.boolean().optional(),
+  sourcemap: z2.boolean().optional(),
+  options: rolldownOptionsSchema.optional()
+}).optional();
+var viteConfigSchema = z2.object({
+  plugins: z2.array(z2.unknown()).optional()
+}).catchall(z2.unknown()).optional();
+
+// src/config/schema-env.ts
+import { z as z3 } from "zod";
+var envConfigSchema = z3.lazy(() => z3.object(rootConfigShape).omit({ accountId: true, wsRoutes: true }).partial().strict());
+var envConfigSchemaInner = envConfigSchema;
+
+// src/config/schema-runtime.ts
+import { z as z4 } from "zod";
+var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+var compatibilityDateSchema = z4.string().regex(dateRegex, {
+  message: "Compatibility date must be in YYYY-MM-DD format"
+});
+var routesConfigSchema = z4.object({
+  dir: z4.string(),
+  prefix: z4.string().optional()
+});
+var filesSchema = z4.object({
+  fetch: z4.union([z4.string(), z4.literal(false)]).optional(),
+  queue: z4.union([z4.string(), z4.literal(false)]).optional(),
+  scheduled: z4.union([z4.string(), z4.literal(false)]).optional(),
+  email: z4.union([z4.string(), z4.literal(false)]).optional(),
+  durableObjects: z4.union([z4.string(), z4.literal(false)]).optional(),
+  entrypoints: z4.union([z4.string(), z4.literal(false)]).optional(),
+  workflows: z4.union([z4.string(), z4.literal(false)]).optional(),
+  routes: z4.union([routesConfigSchema, z4.literal(false)]).optional(),
+  transport: z4.union([z4.string(), z4.null()]).optional()
+}).optional();
+var triggersSchema = z4.object({
+  crons: z4.array(z4.string()).optional()
+}).optional();
+var previewsConfigSchema = z4.object({
+  includeCrons: z4.boolean().optional().default(false)
+}).optional();
+var secretConfigSchema = z4.object({
+  required: z4.boolean().optional().default(true)
+});
+var routeConfigSchema = z4.object({
+  pattern: z4.string(),
+  zone_name: z4.string().optional(),
+  zone_id: z4.string().optional(),
+  custom_domain: z4.boolean().optional()
+});
+var wsRouteConfigSchema = z4.object({
+  pattern: z4.string(),
+  doNamespace: z4.string(),
+  idParam: z4.string().default("id"),
+  forwardPath: z4.string().default("/websocket")
+});
+var assetsConfigSchema = z4.object({
+  directory: z4.string(),
+  binding: z4.string().optional()
+}).optional();
+var observabilitySchema = z4.object({
+  enabled: z4.boolean().optional(),
+  head_sampling_rate: z4.number().min(0).max(1).optional()
+}).optional();
+var limitsSchema = z4.object({
+  cpu_ms: z4.number().optional()
+}).optional();
+var migrationSchema = z4.object({
+  tag: z4.string(),
+  new_classes: z4.array(z4.string()).optional(),
+  renamed_classes: z4.array(z4.object({
+    from: z4.string(),
+    to: z4.string()
+  })).optional(),
+  deleted_classes: z4.array(z4.string()).optional(),
+  new_sqlite_classes: z4.array(z4.string()).optional()
+});
+var wranglerConfigSchema = z4.object({
+  passthrough: z4.record(z4.string(), z4.unknown()).optional()
+}).optional();
+
+// src/config/schema.ts
+function getCurrentDate() {
+  const now = new Date;
+  return now.toISOString().split("T")[0];
+}
+var rootConfigShape = {
+  name: z5.string({
+    required_error: "Worker name is required"
+  }),
+  accountId: z5.string().optional(),
+  compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
+  compatibilityFlags: z5.array(z5.string()).optional().transform((flags = []) => normalizeCompatibilityFlags(flags)),
+  previews: previewsConfigSchema,
+  files: filesSchema,
+  bindings: bindingsSchema,
+  triggers: triggersSchema,
+  vars: z5.record(z5.string(), z5.string()).optional(),
+  secrets: z5.record(z5.string(), secretConfigSchema).optional(),
+  routes: z5.array(routeConfigSchema).optional(),
+  wsRoutes: z5.array(wsRouteConfigSchema).optional(),
+  assets: assetsConfigSchema,
+  limits: limitsSchema,
+  observability: observabilitySchema,
+  migrations: z5.array(migrationSchema).optional(),
+  rolldown: rolldownConfigSchema,
+  vite: viteConfigSchema,
+  wrangler: wranglerConfigSchema
+};
+var canonicalConfigSchema = z5.object({
+  ...rootConfigShape,
+  env: z5.record(z5.string(), envConfigSchemaInner).optional()
+});
+var configSchema = canonicalConfigSchema.strict();
+
+// src/config/resolve.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function mergeEnvironmentValue(base, override) {
+  if (override === undefined) {
+    return base;
+  }
+  if (Array.isArray(override)) {
+    return [...override];
+  }
+  if (isPlainObject(override)) {
+    const baseObject = isPlainObject(base) ? base : {};
+    const mergedObject = {
+      ...baseObject
+    };
+    for (const [key, value] of Object.entries(override)) {
+      mergedObject[key] = mergeEnvironmentValue(baseObject[key], value);
+    }
+    return mergedObject;
+  }
+  return override;
+}
+function mergeConfigForEnvironment(config, environment) {
+  if (!environment || !config.env?.[environment]) {
+    return config;
+  }
+  const mergedConfig = mergeEnvironmentValue(config, config.env[environment]);
+  return {
+    ...mergedConfig,
+    compatibilityFlags: normalizeCompatibilityFlags(mergedConfig.compatibilityFlags)
+  };
+}
+function resolveConfigForEnvironment(config, environment) {
+  const mergedConfig = mergeConfigForEnvironment(config, environment);
+  return materializePreviewScopedConfig(mergedConfig, {
+    environment
+  });
+}
+
+// src/config/binding-resolution-helpers.ts
+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 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 formatMissingBindings(missing) {
+  return missing.map(({ bindingName, resourceName }) => `${bindingName} → ${resourceName}`).join(", ");
+}
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join as join2, resolve } from "pathe";
+
+// src/config/framework-providers.ts
+import { readFile } from "node:fs/promises";
+import { join } from "pathe";
+var SVELTE_CONFIG_FILES = [
+  "svelte.config.js",
+  "svelte.config.mjs",
+  "svelte.config.ts",
+  "svelte.config.cjs"
+];
+async function readTextIfExists(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function readPackageDependencies(cwd) {
+  const packageJsonText = await readTextIfExists(join(cwd, "package.json"));
+  if (!packageJsonText) {
+    return null;
+  }
+  try {
+    const packageJson = JSON.parse(packageJsonText);
+    return {
+      ...packageJson.dependencies ?? {},
+      ...packageJson.devDependencies ?? {},
+      ...packageJson.peerDependencies ?? {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function findFirstExistingTextFile(cwd, candidates) {
+  for (const candidate of candidates) {
+    const fileText = await readTextIfExists(join(cwd, candidate));
+    if (fileText !== null) {
+      return fileText;
+    }
+  }
+  return null;
+}
+var svelteKitCloudflareProvider = {
+  id: "sveltekit-cloudflare",
+  async resolve(context) {
+    const dependencies = await readPackageDependencies(context.cwd);
+    if (!dependencies?.["@sveltejs/kit"] || !dependencies["@sveltejs/adapter-cloudflare"]) {
+      return null;
+    }
+    const svelteConfigText = await findFirstExistingTextFile(context.cwd, SVELTE_CONFIG_FILES);
+    if (!svelteConfigText) {
+      return null;
+    }
+    if (!/@sveltejs\/adapter-cloudflare|adapter-cloudflare/.test(svelteConfigText)) {
+      return null;
+    }
+    return {
+      id: this.id,
+      config: {
+        files: {
+          fetch: ".adapter-cloudflare/_worker.js"
+        },
+        assets: {
+          binding: "ASSETS",
+          directory: ".adapter-cloudflare"
+        }
+      }
+    };
+  }
+};
+var frameworkProviders = [
+  svelteKitCloudflareProvider
+];
+function hasFrameworkInferenceGap(config) {
+  return config.files?.fetch === undefined || config.assets?.directory === undefined || config.assets?.binding === undefined;
+}
+function mergeInferredConfig(config, inferredConfig) {
+  const mergedFiles = inferredConfig.files ? {
+    ...inferredConfig.files,
+    ...config.files ?? {}
+  } : config.files;
+  const mergedAssets = inferredConfig.assets ? {
+    ...inferredConfig.assets,
+    ...config.assets ?? {}
+  } : config.assets;
+  return {
+    ...config,
+    ...mergedFiles && { files: mergedFiles },
+    ...mergedAssets && { assets: mergedAssets }
+  };
+}
+async function applyFrameworkConfigProviders(config, context) {
+  if (!hasFrameworkInferenceGap(config)) {
+    return config;
+  }
+  for (const provider of frameworkProviders) {
+    const resolution = await provider.resolve({
+      ...context,
+      config
+    });
+    if (!resolution) {
+      continue;
+    }
+    return mergeInferredConfig(config, resolution.config);
+  }
+  return config;
+}
+
+// src/config/loader.ts
+var CONFIG_FILES = [
+  "devflare.config.ts",
+  "devflare.config.mts",
+  "devflare.config.js",
+  "devflare.config.mjs"
+];
+function resolveC12Module(cwd) {
+  const requireFromCwd = createRequire(join2(cwd, "__devflare__.cjs"));
+  try {
+    return requireFromCwd("c12");
+  } catch {
+    return createRequire(import.meta.url)("c12");
+  }
+}
+function hasWorkspacePackageJson(cwd) {
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.workspaces !== undefined;
+  } catch {
+    return false;
+  }
+}
+function resolveWorkspaceDotenvDirectory(cwd) {
+  let current = cwd;
+  let nearestDotenvDirectory;
+  while (true) {
+    if (existsSync(join2(current, ".env"))) {
+      nearestDotenvDirectory ??= current;
+      if (hasWorkspacePackageJson(current)) {
+        return current;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return nearestDotenvDirectory;
+    }
+    current = parent;
+  }
+}
+async function loadWorkspaceDotenv(cwd, setupDotenv) {
+  const dotenvDirectory = resolveWorkspaceDotenvDirectory(cwd);
+  if (!dotenvDirectory) {
+    return;
+  }
+  await setupDotenv({
+    cwd: dotenvDirectory,
+    fileName: ".env",
+    env: process.env
+  });
+}
+async function resolveConfigPath(cwd) {
+  for (const file of CONFIG_FILES) {
+    const path = join2(cwd, file);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return;
+}
+async function loadConfig(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const configFile = options.configFile ?? "devflare.config";
+  const { loadConfig: c12LoadConfig, setupDotenv } = resolveC12Module(cwd);
+  await loadWorkspaceDotenv(cwd, setupDotenv);
+  const { config, configFile: loadedFile } = await c12LoadConfig({
+    name: "devflare",
+    cwd,
+    configFile,
+    defaultConfig: undefined,
+    rcFile: false,
+    globalRc: false,
+    dotenv: false
+  });
+  if (!config || !loadedFile) {
+    throw new ConfigNotFoundError(cwd, configFile);
+  }
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    throw new ConfigValidationError(result.error.issues, loadedFile);
+  }
+  return applyFrameworkConfigProviders(result.data, {
+    cwd,
+    configPath: loadedFile
+  });
+}
+
+class ConfigNotFoundError extends Error {
+  cwd;
+  configFile;
+  code = "CONFIG_NOT_FOUND";
+  constructor(cwd, configFile) {
+    super(`Config file not found in ${cwd}.
+` + `Expected one of: ${CONFIG_FILES.join(", ")}
+` + `Run 'devflare init' to create a new config.`);
+    this.cwd = cwd;
+    this.configFile = configFile;
+    this.name = "ConfigNotFoundError";
+  }
+}
+
+class ConfigValidationError extends Error {
+  issues;
+  configFile;
+  code = "CONFIG_VALIDATION_ERROR";
+  constructor(issues, configFile) {
+    const issueMessages = issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join(`
+`);
+    super(`Invalid config in ${configFile}:
+${issueMessages}`);
+    this.issues = issues;
+    this.configFile = configFile;
+    this.name = "ConfigValidationError";
+  }
+}
+
+// src/config/resolve-phased.ts
+function brandAsLocalConfig(config) {
+  return config;
+}
+function brandAsDeployConfig(config) {
+  return config;
+}
+async function resolveResources(config, options) {
+  const envMerged = mergeConfigForEnvironment(config, options.environment);
+  const previewMerged = materializePreviewScopedConfig(envMerged, {
+    environment: options.environment,
+    ...options.preview
+  });
+  switch (options.phase) {
+    case "build": {
+      return previewMerged;
+    }
+    case "local": {
+      const resolved = resolveConfigForLocalRuntime(previewMerged, undefined);
+      return resolved;
+    }
+    case "deploy": {
+      if (options.provision) {
+        const prepared = await prepareMaterializedConfigResourcesForDeploy(previewMerged, options.preparation ?? {
+          accountId: options.accountId,
+          cloudflare: options.cloudflare
+        });
+        return prepared.config;
+      }
+      const materialized = await resolveMaterializedConfigResources(previewMerged, {
+        accountId: options.accountId,
+        cloudflare: options.cloudflare
+      });
+      return materialized;
+    }
+  }
+}
+
+// src/config/resource-resolution.ts
+var defaultCloudflareApi = {
+  getPrimaryAccount,
+  getEffectiveAccountId,
+  listKVNamespaces,
+  listD1Databases,
+  listHyperdrives
+};
+
+class ConfigResourceResolutionError extends Error {
+  code = "CONFIG_RESOURCE_RESOLUTION_ERROR";
+  constructor(message, cause) {
+    super(message);
+    this.name = "ConfigResourceResolutionError";
+    if (cause !== undefined) {
+      this.cause = cause;
+    }
+  }
+}
+function resolveCloudflareApi(overrides) {
+  return {
+    ...defaultCloudflareApi,
+    ...overrides ?? {}
+  };
+}
+async function resolveLookupAccountId(config, options, cloudflareApi) {
+  const explicitAccountId = options.accountId ?? config.accountId;
+  if (explicitAccountId) {
+    return explicitAccountId;
+  }
+  let primaryAccount;
+  try {
+    primaryAccount = await cloudflareApi.getPrimaryAccount();
+  } catch (error) {
+    throw new ConfigResourceResolutionError("Could not resolve Cloudflare-backed resource names 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 resolve Cloudflare-backed resource names 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 name-based resource resolution after selecting primary account ${primaryAccount.id}.`, error);
+  }
+}
+async function resolveResourceIdsByName(pendingBindings, options) {
+  if (pendingBindings.length === 0) {
+    return new Map;
+  }
+  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 missingBindings = pendingBindings.filter(({ resourceName }) => {
+    return !idsByName.has(resourceName);
+  });
+  if (missingBindings.length > 0) {
+    throw new ConfigResourceResolutionError(options.missingFailureMessage(missingBindings));
+  }
+  return idsByName;
+}
+function resolveConfigForLocalRuntime(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const kvBindings = resolvedConfig.bindings?.kv;
+  const d1Bindings = resolvedConfig.bindings?.d1;
+  const hyperdriveBindings = resolvedConfig.bindings?.hyperdrive;
+  if (!kvBindings && !d1Bindings && !hyperdriveBindings) {
+    return brandAsLocalConfig(resolvedConfig);
+  }
+  const pendingKVNameBindings = collectPendingNameBindings(kvBindings, normalizeKVNameBinding);
+  return brandAsLocalConfig(withResolvedIdBindings(resolvedConfig, {
+    kv: kvBindings ? materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : undefined,
+    d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : undefined,
+    hyperdrive: hyperdriveBindings ? materializeIdBindings(hyperdriveBindings, getLocalHyperdriveConfigIdentifier) : undefined
+  }));
+}
+async function resolveMaterializedConfigResources(resolvedConfig, options = {}) {
+  const kvBindings = resolvedConfig.bindings?.kv;
+  const d1Bindings = resolvedConfig.bindings?.d1;
+  const hyperdriveBindings = resolvedConfig.bindings?.hyperdrive;
+  if (!kvBindings && !d1Bindings && !hyperdriveBindings) {
+    return brandAsDeployConfig(resolvedConfig);
+  }
+  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) {
+    return brandAsDeployConfig(withResolvedIdBindings(resolvedConfig, {
+      kv: kvBindings ? materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : undefined,
+      d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : undefined,
+      hyperdrive: hyperdriveBindings ? materializeIdBindings(hyperdriveBindings, getLocalHyperdriveConfigIdentifier) : undefined
+    }));
+  }
+  const cloudflareApi = resolveCloudflareApi(options.cloudflare);
+  const accountId = await resolveLookupAccountId(resolvedConfig, options, cloudflareApi);
+  const namespaceIdsByName = await resolveResourceIdsByName(pendingKVNameBindings, {
+    listResources: async () => cloudflareApi.listKVNamespaces(accountId),
+    listFailureMessage: `Could not list KV namespaces for Cloudflare account ${accountId} while resolving name-based KV bindings.`,
+    missingFailureMessage: (missingBindings) => {
+      return `Could not find KV namespace(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}.`;
+    }
+  });
+  const databaseIdsByName = await resolveResourceIdsByName(pendingD1NameBindings, {
+    listResources: async () => cloudflareApi.listD1Databases(accountId),
+    listFailureMessage: `Could not list D1 databases for Cloudflare account ${accountId} while resolving name-based D1 bindings.`,
+    missingFailureMessage: (missingBindings) => {
+      return `Could not find D1 database(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}.`;
+    }
+  });
+  const hyperdriveIdsByName = await resolveResourceIdsByName(pendingHyperdriveNameBindings, {
+    listResources: async () => cloudflareApi.listHyperdrives(accountId),
+    listFailureMessage: `Could not list Hyperdrive configurations for Cloudflare account ${accountId} while resolving name-based Hyperdrive bindings.`,
+    missingFailureMessage: (missingBindings) => {
+      return `Could not find Hyperdrive configuration(s) for ${formatMissingBindings(missingBindings)} in Cloudflare account ${accountId}.`;
+    }
+  });
+  return brandAsDeployConfig(withResolvedIdBindings(resolvedConfig, {
+    kv: materializeResolvedNameBindings(kvBindings, normalizeKVNameBinding, namespaceIdsByName),
+    d1: materializeResolvedNameBindings(d1Bindings, normalizeD1NameBinding, databaseIdsByName),
+    hyperdrive: materializeResolvedNameBindings(hyperdriveBindings, normalizeHyperdriveNameBinding, hyperdriveIdsByName)
+  }));
+}
+async function resolveConfigResources(config, options = {}) {
+  return resolveResources(config, {
+    phase: "deploy",
+    environment: options.environment,
+    preview: {
+      environment: options.environment,
+      env: options.env,
+      identifier: options.identifier
+    },
+    accountId: options.accountId,
+    cloudflare: options.cloudflare
+  });
+}
+async function loadResolvedConfig(options = {}) {
+  const config = await loadConfig(options);
+  return resolveConfigResources(config, options);
+}
+
+// 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 resolveLookupAccountId2(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: brandAsDeployConfig(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: brandAsDeployConfig(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 resolveLookupAccountId2(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: brandAsDeployConfig(config),
+      created,
+      existing,
+      warnings
+    };
+  } catch (err) {
+    throw decorateOrphanError(err, created);
+  }
+}
+async function prepareConfigResourcesForDeploy(config, options = {}) {
+  const resolvedConfig = await resolveResources(config, {
+    phase: "build",
+    environment: options.environment,
+    preview: {
+      environment: options.environment,
+      env: options.env,
+      identifier: options.identifier
+    }
+  });
+  return prepareMaterializedConfigResourcesForDeploy(resolvedConfig, {
+    accountId: options.accountId,
+    cloudflare: options.cloudflare,
+    describeOnly: options.describeOnly
+  });
+}
+
+export { browserBindingSchema, getSingleBrowserBindingName, normalizeDOBinding, normalizeD1Binding, normalizeKVBinding, normalizeHyperdriveBinding, getLocalKVNamespaceIdentifier, getLocalD1DatabaseIdentifier, configSchema, mergeConfigForEnvironment, resolveConfigForEnvironment, prepareConfigResourcesForDeploy, resolveResources, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };