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

package/dist/index-tmmcf4m6.js

@@ -0,0 +1,808 @@
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  listD1Databases,
+  listHyperdrives,
+  listKVNamespaces
+} 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 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()
+}).optional();
+
+// src/config/schema-normalization.ts
+function getSingleBrowserBindingName(bindings) {
+  const bindingNames = getBrowserBindingNames(bindings);
+  if (bindingNames.length === 0) {
+    return;
+  }
+  if (bindingNames.length > 1) {
+    throw new Error(formatBrowserBindingLimitMessage(bindingNames));
+  }
+  return bindingNames[0];
+}
+function normalizeDOBinding(config) {
+  if (typeof config === "string") {
+    return { className: config };
+  }
+  return {
+    className: config.className,
+    scriptName: config.scriptName,
+    __ref: config.__ref
+  };
+}
+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/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/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 ?? {}
+  };
+}
+function materializeIdBindings(bindings, resolveId) {
+  return Object.fromEntries(Object.entries(bindings).map(([bindingName, bindingConfig]) => {
+    return [bindingName, { id: resolveId(bindingConfig) }];
+  }));
+}
+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 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 } : {}
+    }
+  };
+}
+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);
+  }
+}
+function formatMissingBindings(missing) {
+  return missing.map(({ bindingName, resourceName }) => `${bindingName} → ${resourceName}`).join(", ");
+}
+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 resolvedConfig;
+  }
+  return 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 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 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 withResolvedIdBindings(resolvedConfig, {
+    kv: materializeResolvedNameBindings(kvBindings, normalizeKVNameBinding, namespaceIdsByName),
+    d1: materializeResolvedNameBindings(d1Bindings, normalizeD1NameBinding, databaseIdsByName),
+    hyperdrive: materializeResolvedNameBindings(hyperdriveBindings, normalizeHyperdriveNameBinding, hyperdriveIdsByName)
+  });
+}
+async function resolveConfigResources(config, options = {}) {
+  const resolvedConfig = materializePreviewScopedConfig(mergeConfigForEnvironment(config, options.environment), {
+    environment: options.environment,
+    env: options.env,
+    identifier: options.identifier
+  });
+  return resolveMaterializedConfigResources(resolvedConfig, {
+    accountId: options.accountId,
+    cloudflare: options.cloudflare
+  });
+}
+async function loadResolvedConfig(options = {}) {
+  const config = await loadConfig(options);
+  return resolveConfigResources(config, options);
+}
+
+export { getSingleBrowserBindingName, normalizeDOBinding, normalizeD1Binding, normalizeKVBinding, normalizeHyperdriveBinding, getLocalKVNamespaceIdentifier, getLocalD1DatabaseIdentifier, getLocalHyperdriveConfigIdentifier, configSchema, mergeConfigForEnvironment, resolveConfigForEnvironment, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };